@dangao/bun-server 1.7.1 → 1.8.1

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');
+    });
+  });
+});

package/tests/events/event-decorators.test.ts

@@ -0,0 +1,173 @@
+import { describe, expect, test, beforeEach } from 'bun:test';
+import 'reflect-metadata';
+import {
+  OnEvent,
+  getOnEventMetadata,
+  isEventListenerClass,
+} from '../../src/events/decorators';
+import { Injectable } from '../../src/di/decorators';
+import {
+  ON_EVENT_METADATA_KEY,
+  EVENT_LISTENER_CLASS_METADATA_KEY,
+} from '../../src/events/types';
+
+describe('OnEvent decorator', () => {
+  beforeEach(() => {
+    // 清理可能的元数据污染
+  });
+
+  test('should mark class as event listener class', () => {
+    @Injectable()
+    class TestService {
+      @OnEvent('test.event')
+      public handleEvent(payload: unknown): void {
+        // handler
+      }
+    }
+
+    expect(isEventListenerClass(TestService)).toBe(true);
+  });
+
+  test('should store event metadata on class', () => {
+    @Injectable()
+    class TestService {
+      @OnEvent('user.created')
+      public handleUserCreated(payload: unknown): void {
+        // handler
+      }
+    }
+
+    const metadata = getOnEventMetadata(TestService);
+    expect(metadata).toBeDefined();
+    expect(metadata?.length).toBe(1);
+    expect(metadata?.[0]?.event).toBe('user.created');
+    expect(metadata?.[0]?.methodName).toBe('handleUserCreated');
+  });
+
+  test('should support Symbol as event name', () => {
+    const USER_DELETED = Symbol('user.deleted');
+
+    @Injectable()
+    class TestService {
+      @OnEvent(USER_DELETED)
+      public handleUserDeleted(payload: unknown): void {
+        // handler
+      }
+    }
+
+    const metadata = getOnEventMetadata(TestService);
+    expect(metadata?.[0]?.event).toBe(USER_DELETED);
+  });
+
+  test('should support multiple event listeners in same class', () => {
+    @Injectable()
+    class TestService {
+      @OnEvent('event1')
+      public handleEvent1(payload: unknown): void {}
+
+      @OnEvent('event2')
+      public handleEvent2(payload: unknown): void {}
+
+      @OnEvent('event3')
+      public handleEvent3(payload: unknown): void {}
+    }
+
+    const metadata = getOnEventMetadata(TestService);
+    expect(metadata?.length).toBe(3);
+
+    const events = metadata?.map((m) => m.event);
+    expect(events).toContain('event1');
+    expect(events).toContain('event2');
+    expect(events).toContain('event3');
+  });
+
+  test('should use default options when not specified', () => {
+    @Injectable()
+    class TestService {
+      @OnEvent('test.event')
+      public handleEvent(payload: unknown): void {}
+    }
+
+    const metadata = getOnEventMetadata(TestService);
+    expect(metadata?.[0]?.async).toBe(false);
+    expect(metadata?.[0]?.priority).toBe(0);
+  });
+
+  test('should support async option', () => {
+    @Injectable()
+    class TestService {
+      @OnEvent('test.event', { async: true })
+      public handleEvent(payload: unknown): void {}
+    }
+
+    const metadata = getOnEventMetadata(TestService);
+    expect(metadata?.[0]?.async).toBe(true);
+  });
+
+  test('should support priority option', () => {
+    @Injectable()
+    class TestService {
+      @OnEvent('test.event', { priority: 10 })
+      public handleEvent(payload: unknown): void {}
+    }
+
+    const metadata = getOnEventMetadata(TestService);
+    expect(metadata?.[0]?.priority).toBe(10);
+  });
+
+  test('should support both async and priority options', () => {
+    @Injectable()
+    class TestService {
+      @OnEvent('test.event', { async: true, priority: 5 })
+      public handleEvent(payload: unknown): void {}
+    }
+
+    const metadata = getOnEventMetadata(TestService);
+    expect(metadata?.[0]?.async).toBe(true);
+    expect(metadata?.[0]?.priority).toBe(5);
+  });
+
+  test('should not mark class without @OnEvent as listener class', () => {
+    @Injectable()
+    class RegularService {
+      public doSomething(): void {}
+    }
+
+    expect(isEventListenerClass(RegularService)).toBe(false);
+  });
+
+  test('should return undefined for class without @OnEvent', () => {
+    @Injectable()
+    class RegularService {
+      public doSomething(): void {}
+    }
+
+    const metadata = getOnEventMetadata(RegularService);
+    expect(metadata).toBeUndefined();
+  });
+});
+
+describe('Event metadata isolation', () => {
+  test('should isolate metadata between different classes', () => {
+    @Injectable()
+    class ServiceA {
+      @OnEvent('event.a')
+      public handleA(payload: unknown): void {}
+    }
+
+    @Injectable()
+    class ServiceB {
+      @OnEvent('event.b')
+      public handleB(payload: unknown): void {}
+    }
+
+    const metadataA = getOnEventMetadata(ServiceA);
+    const metadataB = getOnEventMetadata(ServiceB);
+
+    expect(metadataA?.length).toBe(1);
+    expect(metadataA?.[0]?.event).toBe('event.a');
+
+    expect(metadataB?.length).toBe(1);
+    expect(metadataB?.[0]?.event).toBe('event.b');
+  });
+});