@dangao/bun-server 1.8.0 → 1.8.2

package/tests/controller/param-binder.test.ts

@@ -0,0 +1,333 @@
+import { describe, expect, test, beforeEach } from 'bun:test';
+import 'reflect-metadata';
+
+import { ParamBinder } from '../../src/controller/param-binder';
+import {
+  Body,
+  Query,
+  Param,
+  Header,
+  Context as ContextDecorator,
+  QueryMap,
+  HeaderMap,
+} from '../../src/controller/decorators';
+import { Context } from '../../src/core/context';
+import { Container } from '../../src/di/container';
+
+describe('ParamBinder', () => {
+  let container: Container;
+
+  beforeEach(() => {
+    container = new Container();
+  });
+
+  describe('bind', () => {
+    test('should bind @Body parameter', async () => {
+      class TestController {
+        public testMethod(@Body() body: unknown): void {}
+      }
+
+      const request = new Request('http://localhost/test', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ name: 'test' }),
+      });
+      const context = new Context(request, container);
+
+      const params = await ParamBinder.bind(
+        TestController.prototype,
+        'testMethod',
+        context,
+        container,
+      );
+
+      expect(params[0]).toEqual({ name: 'test' });
+    });
+
+    test('should bind @Body with key parameter', async () => {
+      class TestController {
+        public testMethod(@Body('name') name: string): void {}
+      }
+
+      const request = new Request('http://localhost/test', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ name: 'alice', age: 25 }),
+      });
+      const context = new Context(request, container);
+
+      const params = await ParamBinder.bind(
+        TestController.prototype,
+        'testMethod',
+        context,
+        container,
+      );
+
+      expect(params[0]).toBe('alice');
+    });
+
+    test('should bind @Query parameter', async () => {
+      class TestController {
+        public testMethod(@Query('id') id: string): void {}
+      }
+
+      const request = new Request('http://localhost/test?id=123');
+      const context = new Context(request, container);
+
+      const params = await ParamBinder.bind(
+        TestController.prototype,
+        'testMethod',
+        context,
+        container,
+      );
+
+      expect(params[0]).toBe('123');
+    });
+
+    test('should bind @Param parameter', async () => {
+      class TestController {
+        public testMethod(@Param('id') id: string): void {}
+      }
+
+      const request = new Request('http://localhost/users/456');
+      const context = new Context(request, container);
+      context.params = { id: '456' };
+
+      const params = await ParamBinder.bind(
+        TestController.prototype,
+        'testMethod',
+        context,
+        container,
+      );
+
+      expect(params[0]).toBe('456');
+    });
+
+    test('should bind @Header parameter', async () => {
+      class TestController {
+        public testMethod(@Header('x-custom') custom: string): void {}
+      }
+
+      const request = new Request('http://localhost/test', {
+        headers: { 'X-Custom': 'custom-value' },
+      });
+      const context = new Context(request, container);
+
+      const params = await ParamBinder.bind(
+        TestController.prototype,
+        'testMethod',
+        context,
+        container,
+      );
+
+      expect(params[0]).toBe('custom-value');
+    });
+
+    test('should bind @Context parameter', async () => {
+      class TestController {
+        public testMethod(@ContextDecorator() ctx: Context): void {}
+      }
+
+      const request = new Request('http://localhost/test');
+      const context = new Context(request, container);
+
+      const params = await ParamBinder.bind(
+        TestController.prototype,
+        'testMethod',
+        context,
+        container,
+      );
+
+      // 返回的是 context 或 AsyncLocalStorage 中的 context
+      expect(params[0]).toBeDefined();
+    });
+
+    test('should bind multiple parameters in correct order', async () => {
+      class TestController {
+        public testMethod(
+          @Query('name') name: string,
+          @Query('age') age: string,
+          @Header('x-token') token: string,
+        ): void {}
+      }
+
+      const request = new Request('http://localhost/test?name=alice&age=25', {
+        headers: { 'X-Token': 'abc123' },
+      });
+      const context = new Context(request, container);
+
+      const params = await ParamBinder.bind(
+        TestController.prototype,
+        'testMethod',
+        context,
+        container,
+      );
+
+      expect(params[0]).toBe('alice');
+      expect(params[1]).toBe('25');
+      expect(params[2]).toBe('abc123');
+    });
+
+    test('should return empty array for method without decorators', async () => {
+      class TestController {
+        public testMethod(arg: string): void {}
+      }
+
+      const request = new Request('http://localhost/test');
+      const context = new Context(request, container);
+
+      const params = await ParamBinder.bind(
+        TestController.prototype,
+        'testMethod',
+        context,
+        container,
+      );
+
+      expect(params).toEqual([]);
+    });
+
+    test('should handle @QueryMap parameter', async () => {
+      class TestController {
+        public testMethod(@QueryMap() query: Record<string, string>): void {}
+      }
+
+      const request = new Request('http://localhost/test?foo=bar&baz=qux');
+      const context = new Context(request, container);
+
+      const params = await ParamBinder.bind(
+        TestController.prototype,
+        'testMethod',
+        context,
+        container,
+      );
+
+      expect(params[0]).toEqual({ foo: 'bar', baz: 'qux' });
+    });
+
+    test('should handle @QueryMap with transform', async () => {
+      class TestController {
+        public testMethod(
+          @QueryMap({
+            transform: (map) => ({ ...map, transformed: true }),
+          })
+          query: Record<string, unknown>,
+        ): void {}
+      }
+
+      const request = new Request('http://localhost/test?foo=bar');
+      const context = new Context(request, container);
+
+      const params = await ParamBinder.bind(
+        TestController.prototype,
+        'testMethod',
+        context,
+        container,
+      );
+
+      expect((params[0] as any).transformed).toBe(true);
+    });
+
+    test('should handle @HeaderMap parameter', async () => {
+      class TestController {
+        public testMethod(@HeaderMap() headers: Record<string, string>): void {}
+      }
+
+      const request = new Request('http://localhost/test', {
+        headers: { 'X-Custom': 'value1', 'X-Another': 'value2' },
+      });
+      const context = new Context(request, container);
+
+      const params = await ParamBinder.bind(
+        TestController.prototype,
+        'testMethod',
+        context,
+        container,
+      );
+
+      expect((params[0] as any)['x-custom']).toBe('value1');
+      expect((params[0] as any)['x-another']).toBe('value2');
+    });
+
+    test('should handle @HeaderMap with pick', async () => {
+      class TestController {
+        public testMethod(
+          @HeaderMap({ pick: ['x-custom'] })
+          headers: Record<string, string>,
+        ): void {}
+      }
+
+      const request = new Request('http://localhost/test', {
+        headers: { 'X-Custom': 'value1', 'X-Another': 'value2' },
+      });
+      const context = new Context(request, container);
+
+      const params = await ParamBinder.bind(
+        TestController.prototype,
+        'testMethod',
+        context,
+        container,
+      );
+
+      expect((params[0] as any)['x-custom']).toBe('value1');
+      expect((params[0] as any)['x-another']).toBeUndefined();
+    });
+
+    test('should handle missing body key', async () => {
+      class TestController {
+        public testMethod(@Body('missing') value: string): void {}
+      }
+
+      const request = new Request('http://localhost/test', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ name: 'test' }),
+      });
+      const context = new Context(request, container);
+
+      const params = await ParamBinder.bind(
+        TestController.prototype,
+        'testMethod',
+        context,
+        container,
+      );
+
+      expect(params[0]).toBeUndefined();
+    });
+
+    test('should return null for missing query param', async () => {
+      class TestController {
+        public testMethod(@Query('missing') value: string): void {}
+      }
+
+      const request = new Request('http://localhost/test');
+      const context = new Context(request, container);
+
+      const params = await ParamBinder.bind(
+        TestController.prototype,
+        'testMethod',
+        context,
+        container,
+      );
+
+      expect(params[0]).toBeNull();
+    });
+
+    test('should return undefined for missing path param', async () => {
+      class TestController {
+        public testMethod(@Param('missing') value: string): void {}
+      }
+
+      const request = new Request('http://localhost/test');
+      const context = new Context(request, container);
+
+      const params = await ParamBinder.bind(
+        TestController.prototype,
+        'testMethod',
+        context,
+        container,
+      );
+
+      expect(params[0]).toBeUndefined();
+    });
+  });
+});

package/tests/error/error-handler.test.ts

@@ -1,68 +1,177 @@
-import { describe, expect, test } from 'bun:test';
+import { describe, expect, test, beforeEach } from 'bun:test';
+import 'reflect-metadata';
 
-import { Context } from '../../src/core/context';
 import { handleError } from '../../src/error/handler';
-import { HttpException, BadRequestException } from '../../src/error/http-exception';
+import { HttpException, BadRequestException, UnauthorizedException, ForbiddenException, NotFoundException } from '../../src/error';
 import { ValidationError } from '../../src/validation';
-import { ExceptionFilterRegistry, type ExceptionFilter } from '../../src/error/filter';
-
-function createContext(url: string = 'http://localhost/api/error'): Context {
-  return new Context(new Request(url));
-}
-
-describe('Error Handler', () => {
-  test('should handle HttpException', async () => {
-    const ctx = createContext();
-    const error = new BadRequestException('Invalid payload');
-    const response = await handleError(error, ctx);
-    expect(response.status).toBe(400);
-    const data = await response.json();
-    expect(data.error).toBe('Invalid payload');
-  });
+import { Context } from '../../src/core/context';
+import { Container } from '../../src/di/container';
 
-  test('should handle ValidationError', async () => {
-    const ctx = createContext();
-    const validationError = new ValidationError('Validation failed', [
-      { index: 0, rule: 'isString', message: 'Must be string' },
-    ]);
-    const response = await handleError(validationError, ctx);
-    expect(response.status).toBe(400);
-    const data = await response.json();
-    expect(data.issues.length).toBe(1);
+describe('handleError', () => {
+  let container: Container;
+
+  beforeEach(() => {
+    container = new Container();
   });
 
-  test('should allow custom exception filter', async () => {
-    const registry = ExceptionFilterRegistry.getInstance();
-    registry.clear();
-
-    const filter: ExceptionFilter = {
-      catch(error, context) {
-        if (error instanceof Error && error.message === 'custom') {
-          context.setStatus(418);
-          return context.createResponse({ error: 'filtered' });
-        }
-        return undefined;
-      },
-    };
-
-    registry.register(filter);
-
-    const ctx = createContext();
-    const response = await handleError(new Error('custom'), ctx);
-    expect(response.status).toBe(418);
-    const data = await response.json();
-    expect(data.error).toBe('filtered');
-
-    registry.clear();
+  function createContext(): Context {
+    const request = new Request('http://localhost/test');
+    return new Context(request, container);
+  }
+
+  describe('HttpException handling', () => {
+    test('should handle basic HttpException', async () => {
+      const context = createContext();
+      const error = new HttpException(400, 'Bad request');
+
+      const response = await handleError(error, context);
+      const body = await response.json() as { error: string };
+
+      expect(response.status).toBe(400);
+      expect(body.error).toBe('Bad request');
+    });
+
+    test('should handle BadRequestException', async () => {
+      const context = createContext();
+      const error = new BadRequestException('Invalid input');
+
+      const response = await handleError(error, context);
+      const body = await response.json() as { error: string };
+
+      expect(response.status).toBe(400);
+      expect(body.error).toBe('Invalid input');
+    });
+
+    test('should handle UnauthorizedException', async () => {
+      const context = createContext();
+      const error = new UnauthorizedException('Not authenticated');
+
+      const response = await handleError(error, context);
+      const body = await response.json() as { error: string };
+
+      expect(response.status).toBe(401);
+      expect(body.error).toBe('Not authenticated');
+    });
+
+    test('should handle ForbiddenException', async () => {
+      const context = createContext();
+      const error = new ForbiddenException('Access denied');
+
+      const response = await handleError(error, context);
+      const body = await response.json() as { error: string };
+
+      expect(response.status).toBe(403);
+      expect(body.error).toBe('Access denied');
+    });
+
+    test('should handle NotFoundException', async () => {
+      const context = createContext();
+      const error = new NotFoundException('Resource not found');
+
+      const response = await handleError(error, context);
+      const body = await response.json() as { error: string };
+
+      expect(response.status).toBe(404);
+      expect(body.error).toBe('Resource not found');
+    });
+
+    test('should include error code in response when present', async () => {
+      const context = createContext();
+      // HttpException 构造函数: (status, message, details?, code?, messageParams?)
+      const error = new HttpException(400, 'Validation failed', undefined, 'E001');
+
+      const response = await handleError(error, context);
+      const body = await response.json() as { error: string; code: string };
+
+      expect(body.code).toBe('E001');
+    });
+
+    test('should include details in response when present', async () => {
+      const context = createContext();
+      const error = new HttpException(400, 'Validation failed');
+      (error as any).details = { field: 'email', issue: 'invalid format' };
+
+      const response = await handleError(error, context);
+      const body = await response.json() as { error: string; details: unknown };
+
+      expect(body.details).toEqual({ field: 'email', issue: 'invalid format' });
+    });
   });
 
-  test('should fallback to 500 for unknown errors', async () => {
-    const ctx = createContext();
-    const response = await handleError(new Error('unknown'), ctx);
-    expect(response.status).toBe(500);
-    const data = await response.json();
-    expect(data.error).toBe('Internal Server Error');
+  describe('ValidationError handling', () => {
+    test('should handle ValidationError', async () => {
+      const context = createContext();
+      const error = new ValidationError('Validation failed', [
+        { path: 'email', message: 'Invalid email format' },
+      ]);
+
+      const response = await handleError(error, context);
+      const body = await response.json() as { error: string; code: string; issues: unknown[] };
+
+      expect(response.status).toBe(400);
+      expect(body.error).toBe('Validation failed');
+      expect(body.code).toBe('VALIDATION_FAILED');
+      expect(body.issues).toHaveLength(1);
+    });
+
+    test('should include all validation issues', async () => {
+      const context = createContext();
+      const error = new ValidationError('Multiple errors', [
+        { path: 'email', message: 'Invalid email' },
+        { path: 'name', message: 'Name is required' },
+        { path: 'age', message: 'Age must be positive' },
+      ]);
+
+      const response = await handleError(error, context);
+      const body = await response.json() as { issues: unknown[] };
+
+      expect(body.issues).toHaveLength(3);
+    });
   });
-});
 
+  describe('Unknown error handling', () => {
+    test('should handle Error instance', async () => {
+      const context = createContext();
+      const error = new Error('Something went wrong');
+
+      const response = await handleError(error, context);
+      const body = await response.json() as { error: string; details?: string };
+
+      expect(response.status).toBe(500);
+      expect(body.error).toBe('Internal Server Error');
+    });
 
+    test('should handle string error', async () => {
+      const context = createContext();
+      const error = 'String error message';
+
+      const response = await handleError(error, context);
+      const body = await response.json() as { error: string };
+
+      expect(response.status).toBe(500);
+      expect(body.error).toBe('Internal Server Error');
+    });
+
+    test('should handle null error', async () => {
+      const context = createContext();
+      const error = null;
+
+      const response = await handleError(error, context);
+      const body = await response.json() as { error: string };
+
+      expect(response.status).toBe(500);
+      expect(body.error).toBe('Internal Server Error');
+    });
+
+    test('should handle undefined error', async () => {
+      const context = createContext();
+      const error = undefined;
+
+      const response = await handleError(error, context);
+      const body = await response.json() as { error: string };
+
+      expect(response.status).toBe(500);
+      expect(body.error).toBe('Internal Server Error');
+    });
+  });
+});

package/tests/error/i18n-extended.test.ts

@@ -0,0 +1,105 @@
+import { describe, expect, test } from 'bun:test';
+
+import { ErrorMessageI18n, type SupportedLanguage } from '../../src/error/i18n';
+import { ErrorCode } from '../../src/error/error-codes';
+
+describe('Error I18n', () => {
+  describe('ErrorMessageI18n.getMessage', () => {
+    test('should return English message by default', () => {
+      const message = ErrorMessageI18n.getMessage(ErrorCode.INTERNAL_ERROR);
+      expect(message.toLowerCase()).toContain('internal');
+    });
+
+    test('should return Chinese message when specified', () => {
+      const message = ErrorMessageI18n.getMessage(ErrorCode.INTERNAL_ERROR, 'zh-CN');
+      expect(message).toBe('服务器内部错误');
+    });
+
+    test('should return Japanese message when available', () => {
+      const message = ErrorMessageI18n.getMessage(ErrorCode.INTERNAL_ERROR, 'ja');
+      expect(message).toBe('サーバー内部エラー');
+    });
+
+    test('should return Korean message when available', () => {
+      const message = ErrorMessageI18n.getMessage(ErrorCode.INTERNAL_ERROR, 'ko');
+      expect(message).toBe('서버 내부 오류');
+    });
+
+    test('should fallback to English when translation not available', () => {
+      // Use an error code that might not have translations in all languages
+      const message = ErrorMessageI18n.getMessage(ErrorCode.DATABASE_POOL_EXHAUSTED, 'ja');
+      // Should fallback to English
+      expect(message).toBeDefined();
+    });
+
+    test('should return message for auth errors', () => {
+      const messages = {
+        en: ErrorMessageI18n.getMessage(ErrorCode.AUTH_REQUIRED, 'en'),
+        zhCN: ErrorMessageI18n.getMessage(ErrorCode.AUTH_REQUIRED, 'zh-CN'),
+      };
+
+      expect(messages.en.toLowerCase()).toContain('authentication');
+      expect(messages.zhCN).toBe('需要认证');
+    });
+
+    test('should return message for validation errors', () => {
+      const message = ErrorMessageI18n.getMessage(ErrorCode.VALIDATION_FAILED, 'zh-CN');
+      expect(message).toBe('验证失败');
+    });
+
+    test('should support message parameters', () => {
+      // getMessage supports params as third argument
+      const message = ErrorMessageI18n.getMessage(ErrorCode.INTERNAL_ERROR, 'en', { detail: 'test' });
+      expect(message).toBeDefined();
+    });
+  });
+
+  describe('default language', () => {
+    test('should support multiple languages', () => {
+      // Test that different languages return different messages
+      const enMessage = ErrorMessageI18n.getMessage(ErrorCode.INTERNAL_ERROR, 'en');
+      const zhMessage = ErrorMessageI18n.getMessage(ErrorCode.INTERNAL_ERROR, 'zh-CN');
+
+      // English and Chinese messages should be different
+      expect(enMessage).not.toBe(zhMessage);
+      expect(zhMessage).toBe('服务器内部错误');
+    });
+  });
+
+  describe('ErrorMessageI18n.parseLanguageFromHeader', () => {
+    test('should parse zh-CN from header', () => {
+      const lang = ErrorMessageI18n.parseLanguageFromHeader('zh-CN,zh;q=0.9,en;q=0.8');
+      expect(lang).toBe('zh-CN');
+    });
+
+    test('should parse Japanese', () => {
+      const lang = ErrorMessageI18n.parseLanguageFromHeader('ja,en;q=0.8');
+      expect(lang).toBe('ja');
+    });
+
+    test('should parse Korean', () => {
+      const lang = ErrorMessageI18n.parseLanguageFromHeader('ko-KR,ko;q=0.9');
+      expect(lang).toBe('ko');
+    });
+
+    test('should return English by default', () => {
+      const lang = ErrorMessageI18n.parseLanguageFromHeader('fr,de;q=0.8');
+      expect(lang).toBe('en');
+    });
+
+    test('should return English when header is null', () => {
+      const lang = ErrorMessageI18n.parseLanguageFromHeader(null);
+      expect(lang).toBe('en');
+    });
+
+    test('should return English when header is undefined', () => {
+      const lang = ErrorMessageI18n.parseLanguageFromHeader(undefined);
+      expect(lang).toBe('en');
+    });
+
+    test('should handle zh without region code', () => {
+      const lang = ErrorMessageI18n.parseLanguageFromHeader('zh');
+      expect(lang).toBe('zh-CN');
+    });
+  });
+});