feat(nestjs): add middleware support (#21)

nailiable · nailiable · commit 53c35bd6c1da · 2025-04-19T17:41:39.000+08:00
diff --git a/packages/adapter/adapter-nestjs/src/middleware/middleware-config-proxy.ts b/packages/adapter/adapter-nestjs/src/middleware/middleware-config-proxy.ts
@@ -1,71 +1,55 @@
-import type { MiddlewareConfigProxy, MiddlewareConsumer, NestMiddleware, RouteInfo, Type } from '@nestjs/common/interfaces'
-import type { IPluginContext } from '@unioc/core'
-import type { MiddlewareConsumerBuilder } from './middleware-customer'
-import { isClass } from '@unioc/shared'
-
-export interface IResolvedMiddleware {
-  handler(...args: any[]): any
-  instance?: NestMiddleware
-  routes: (string | Type<any> | RouteInfo)[]
-}
+import type { MiddlewareConfigProxy, MiddlewareConsumer, RouteInfo, Type } from '@nestjs/common/interfaces'
+import type { MiddlewareType } from './middleware-customer'
+import { MiddlewareCustomerBuilder } from './middleware-customer'
 
 export class MiddlewareConfigProxyBuilder implements MiddlewareConfigProxy {
-  private _excludedRoutes: (string | RouteInfo)[] = []
-  private _routes: (string | Type<any> | RouteInfo)[] = []
-  private _middleware: (Type<any> | ((...args: any[]) => any))[] = []
-
-  constructor(private readonly _middlewareConsumer: MiddlewareConsumerBuilder) {}
+  constructor(
+    private readonly _middlewareCustomerBuilder: MiddlewareCustomerBuilder,
+    private readonly _middlewares: MiddlewareType[],
+  ) {}
 
-  protected getMiddlewareConsumer(): MiddlewareConsumer {
-    this._middlewareConsumer.add(this)
-    return this._middlewareConsumer
+  getMiddlewareCustomerBuilder(): MiddlewareCustomerBuilder {
+    return this._middlewareCustomerBuilder
   }
 
   exclude(...routes: (string | RouteInfo)[]): MiddlewareConfigProxy {
-    this._excludedRoutes = [...this._excludedRoutes, ...routes]
+    for (const route of routes) {
+      for (const middleware of this._middlewares) {
+        const data = this.getMiddlewareCustomerBuilder().getMiddlewareMap().get(middleware)
+        if (!data) {
+          this.getMiddlewareCustomerBuilder().getMiddlewareMap().set(middleware, {
+            includedRoutes: [],
+            excludedRoutes: [route],
+          })
+        }
+        else {
+          data.excludedRoutes.push(route)
+        }
+      }
+    }
+
     return this
   }
 
   forRoutes(...routes: (string | Type<any> | RouteInfo)[]): MiddlewareConsumer {
-    this._routes = [...this._routes, ...routes]
-    return this.getMiddlewareConsumer()
-  }
-
-  public getExcludedRoutes(): (string | RouteInfo)[] {
-    return this._excludedRoutes
-  }
-
-  public getRoutes(): (string | Type<any> | RouteInfo)[] {
-    return this._routes
-  }
-
-  public setMiddleware(middleware: (Type<any> | ((...args: any[]) => any))[]): void {
-    this._middleware = middleware
-  }
-
-  public async resolveMiddlewares(ctx: IPluginContext): Promise<IResolvedMiddleware[]> {
-    const handlers: IResolvedMiddleware[] = []
-
-    for (const middleware of this._middleware) {
-      if (isClass(middleware)) {
-        const instance: NestMiddleware = await ctx.createClass(middleware).resolve()
-        if (instance && typeof instance === 'object' && 'use' in instance && typeof instance.use === 'function') {
-          handlers.push({
-            handler: instance.use,
-            instance,
-            routes: this._routes,
+    for (const route of routes) {
+      for (const middleware of this._middlewares) {
+        const data = this.getMiddlewareCustomerBuilder().getMiddlewareMap().get(middleware)
+        if (!data) {
+          this.getMiddlewareCustomerBuilder().getMiddlewareMap().set(middleware, {
+            includedRoutes: [],
+            excludedRoutes: [route],
           })
         }
-      }
-      else {
-        handlers.push({
-          handler: middleware,
-          instance: undefined,
-          routes: this._routes,
-        })
+        else {
+          data.excludedRoutes.push(route)
+        }
       }
     }
 
-    return handlers
+    return new MiddlewareCustomerBuilder(
+      this.getMiddlewareCustomerBuilder().getPluginContext(),
+      this.getMiddlewareCustomerBuilder().getMiddlewareMap(),
+    )
   }
 }
diff --git a/packages/adapter/adapter-nestjs/src/middleware/middleware-customer.ts b/packages/adapter/adapter-nestjs/src/middleware/middleware-customer.ts
@@ -1,22 +1,52 @@
 import type { MiddlewareConsumer, Type } from '@nestjs/common'
-import type { MiddlewareConfigProxy } from '@nestjs/common/interfaces'
+import type { MiddlewareConfigProxy, RouteInfo } from '@nestjs/common/interfaces'
+import type { IPluginContext } from '@unioc/core'
+import type { Awaitable } from '@unioc/shared'
 import { MiddlewareConfigProxyBuilder } from './middleware-config-proxy'
 
-export class MiddlewareConsumerBuilder implements MiddlewareConsumer {
-  private _middlewareConfigs: MiddlewareConfigProxyBuilder[] = []
+export type MiddlewareType = Type | ((...args: any[]) => Awaitable<unknown>)
 
-  apply(...middleware: (Type<any> | ((...args: any[]) => any))[]): MiddlewareConfigProxy {
-    const config = new MiddlewareConfigProxyBuilder(this)
-    config.setMiddleware(middleware)
-    return config
+export interface IMiddlewareApplyData {
+  includedRoutes: (string | RouteInfo)[]
+  excludedRoutes: (string | Type<any> | RouteInfo)[]
+}
+
+export class MiddlewareCustomerBuilder implements MiddlewareConsumer {
+  constructor(
+    private readonly _pluginContext: IPluginContext,
+    private readonly _middlewareMap: Map<MiddlewareType, IMiddlewareApplyData> = new Map<MiddlewareType, IMiddlewareApplyData>(),
+  ) {}
+
+  getPluginContext(): IPluginContext {
+    return this._pluginContext
+  }
+
+  getMiddlewareMap(): Map<MiddlewareType, IMiddlewareApplyData> {
+    return this._middlewareMap
   }
 
-  add(...middlewareConfigs: MiddlewareConfigProxyBuilder[]): MiddlewareConsumer {
-    this._middlewareConfigs = [...this._middlewareConfigs, ...middlewareConfigs]
-    return this
+  apply(...middlewares: MiddlewareType[]): MiddlewareConfigProxy {
+    for (const middleware of middlewares) {
+      if (!this.getMiddlewareMap().has(middleware)) {
+        this.getMiddlewareMap().set(middleware, {
+          includedRoutes: [],
+          excludedRoutes: [],
+        })
+      }
+    }
+    return new MiddlewareConfigProxyBuilder(this, middlewares)
   }
 
-  public getMiddlewareConfigs(): MiddlewareConfigProxyBuilder[] {
-    return this._middlewareConfigs
+  merge(preMerge: Map<MiddlewareType, IMiddlewareApplyData>): Map<MiddlewareType, IMiddlewareApplyData> {
+    for (const [preMergeMiddleware, preMergeData] of preMerge.entries()) {
+      for (const [middleware, data] of this.getMiddlewareMap().entries()) {
+        if (preMergeMiddleware === middleware) {
+          data.includedRoutes = [...data.includedRoutes, ...preMergeData.includedRoutes]
+          data.excludedRoutes = [...data.excludedRoutes, ...preMergeData.excludedRoutes]
+          this.getMiddlewareMap().set(middleware, data)
+        }
+      }
+    }
+    return this.getMiddlewareMap()
   }
 }
diff --git a/packages/adapter/adapter-nestjs/src/nest-resolver.ts b/packages/adapter/adapter-nestjs/src/nest-resolver.ts
@@ -9,10 +9,13 @@ export class NestJSResolver {
     return this._pluginContext
   }
 
+  isResolved: boolean = false
+
   async resolveModule(module: ModuleMetadata): Promise<this> {
     await this.resolveImports(module.imports)
     await this.resolveProviders(module.providers)
     await this.resolveControllers(module.controllers)
+    this.isResolved = true
     return this
   }
 
@@ -21,14 +24,20 @@ export class NestJSResolver {
   private readonly _controllers = new Set<IClassWrapper>()
 
   getResolvedModules(): IClassWrapper[] {
+    if (!this.isResolved)
+      throw new Error('NestJSResolver is not resolved yet, please call resolveModule first.')
     return Array.from(this._modules)
   }
 
   getResolvedProviders(): IClassWrapper[] {
+    if (!this.isResolved)
+      throw new Error('NestJSResolver is not resolved yet, please call resolveModule first.')
     return Array.from(this._providers)
   }
 
   getResolvedControllers(): IClassWrapper[] {
+    if (!this.isResolved)
+      throw new Error('NestJSResolver is not resolved yet, please call resolveModule first.')
     return Array.from(this._controllers)
   }
 
diff --git a/packages/adapter/adapter-nestjs/src/plugin.ts b/packages/adapter/adapter-nestjs/src/plugin.ts
@@ -1,10 +1,9 @@
-import type { InjectionToken, ModuleMetadata, NestModule } from '@nestjs/common'
+import type { InjectionToken, ModuleMetadata } from '@nestjs/common'
 import type { IPlugin } from '@unioc/core'
 import type { IClass } from '@unioc/shared'
 import { PROPERTY_DEPS_METADATA, SELF_DECLARED_DEPS_METADATA } from '@nestjs/common/constants.js'
 import { AbstractRestfulBootstrap } from '@unioc/web'
 import { ErrorCollector } from './error-collector'
-import { MiddlewareConsumerBuilder } from './middleware/middleware-customer'
 import { NestJSResolver } from './nest-resolver'
 import { NestJSRestfulHandler } from './restful/restful-handler'
 import { NestJSRestfulScanner } from './restful/restful-scanner'
@@ -44,28 +43,10 @@ export function NestJS(options: NestJS.Options = {}): IPlugin {
         return
       }
 
-      const scanner = new NestJSRestfulScanner(this)
+      const scanner = new NestJSRestfulScanner(this, nestJSResolver.getResolvedModules())
       bootstrap.addRestfulScanner(scanner)
       bootstrap.createValue(scanner, NestJSRestfulScanner)
       await scanner.resolveAll()
-
-      // apply restful middlewares
-      const modules = nestJSResolver.getResolvedModules()
-      const middlewareConsumer = new MiddlewareConsumerBuilder()
-
-      for (const moduleWrapper of modules) {
-        const resolvedInstance: NestModule = await moduleWrapper.resolve()
-        if (resolvedInstance && typeof resolvedInstance === 'object' && 'configure' in resolvedInstance && typeof resolvedInstance.configure === 'function') {
-          await resolvedInstance.configure(middlewareConsumer)
-        }
-      }
-
-      // apply middlewares
-      const middlewareConfigs = middlewareConsumer.getMiddlewareConfigs()
-      for (const middlewareConfig of middlewareConfigs) {
-        const _middlewares = await middlewareConfig.resolveMiddlewares(this)
-        // TODO
-      }
     },
 
     async resolve(ctx) {
diff --git a/packages/adapter/adapter-nestjs/src/restful/restful-handler.ts b/packages/adapter/adapter-nestjs/src/restful/restful-handler.ts
@@ -13,7 +13,7 @@ export class NestJSRestfulHandler implements IRestfulConnect.Handler {
     return this._restfulScanner
   }
 
-  private _getParamValue(currentMetadata: INestJSMethodParamMetadata, ctx: IRestfulConnect.WebContext): unknown {
+  protected getParamValue(currentMetadata: INestJSMethodParamMetadata, ctx: IRestfulConnect.WebContext): unknown {
     switch (currentMetadata.paramType) {
       case 'body':
         if (typeof ctx.body === 'object' && ctx.body !== null)
@@ -86,7 +86,7 @@ export class NestJSRestfulHandler implements IRestfulConnect.Handler {
       if (!currentMetadata)
         continue
       if (currentMetadata.paramType !== 'body' && currentMetadata.paramType !== 'query' && currentMetadata.paramType !== 'param' && currentMetadata.paramType !== 'custom') {
-        params[i] = this._getParamValue(currentMetadata, ctx)
+        params[i] = this.getParamValue(currentMetadata, ctx)
         continue
       }
 
@@ -95,7 +95,7 @@ export class NestJSRestfulHandler implements IRestfulConnect.Handler {
         .getRestfulScanner()
         .executePipe(pipes, {
           type: currentMetadata.paramType,
-          value: this._getParamValue(currentMetadata, ctx),
+          value: this.getParamValue(currentMetadata, ctx),
           data: currentMetadata.data as string,
           metatype: currentParamType,
           ...ctx,
@@ -166,11 +166,13 @@ export class NestJSRestfulHandler implements IRestfulConnect.Handler {
     } as const
 
     try {
-      // 1. Build params with pipes
+      // 1. Execute middlewares
+      await this.getRestfulScanner().executeMiddlewares(methodWrapper, ctx)
+      // 2. Build params with pipes
       methodArguments = await this.buildParams(methodWrapper, ctx)
-      // 2. Execute guards
+      // 3. Execute guards
       await this.executeGuards(methodWrapper, methodArguments)
-      // 3. Execute the controller method
+      // 4. Execute the controller method
       const result = await methodWrapper.execute(methodArguments, extraOptions)
       // 4. TODO: Execute the interceptors
       // 5. Send the ending response
diff --git a/packages/adapter/adapter-nestjs/src/restful/restful-scanner.ts b/packages/adapter/adapter-nestjs/src/restful/restful-scanner.ts
@@ -1,17 +1,25 @@
-import type { ArgumentMetadata, ArgumentsHost, CanActivate, ExceptionFilter, ExecutionContext, PipeTransform } from '@nestjs/common'
-import type { IArgument, IPluginContext } from '@unioc/core'
+import type { ArgumentMetadata, ArgumentsHost, CanActivate, ExceptionFilter, ExecutionContext, NestMiddleware, NestModule, PipeTransform } from '@nestjs/common'
+import type { IArgument, IClassWrapper, IPluginContext } from '@unioc/core'
 import type { IClass } from '@unioc/shared'
 import type { IHttpParam, IRestfulConnect, IRestfulScanner } from '@unioc/web'
+import type { IMiddlewareApplyData, MiddlewareType } from '../middleware/middleware-customer'
 import type { NestJSMethodOperator } from './method-operator'
+import type { NestJSMethodWrapper } from './method-wrapper'
 import { CONTROLLER_WATERMARK, FILTER_CATCH_EXCEPTIONS } from '@nestjs/common/constants.js'
+import { isClass } from '@unioc/shared'
 import { RestfulScanner } from '@unioc/web'
+import { MiddlewareCustomerBuilder } from '../middleware/middleware-customer'
 import { NestJSControllerWrapper } from './controller-wrapper'
 import { NestJSRestfulHandler } from './restful-handler'
 
 export interface INestJSPipeArgument extends IArgument, ArgumentMetadata, Partial<Record<IHttpParam, unknown>> {}
 export type INestJSFilterCatchType = 'done' | 'no-match'
 
 export class NestJSRestfulScanner extends RestfulScanner implements IRestfulScanner {
+  constructor(pluginContext: IPluginContext, private readonly _modules: IClassWrapper[]) {
+    super(pluginContext)
+  }
+
   override getPluginContext(): IPluginContext {
     return super.getPluginContext()
   }
@@ -134,6 +142,74 @@ export class NestJSRestfulScanner extends RestfulScanner implements IRestfulScan
     return true
   }
 
+  private _middlewareCustomerMap: Map<MiddlewareType, IMiddlewareApplyData> = new Map<MiddlewareType, IMiddlewareApplyData>()
+
+  async resolveMiddlewares(): Promise<void> {
+    for (const moduleWrapper of this._modules) {
+      const resolveInstance: NestModule = await moduleWrapper.resolve()
+      if (!('configure' in resolveInstance) || typeof resolveInstance.configure !== 'function')
+        continue
+
+      const middlewareCustomer = new MiddlewareCustomerBuilder(this.getPluginContext())
+      await resolveInstance.configure(middlewareCustomer)
+      this._middlewareCustomerMap = middlewareCustomer.merge(this._middlewareCustomerMap)
+    }
+  }
+
+  async executeMiddlewares(methodWrapper: NestJSMethodWrapper, ctx: IRestfulConnect.WebContext): Promise<void> {
+    const fullPaths = methodWrapper.findAll().map(o => o.getFullPath())
+    const classTarget = methodWrapper.getControllerOperator().getControllerWrapper().getClassWrapper().getTarget()
+    const matchedMiddlewares: MiddlewareType[] = []
+
+    for (const [middleware, data] of this._middlewareCustomerMap.entries()) {
+      for (const route of data.includedRoutes) {
+        if (isClass(route)) {
+          if (classTarget === route) {
+            matchedMiddlewares.push(middleware)
+          }
+        }
+        else if (typeof route === 'string') {
+          if (fullPaths.includes(route)) {
+            matchedMiddlewares.push(middleware)
+          }
+        }
+        else {
+          if (fullPaths.includes(route.path)) {
+            matchedMiddlewares.push(middleware)
+          }
+        }
+      }
+
+      for (const route of data.excludedRoutes) {
+        if (isClass(route)) {
+          if (classTarget === route) {
+            matchedMiddlewares.splice(matchedMiddlewares.indexOf(middleware), 1)
+          }
+        }
+        else if (typeof route === 'string') {
+          if (fullPaths.includes(route)) {
+            matchedMiddlewares.splice(matchedMiddlewares.indexOf(middleware), 1)
+          }
+        }
+        else {
+          if (fullPaths.includes(route.path)) {
+            matchedMiddlewares.splice(matchedMiddlewares.indexOf(middleware), 1)
+          }
+        }
+      }
+    }
+
+    for (const middleware of matchedMiddlewares) {
+      if (isClass(middleware)) {
+        const middlewareInstance = await this.getPluginContext().createClass<IClass<NestMiddleware>>(middleware).resolve()
+        await middlewareInstance.use(ctx.request, ctx.response, ctx.next)
+      }
+      else {
+        await middleware(ctx.request, ctx.response, ctx.next)
+      }
+    }
+  }
+
   resolveConnectHandler(): IRestfulConnect.Handler {
     return new NestJSRestfulHandler(this)
   }

Original file line number	Diff line number	Diff line change
`@@ -9,10 +9,13 @@ export class NestJSResolver {`
`9`	`9`	`return this._pluginContext`
`10`	`10`	`}`
`11`	`11`
	`12`	`+ isResolved: boolean = false`
	`13`	`+`
`12`	`14`	`async resolveModule(module: ModuleMetadata): Promise<this> {`
`13`	`15`	`await this.resolveImports(module.imports)`
`14`	`16`	`await this.resolveProviders(module.providers)`
`15`	`17`	`await this.resolveControllers(module.controllers)`
	`18`	`+ this.isResolved = true`
`16`	`19`	`return this`
`17`	`20`	`}`
`18`	`21`
`@@ -21,14 +24,20 @@ export class NestJSResolver {`
`21`	`24`	`private readonly _controllers = new Set<IClassWrapper>()`
`22`	`25`
`23`	`26`	`getResolvedModules(): IClassWrapper[] {`
	`27`	`+ if (!this.isResolved)`
	`28`	`+ throw new Error('NestJSResolver is not resolved yet, please call resolveModule first.')`
`24`	`29`	`return Array.from(this._modules)`
`25`	`30`	`}`
`26`	`31`
`27`	`32`	`getResolvedProviders(): IClassWrapper[] {`
	`33`	`+ if (!this.isResolved)`
	`34`	`+ throw new Error('NestJSResolver is not resolved yet, please call resolveModule first.')`
`28`	`35`	`return Array.from(this._providers)`
`29`	`36`	`}`
`30`	`37`
`31`	`38`	`getResolvedControllers(): IClassWrapper[] {`
	`39`	`+ if (!this.isResolved)`
	`40`	`+ throw new Error('NestJSResolver is not resolved yet, please call resolveModule first.')`
`32`	`41`	`return Array.from(this._controllers)`
`33`	`42`	`}`
`34`	`43`