Merge pull request #98 from uniocjs/dev-groupguanfang

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

Author: Groupguanfang

.changeset/3db0c793e162ab7be152e14180b3dae6b9cd2d5b.md

@@ -0,0 +1,5 @@
+---
+"@unioc/adapter-nestjs": "patch"
+---
+
+[3db0c793e162ab7be152e14180b3dae6b9cd2d5b] fix(nestjs): MiddlewareConfigProxy forRoutes incorrect

.changeset/53c35bd6c1dad04be84922fce98d039b81c5b5b7.md

@@ -0,0 +1,5 @@
+---
+"@unioc/adapter-nestjs": "minor"
+---
+
+[53c35bd6c1dad04be84922fce98d039b81c5b5b7] feat(nestjs): add middleware support (#21)

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: [route],
+            excludedRoutes: [],
           })
         }
-      }
-      else {
-        handlers.push({
-          handler: middleware,
-          instance: undefined,
-          routes: this._routes,
-        })
+        else {
+          data.includedRoutes.push(route)
+        }
       }
     }
 
-    return handlers
+    return new MiddlewareCustomerBuilder(
+      this.getMiddlewareCustomerBuilder().getPluginContext(),
+      this.getMiddlewareCustomerBuilder().getMiddlewareMap(),
+    )
   }
 }

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 | Type<any> | RouteInfo)[]
+  excludedRoutes: (string | 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()
   }
 }

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)
   }
 

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) {

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