Merge pull request #84 from uniocjs/dev-groupguanfang

feat(core,nestjs): expose extraOptions for IPluginContext.handle in core; finishing the guards/pipes error handle (#82,#24)

Author: Groupguanfang

packages/adapter/adapter-nestjs/src/arguments-host-builder.ts

@@ -9,7 +9,7 @@ export class ArgumentsHostBuilder implements ArgumentsHost {
 
   private _httpArgumentsHost: HttpArgumentsHost = {} as any
 
-  getArgs<T extends Array<any> = any[]>(): T {
+  getArgs<T extends Array<unknown> = unknown[]>(): T {
     return this._args as T
   }
 

packages/adapter/adapter-nestjs/src/restful/ending-handler.ts

@@ -11,7 +11,7 @@ export class EndingHandler {
    * @param ctx - The web context of the request.
    * @param result - The result of the request.
    */
-  async sendConnectEndingResponse(ctx: IRestfulConnect.WebContext, result: IResult): Promise<void> {
+  async sendConnectEndingIfNotSent(ctx: IRestfulConnect.WebContext, result: IResult): Promise<void> {
     if (ctx.response.writableEnded || ctx.response.writableFinished)
       return
 

packages/adapter/adapter-nestjs/src/restful/restful-handler.ts

@@ -1,11 +1,18 @@
 import type { IMethodExecuteOptions, IRestfulConnect, IRestMethodOperator } from '@unioc/web'
 import type { INestJSMethodParamMetadata, NestJSMethodWrapper } from './method-wrapper'
+import type { NestJSRestfulScanner } from './restful-scanner'
 import { UnauthorizedException } from '@nestjs/common'
 import { ExecutionContextBuilder } from '../execution-context-builder'
 import { EndingHandler } from './ending-handler'
 import { NestJSMethodOperator } from './method-operator'
 
 export class NestJSRestfulHandler implements IRestfulConnect.Handler {
+  constructor(private readonly _restfulScanner: NestJSRestfulScanner) {}
+
+  getRestfulScanner(): NestJSRestfulScanner {
+    return this._restfulScanner
+  }
+
   private _getParamValue(currentMetadata: INestJSMethodParamMetadata, ctx: IRestfulConnect.WebContext): unknown {
     switch (currentMetadata.paramType) {
       case 'body':
@@ -151,23 +158,35 @@ export class NestJSRestfulHandler implements IRestfulConnect.Handler {
       throw new Error('Method operator is not a NestJSMethodOperator')
 
     const methodWrapper = methodOperator.getMethodWrapper()
+    let methodArguments: unknown[] = []
+    const extraOptions = {
+      webContext: ctx,
+      adapterType: 'connect',
+      handlerType: 'nestjs',
+    } as const
 
     try {
       // 1. Build params with pipes
-      const params = await this.buildParams(methodWrapper, ctx)
+      methodArguments = await this.buildParams(methodWrapper, ctx)
       // 2. Execute guards
-      await this.executeGuards(methodWrapper, params)
+      await this.executeGuards(methodWrapper, methodArguments)
       // 3. Execute the controller method
-      const result = await methodWrapper.execute(params, {
-        webContext: ctx,
-        adapterType: 'connect',
-        handlerType: 'nestjs',
-      })
-      // 4. Send the ending response
-      await this._endingHandler.sendConnectEndingResponse(ctx, result)
+      const result = await methodWrapper.execute(methodArguments, extraOptions)
+      // 4. TODO: Execute the interceptors
+      // 5. Send the ending response
+      await this._endingHandler.sendConnectEndingIfNotSent(ctx, result)
     }
     catch (error) {
-      await this._endingHandler.sendConnectEndingResponse(ctx, {
+      await this.getRestfulScanner().getPluginContext().handle({
+        classWrapper: methodWrapper.getControllerOperator()
+          .getControllerWrapper()
+          .getClassWrapper(),
+        propertyKey: methodWrapper.getPropertyKey(),
+        methodArguments,
+        error,
+        extraOptions,
+      })
+      await this._endingHandler.sendConnectEndingIfNotSent(ctx, {
         type: 'error',
         error,
       })

packages/adapter/adapter-nestjs/src/restful/restful-scanner.ts

@@ -1,5 +1,5 @@
 import type { ArgumentMetadata, ArgumentsHost, CanActivate, ExceptionFilter, ExecutionContext, PipeTransform } from '@nestjs/common'
-import type { IArgument } from '@unioc/core'
+import type { IArgument, IPluginContext } from '@unioc/core'
 import type { IClass } from '@unioc/shared'
 import type { IHttpParam, IRestfulConnect, IRestfulScanner } from '@unioc/web'
 import type { NestJSMethodOperator } from './method-operator'
@@ -12,6 +12,10 @@ export interface INestJSPipeArgument extends IArgument, ArgumentMetadata, Partia
 export type INestJSFilterCatchType = 'done' | 'no-match'
 
 export class NestJSRestfulScanner extends RestfulScanner implements IRestfulScanner {
+  override getPluginContext(): IPluginContext {
+    return super.getPluginContext()
+  }
+
   protected override scanAllRestControllerWrappers(): void {
     const allClassWrappers = this.getControllerWrappers()
 
@@ -131,6 +135,6 @@ export class NestJSRestfulScanner extends RestfulScanner implements IRestfulScan
   }
 
   resolveConnectHandler(): IRestfulConnect.Handler {
-    return new NestJSRestfulHandler()
+    return new NestJSRestfulHandler(this)
   }
 }

packages/adapter/adapter-nestjs/test/guard.test.ts

@@ -76,8 +76,7 @@ it('should use guard with filter', async () => {
     .get('/test-guard-with-filter')
     .expect(401)
     .expect('Content-Type', /application\/json/)
-    // It is not working, TODO: fix it
-    // .expect({
-    //   status: 'Not Authorized!',
-    // })
+    .expect({
+      status: 'Not Authorized!',
+    })
 })

packages/core/core/src/contexts/plugins/plugin-context.ts

@@ -54,6 +54,7 @@ export class PluginContext extends AbstractContext implements IPluginContext {
       options.methodArguments,
       options.error,
       'error',
+      options.extraOptions,
     )
   }
 }

packages/core/core/src/types/plugin.ts

@@ -23,6 +23,10 @@ export interface IHandleExecutorOptions {
    * The current method arguments.
    */
   methodArguments: unknown[]
+  /**
+   * The extra options.
+   */
+  extraOptions?: Record<string, unknown>
 }
 
 export interface IPluginContext extends IContext, IInternalLogger, IBootstrapDeriver {