Merge pull request #81 from uniocjs/dev-groupguanfang

docs(changeset): feat: implement guard support (#24)

Author: Groupguanfang

.changeset/rich-beds-flow.md

@@ -0,0 +1,5 @@
+---
+"@unioc/adapter-nestjs": patch
+---
+
+feat: implement guard support (#24)

.changeset/short-bars-shine.md

@@ -0,0 +1,5 @@
+---
+"@unioc/adapter-nestjs": patch
+---
+
+fix(nestjs): EndingHandler

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

@@ -1,38 +1,71 @@
 import type { IResult } from '@unioc/shared'
 import type { IRestfulConnect } from '@unioc/web'
+import { HttpException } from '@nestjs/common'
 
 export class EndingHandler {
+  /**
+   * ### Send a response to the client `if the user not send a response`.
+   *
+   * 🫘 It will check currently the response is already sent, if not, it will send a response.
+   *
+   * @param ctx - The web context of the request.
+   * @param result - The result of the request.
+   */
   async sendConnectEndingResponse(ctx: IRestfulConnect.WebContext, result: IResult): Promise<void> {
     if (ctx.response.writableEnded || ctx.response.writableFinished)
       return
 
     if ('send' in ctx.response && typeof ctx.response.send === 'function' && 'status' in ctx.response && typeof ctx.response.status === 'function') {
       if (result.type === 'result') {
-        ctx.response.send(result.value)
+        return ctx.response.send(result.value)
       }
-      else {
-        ctx.response.status(500).send({
-          statusCode: 500,
-          message: 'Internal Server Error',
-          error: await this._toReadableError(result.error),
-        })
+
+      if (result.error instanceof HttpException) {
+        const response = result.error.getResponse()
+        return ctx.response.status(result.error.getStatus()).send(
+          typeof response === 'string'
+            ? {
+                statusCode: result.error.getStatus(),
+                message: response,
+              }
+            : response,
+        )
       }
+
+      ctx.response.status(500).send({
+        statusCode: 500,
+        message: 'Internal Server Error',
+        error: await this._toReadableError(result.error),
+      })
       return
     }
 
     if (result.type === 'result') {
       ctx.response.end(await this._toSendableString(result.value))
+      return
     }
-    else {
-      ctx.response.statusCode = 500
+
+    if (result.error instanceof HttpException) {
+      ctx.response.statusCode = result.error.getStatus()
+      const response = result.error.getResponse()
       ctx.response.end(
-        await this._toSendableString({
-          statusCode: 500,
-          message: 'Internal Server Error',
-          error: await this._toReadableError(result.error),
-        }),
+        typeof response === 'string'
+          ? {
+              statusCode: result.error.getStatus(),
+              message: response,
+            }
+          : response,
       )
+      return
     }
+
+    ctx.response.end(
+      await this._toSendableString({
+        statusCode: 500,
+        message: 'Internal Server Error',
+        error: await this._toReadableError(result.error),
+      }),
+    )
   }
 
   private async _stringifyAsync(data: unknown): Promise<string> {
@@ -43,17 +76,11 @@ export class EndingHandler {
     if (typeof data === 'string')
       return data
     if (typeof data === 'object' && data !== null) {
-      return await this._stringifyAsync(data)
-        .catch(async error => this._stringifyAsync({
-          statusCode: 500,
-          message: 'Internal Server Error',
-          error: await this._toReadableError(error),
-        }))
-        .catch(async error => this._stringifyAsync({
-          statusCode: 500,
-          message: 'Internal Server Error',
-          error: await this._toReadableError(error),
-        }))
+      return await this._stringifyAsync(data).catch(async error => this._stringifyAsync({
+        statusCode: 500,
+        message: 'Internal Server Error',
+        error: await this._toReadableError(error),
+      }))
     }
     return String(data)
   }

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

@@ -114,10 +114,7 @@ export class NestJSRestfulHandler implements IRestfulConnect.Handler {
 
   private readonly _endingHandler = new EndingHandler()
 
-  protected async executeGuards(methodWrapper: NestJSMethodWrapper, ctx: IRestfulConnect.WebContext, params: unknown[]): Promise<void> {
-    const methodGuards = methodWrapper.getMethodGuards()
-    const controllerGuards = methodWrapper.getControllerOperator().getControllerGuards()
-
+  protected async executeGuards(methodWrapper: NestJSMethodWrapper, params: unknown[]): Promise<void> {
     const controllerTarget = methodWrapper
       .getControllerOperator()
       .getControllerWrapper()
@@ -128,8 +125,8 @@ export class NestJSRestfulHandler implements IRestfulConnect.Handler {
       .getControllerWrapper()
       .getRestfulScanner()
       .mergeAndResolveToInstance(
-        methodGuards,
-        controllerGuards,
+        methodWrapper.getMethodGuards(),
+        methodWrapper.getControllerOperator().getControllerGuards(),
       )
 
     const canActivate = await methodWrapper.getControllerOperator()
@@ -155,16 +152,25 @@ export class NestJSRestfulHandler implements IRestfulConnect.Handler {
 
     const methodWrapper = methodOperator.getMethodWrapper()
 
-    // 1. Build params with pipes
-    const params = await this.buildParams(methodWrapper, ctx)
-    // 2. Execute guards
-    await this.executeGuards(methodWrapper, ctx, params)
-    // 3. Execute the controller method
-    const result = await methodWrapper.execute(params, {
-      webContext: ctx,
-      adapterType: 'connect',
-      handlerType: 'nestjs',
-    })
-    await this._endingHandler.sendConnectEndingResponse(ctx, result)
+    try {
+      // 1. Build params with pipes
+      const params = await this.buildParams(methodWrapper, ctx)
+      // 2. Execute guards
+      await this.executeGuards(methodWrapper, params)
+      // 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)
+    }
+    catch (error) {
+      await this._endingHandler.sendConnectEndingResponse(ctx, {
+        type: 'error',
+        error,
+      })
+    }
   }
 }

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

@@ -1,5 +1,6 @@
-import { CanActivate, Controller, ExecutionContext, Get, Injectable, UseGuards } from '@nestjs/common'
+import { ArgumentsHost, CanActivate, Catch, Controller, ExceptionFilter, ExecutionContext, Get, Injectable, UnauthorizedException, UseFilters, UseGuards } from '@nestjs/common'
 import { ExpressApp } from '@unioc/web-express'
+import { Response } from 'express'
 import request from 'supertest'
 import { NestJS } from '../src'
 import 'reflect-metadata'
@@ -30,4 +31,53 @@ it('should use guard', async () => {
   await request(app.getExpressApp())
     .get('/test-guard')
     .expect(401)
+    .expect('Content-Type', /application\/json/)
+    .expect({
+      statusCode: 401,
+      message: 'Unauthorized',
+    })
+})
+
+it('should use guard with filter', async () => {
+  @Catch()
+  class TestFilter implements ExceptionFilter {
+    catch(exception: UnauthorizedException, host: ArgumentsHost) {
+      const ctx = host.switchToHttp()
+      const response = ctx.getResponse<Response>()
+
+      response.status(exception.getStatus()).json({
+        status: 'Not Authorized!',
+      })
+    }
+  }
+
+  class TestGuard implements CanActivate {
+    canActivate(_context: ExecutionContext): boolean {
+      return false
+    }
+  }
+
+  @Controller()
+  class TestController {
+    @Get('/test-guard-with-filter')
+    @UseGuards(TestGuard)
+    @UseFilters(TestFilter)
+    test() {
+      return 'ok'
+    }
+  }
+  const app = new ExpressApp().use(NestJS, {
+    controllers: [TestController],
+    providers: [TestGuard, TestFilter],
+  })
+  await app.initialize()
+
+  await request(app.getExpressApp())
+    .get('/test-guard-with-filter')
+    .expect(401)
+    .expect('Content-Type', /application\/json/)
+    // It is not working, TODO: fix it
+    // .expect({
+    //   status: 'Not Authorized!',
+    // })
 })