feat: 规范化middleware书写方式

Author: hubvue

src/decorator/httpRouter.ts

@@ -1,5 +1,5 @@
 import { META_ROUTER } from '../constants'
-import { RouteAop } from '../types'
+import { RouteAop, Tag } from '../types'
 import { Middleware } from 'koa'
 // create http request method decorator
 /**
@@ -29,37 +29,25 @@ export const All = createHTTPMethodDecorator('get', 'post', 'put', 'delete')
  */
 type HttpMethodReturnType = (
   path: string,
-  aopPlugins?: RouteAop
+  aopMiddles?: RouteAop
 ) => MethodDecorator
 function createHTTPMethodDecorator(
   ...methods: Array<string>
 ): HttpMethodReturnType {
-  return (path, aopPlugins = {}): MethodDecorator => (
+  return (path, aopMiddles = {}): MethodDecorator => (
     target,
     propertyKey,
     descripator
   ) => {
-    let beforePlugins: Set<Middleware> = new Set()
-    let afterPlugins: Set<Middleware> = new Set()
-    const before = aopPlugins.before
-    const after = aopPlugins.after
-    if (before) {
-      for (let plugin of before) {
-        beforePlugins.add(plugin)
-      }
-    }
-    if (after) {
-      for (let plugin of after) {
-        afterPlugins.add(plugin)
-      }
-    }
+    let beforeMiddlesType: Array<Tag> = aopMiddles.before || []
+    let afterMiddlesType: Array<Tag> = aopMiddles.after || []
     Reflect.defineMetadata(
       META_ROUTER,
       {
         methods,
         path,
-        beforePlugins,
-        afterPlugins
+        beforeMiddlesType,
+        afterMiddlesType
       },
       descripator.value
     )

src/index.ts

@@ -9,3 +9,5 @@ export * from './core'
 export * from './core/controller'
 
 export * from './decorator/params'
+
+export * from './runtime/koa/middleware'

src/runtime/koa/index.ts

@@ -1,11 +1,11 @@
 import * as Koa from 'koa'
 import * as Router from 'koa-router'
-import { installMiddleware } from './middleware'
+import { installMiddleware, middlePoll } from './middleware/index'
 import parseParamsDecorator from './params'
 import { RuntimeOptions, RouteMetaInterface } from '../../types'
 import { META_ROUTER } from '../../constants'
 import { resolvePath } from '../../utils'
-
+const Logger = console
 /**
  * @description 注册中间件调用koa启动服务
  * @param controllers
@@ -14,9 +14,8 @@ import { resolvePath } from '../../utils'
 function KoaRuntime(controllers: Set<any>, options: RuntimeOptions) {
   const app: Koa = new Koa()
   const router: Router = new Router()
-  const plugins: Array<Koa.Middleware> = options.plugins || []
-  // 注册中间件
-  installMiddleware(app, plugins)
+  // 注册全局中间件
+  installMiddleware(app, middlePoll.golbalMiddle)
   for (let controllerMeta of controllers) {
     const { path: rootPath, controller } = controllerMeta
     if (!rootPath) {
@@ -30,12 +29,31 @@ function KoaRuntime(controllers: Set<any>, options: RuntimeOptions) {
           controller[name]
         )
         if (metaRoute) {
-          const { methods, path, beforePlugins, afterPlugins } = metaRoute
+          const {
+            methods,
+            path,
+            beforeMiddlesType,
+            afterMiddlesType
+          } = metaRoute
+          const beforeMiddles = beforeMiddlesType.map(middleType => {
+            if (middlePoll.routeMiddle.has(middleType)) {
+              return middlePoll.routeMiddle.get(middleType)
+            } else {
+              Logger.error(`[kever|err]: ${String(middleType)} unregistered！`)
+            }
+          })
+          const afterMiddles = afterMiddlesType.map(middleType => {
+            if (middlePoll.routeMiddle.has(middleType)) {
+              return middlePoll.routeMiddle.get(middleType)
+            } else {
+              Logger.error(`[kever|err]: ${String(middleType)} unregistered！`)
+            }
+          })
           const routePath: string = resolvePath(rootPath, path)
           for (let method of methods) {
             router[method](
               routePath,
-              ...beforePlugins,
+              ...beforeMiddles,
               async (ctx: Koa.Context, next: Koa.Next) => {
                 // 将ctx和next绑定到controller实例上
                 controller['ctx'] = ctx
@@ -44,7 +62,7 @@ function KoaRuntime(controllers: Set<any>, options: RuntimeOptions) {
                 const routeParams = parseParamsDecorator(controller[name], ctx)
                 await controller[name](...routeParams)
               },
-              ...afterPlugins
+              ...afterMiddles
             )
           }
         }

src/runtime/koa/middleware/index.ts

@@ -0,0 +1,44 @@
+import * as Koa from 'koa'
+import * as koaBody from 'koa-body'
+import koaCookie from 'koa-cookie'
+import { Tag } from '../../../types/index'
+
+export const installMiddleware = (app: Koa, middles: Set<Koa.Middleware>) => {
+  app.use(koaBody())
+  app.use(koaCookie())
+  for (let middle of middles) {
+    app.use(middle)
+  }
+}
+
+/**
+ * @description 基础的中间件接口，所有的中间件都要继承这个东西
+ */
+export interface BaseMiddle {
+  ready(): void
+}
+
+interface MiddlePoll<T> {
+  routeMiddle: Map<Tag, T>
+  golbalMiddle: Set<T>
+}
+export const middlePoll: MiddlePoll<Koa.Middleware> = {
+  routeMiddle: new Map(),
+  golbalMiddle: new Set()
+}
+
+type registerMiddleType = (
+  tag: Tag
+) => <T extends { new (...args: any[]): {}; ready(): void }>(target: T) => void
+
+export const registerMiddle: registerMiddleType = (tag: Tag) => target => {
+  const instance: BaseMiddle = new target() as BaseMiddle
+  middlePoll.routeMiddle.set(tag, instance.ready)
+}
+
+export const registerGlobalMiddle: registerMiddleType = (
+  tag: Tag
+) => target => {
+  const instance: BaseMiddle = new target() as BaseMiddle
+  middlePoll.golbalMiddle.add(instance.ready)
+}

src/types/index.ts

@@ -2,14 +2,14 @@ import { Middleware } from 'koa'
 
 export type Tag = symbol | string
 export type RuntimeOptions = Partial<Record<'plugins', Array<Middleware>>>
-export type RouteAop = Partial<Record<'before' | 'after', Array<Middleware>>>
+export type RouteAop = Partial<Record<'before' | 'after', Array<Tag>>>
 export type InjectMetaType = Record<'propertyKey' | 'tag', Tag>
 
 export interface RouteMetaInterface {
   methods: Array<string>
   path: string
-  beforePlugins: Array<Middleware>
-  afterPlugins: Array<Middleware>
+  beforeMiddlesType: Array<Tag>
+  afterMiddlesType: Array<Tag>
 }
 
 export interface ControllerInterface {