Merge pull request #78 from uniocjs/dev-groupguanfang

feat: add testing file for filter, update nest.js handler's param

Author: Groupguanfang

.changeset/tall-dogs-shine.md

@@ -0,0 +1,6 @@
+---
+"@unioc/adapter-nestjs": patch
+"@unioc/core": patch
+---
+
+feat: add testing file for filter, update nest.js handler's param

package.json

@@ -40,6 +40,7 @@
     "bumpp": "^10.1.0",
     "create-unioc": "workspace:*",
     "eslint": "^9.24.0",
+    "express": "^5.1.0",
     "external-editor": "^3.1.0",
     "fast-glob": "^3.3.3",
     "js-yaml": "^4.1.0",

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

@@ -19,6 +19,39 @@ export class NestJSRestfulHandler implements IRestfulConnect.Handler {
         if (typeof ctx.param === 'object' && ctx.param !== null)
           return currentMetadata.data ? (ctx.param as Record<string, unknown>)[currentMetadata.data as string] : ctx.param
         return ctx.param
+
+      case 'ip':
+        return ctx.ip
+
+      case 'context':
+        throw new Error('[adapter-nestjs] The param type "context" is not supported.')
+
+      case 'request':
+        return ctx.request
+
+      case 'response':
+        return ctx.response
+
+      case 'next':
+        return ctx.next
+
+      case 'file':
+        return ctx.file
+
+      case 'files':
+        return ctx.files
+
+      case 'headers':
+        return ctx.headers
+
+      case 'host':
+        return ctx.host
+
+      case 'rawBody':
+        return ctx.rawBody
+
+      case 'session':
+        return ctx.session
     }
   }
 
@@ -42,8 +75,10 @@ export class NestJSRestfulHandler implements IRestfulConnect.Handler {
 
       if (!currentMetadata)
         continue
-      if (currentMetadata.paramType !== 'body' && currentMetadata.paramType !== 'query' && currentMetadata.paramType !== 'param' && currentMetadata.paramType !== 'custom')
+      if (currentMetadata.paramType !== 'body' && currentMetadata.paramType !== 'query' && currentMetadata.paramType !== 'param' && currentMetadata.paramType !== 'custom') {
+        params[i] = this._getParamValue(currentMetadata, ctx)
         continue
+      }
 
       const transformedParams = await methodWrapper.getControllerOperator()
         .getControllerWrapper()
@@ -90,28 +125,33 @@ export class NestJSRestfulHandler implements IRestfulConnect.Handler {
     if (ctx.response.writableEnded || ctx.response.writableFinished)
       return
 
-    if ('send' in ctx.response && typeof ctx.response.send === 'function') {
-      ctx.response.send(
-        result.type === 'result'
-          ? result.value
-          : {
-              statusCode: 500,
-              message: 'Internal Server Error',
-              error: await this._toReadableError(result.error),
-            },
-      )
+    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)
+      }
+      else {
+        ctx.response.status(500).send({
+          statusCode: 500,
+          message: 'Internal Server Error',
+          error: await this._toReadableError(result.error),
+        })
+      }
       return
     }
 
-    ctx.response.end(
-      result.type === 'result'
-        ? await this._toSendableString(result.value)
-        : await this._toSendableString({
+    if (result.type === 'result') {
+      ctx.response.end(await this._toSendableString(result.value))
+    }
+    else {
+      ctx.response.statusCode = 500
+      ctx.response.end(
+        await this._toSendableString({
           statusCode: 500,
           message: 'Internal Server Error',
           error: await this._toReadableError(result.error),
         }),
-    )
+      )
+    }
   }
 
   private async _toReadableError(error: unknown): Promise<Record<string, unknown>> {

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

@@ -0,0 +1,115 @@
+import { IncomingMessage, ServerResponse } from 'node:http'
+import { ArgumentsHost, Body, Catch, ContextType, Controller, ExceptionFilter, Get, Next, Param, Post, Query, Req, Res, UseFilters } from '@nestjs/common'
+import { ExpressApp } from '@unioc/web-express'
+import express, { NextFunction, Request, Response } from 'express'
+import request from 'supertest'
+import { NestJS } from '../src'
+import 'reflect-metadata'
+
+it('should use internal error message', async () => {
+  @Controller()
+  class TestController {
+    @Get()
+    willThrowError() {
+      throw new Error('test')
+    }
+  }
+
+  const app = new ExpressApp().use(NestJS, {
+    controllers: [TestController],
+  })
+  await app.initialize()
+  await request(app.getExpressApp())
+    .get('/')
+    .expect('Content-Type', /application\/json/)
+    .expect(500)
+    .expect((res) => {
+      expect(res.body.statusCode).toBe(500)
+      expect(res.body.message).toBe('Internal Server Error')
+      expect(res.body.error.message).toBe('test')
+      expect(res.body.error.stack).toMatch(/Error: test/)
+      expect(res.body.error.name).toBe('Error')
+    })
+})
+
+it('should use filter & testing params', async () => {
+  @Catch()
+  class TestFilter implements ExceptionFilter {
+    catch(exception: any, host: ArgumentsHost) {
+      const index1 = host.getArgByIndex(0)
+      expect(index1).toBe('1')
+
+      const index2 = host.getArgByIndex(1)
+      expect(index2).toBeInstanceOf(IncomingMessage)
+
+      const index3 = host.getArgByIndex(2)
+      expect(index3).toBeInstanceOf(ServerResponse)
+
+      const index4 = host.getArgByIndex(3)
+      expect(index4).toBeInstanceOf(Function)
+
+      const contextType = host.getType()
+      expect(contextType).toBe('http' satisfies ContextType)
+
+      const ctx = host.switchToHttp()
+      const request = ctx.getRequest<import('express').Request>()
+      expect(request).toBeInstanceOf(IncomingMessage)
+      const response = ctx.getResponse<import('express').Response>()
+
+      console.error('Handled a error in [filter.test.ts: `should use filter`]:')
+      console.error(exception)
+
+      response.status(500).json({
+        statusCode: 500,
+        message: 'Throw an error and catch in test filter!',
+        error: exception.message,
+      })
+    }
+  }
+
+  @Controller()
+  @UseFilters(TestFilter)
+  class TestController {
+    @Post('/test/:id')
+    willThrowError(
+      @Query('a') a: string,
+      @Req() request: Request,
+      @Res() response: Response,
+      @Next() next: NextFunction,
+      @Param() param: Record<string, unknown>,
+      @Param('id') id: string,
+      @Body() body: any,
+    ) {
+      expect(a).toBe('1')
+      expect(request).toBeInstanceOf(IncomingMessage)
+      expect(response).toBeInstanceOf(ServerResponse)
+      expect(next).toBeInstanceOf(Function)
+      expect(Object.keys(param).length).toBe(1)
+      expect(param.id).toBe('1')
+      expect(id).toBe('1')
+      expect(Object.keys(body).length).toBe(1)
+      throw new Error('test')
+    }
+  }
+
+  const app = new ExpressApp().use(NestJS, {
+    controllers: [TestController],
+    providers: [TestFilter],
+  })
+  app.getExpressApp().use(express.json())
+  await app.initialize()
+
+  await request(app.getExpressApp())
+    .post('/test/1')
+    .query({ a: '1' })
+    .send({
+      foo: 'bar',
+    })
+    .expect('Content-Type', /application\/json/)
+    .expect(500)
+    .expect((res) => {
+      expect(res.body.statusCode).toBe(500)
+      expect(res.body.message).toBe('Throw an error and catch in test filter!')
+      expect(res.body.error).toBe('test')
+    })
+})

packages/core/core/src/contexts/classes/class-executor.ts

@@ -1,4 +1,4 @@
-import type { IClass, IResult } from '@unioc/shared'
+import type { IClass, IError, IResult, ISuccess } from '@unioc/shared'
 import type { ClassWrapper } from '../../container/class-wrapper'
 import type { IClassExecutor, IClassWrapper } from '../../types'
 
@@ -20,20 +20,22 @@ export class ClassExecutor<TClass extends IClass = IClass> implements IClassExec
     const invokeContext = await pluginExecutor.executeInvoke(classWrapper, options.methodName, options.arguments)
     const args = invokeContext.getMethodArguments()
 
-    try {
-      const result = await instance[options.methodName](...args)
+    async function executor(): Promise<unknown> {
+      return await instance[options.methodName](...args)
+    }
+
+    return executor().then(async (result) => {
       const handleContext = await pluginExecutor.executeHandle(classWrapper, options.methodName, args, result, 'result', options.extraOptions)
       return {
         type: 'result',
         value: handleContext.getExecuteResult() as T,
-      }
-    }
-    catch (error) {
+      } satisfies ISuccess<T>
+    }).catch(async (error) => {
       const handleContext = await pluginExecutor.executeHandle(classWrapper, options.methodName, args, error, 'error', options.extraOptions)
       return {
         type: 'error',
         error: handleContext.getExecuteResult() as TE,
-      }
-    }
+      } satisfies IError<TE>
+    })
   }
 }