@dangao/bun-server 1.0.0 → 1.0.3

package/tests/di/container.test.ts

@@ -0,0 +1,264 @@
+import 'reflect-metadata';
+import { describe, expect, test, beforeEach } from 'bun:test';
+import { Container } from '../../src/di/container';
+import { Lifecycle } from '../../src/di/types';
+import { Injectable, Inject } from '../../src/di/decorators';
+import { Controller, ControllerRegistry } from '../../src/controller/controller';
+import { GET } from '../../src/router/decorators';
+import { RouteRegistry } from '../../src/router/registry';
+import { Context } from '../../src/core/context';
+
+describe('Container', () => {
+  let container: Container;
+
+  beforeEach(() => {
+    container = new Container();
+    // 清理全局注册表，避免测试间污染
+    RouteRegistry.getInstance().clear();
+    ControllerRegistry.getInstance().clear();
+  });
+
+  test('should create container instance', () => {
+    expect(container).toBeInstanceOf(Container);
+  });
+
+  test('should register and resolve singleton', () => {
+    class TestService {
+      public value = 'test';
+    }
+
+    container.register(TestService, { lifecycle: Lifecycle.Singleton });
+
+    const instance1 = container.resolve(TestService);
+    const instance2 = container.resolve(TestService);
+
+    expect(instance1).toBe(instance2);
+    expect(instance1.value).toBe('test');
+  });
+
+  test('should register and resolve transient', () => {
+    class TestService {
+      public value = 'test';
+    }
+
+    container.register(TestService, { lifecycle: Lifecycle.Transient });
+
+    const instance1 = container.resolve(TestService);
+    const instance2 = container.resolve(TestService);
+
+    expect(instance1).not.toBe(instance2);
+    expect(instance1.value).toBe('test');
+    expect(instance2.value).toBe('test');
+  });
+
+  test('should resolve with constructor injection', () => {
+    @Injectable()
+    class Dependency {
+      public name = 'dependency';
+    }
+
+    @Injectable()
+    class Service {
+      public dependency: Dependency;
+
+      public constructor(@Inject(Dependency) dependency: Dependency) {
+        this.dependency = dependency;
+      }
+    }
+
+    container.register(Dependency);
+    container.register(Service);
+
+    const service = container.resolve(Service);
+
+    expect(service).toBeInstanceOf(Service);
+    expect(service.dependency).toBeInstanceOf(Dependency);
+    expect(service.dependency.name).toBe('dependency');
+  });
+
+  test('should resolve nested dependencies', () => {
+    @Injectable()
+    class Level1 {
+      public name = 'level1';
+    }
+
+    @Injectable()
+    class Level2 {
+      public level1: Level1;
+
+      public constructor(@Inject(Level1) level1: Level1) {
+        this.level1 = level1;
+      }
+    }
+
+    @Injectable()
+    class Level3 {
+      public level2: Level2;
+
+      public constructor(@Inject(Level2) level2: Level2) {
+        this.level2 = level2;
+      }
+    }
+
+    container.register(Level1);
+    container.register(Level2);
+    container.register(Level3);
+
+    const level3 = container.resolve(Level3);
+
+    expect(level3).toBeInstanceOf(Level3);
+    expect(level3.level2).toBeInstanceOf(Level2);
+    expect(level3.level2.level1).toBeInstanceOf(Level1);
+    expect(level3.level2.level1.name).toBe('level1');
+  });
+
+  test('should resolve dependency without explicit registration when constructor has no deps', () => {
+    @Injectable()
+    class PlainService {
+      public id = 'plain';
+    }
+
+    @Injectable()
+    class Consumer {
+      public constructor(public readonly service: PlainService) {}
+    }
+
+    container.register(Consumer);
+
+    const consumer = container.resolve(Consumer);
+    expect(consumer.service).toBeInstanceOf(PlainService);
+    expect(consumer.service.id).toBe('plain');
+  });
+
+  test('should use factory function', () => {
+    class TestService {
+      public value: string;
+
+      public constructor(value: string) {
+        this.value = value;
+      }
+    }
+
+    container.register(TestService, {
+      factory: () => new TestService('factory-created'),
+    });
+
+    const instance = container.resolve(TestService);
+
+    expect(instance).toBeInstanceOf(TestService);
+    expect(instance.value).toBe('factory-created');
+  });
+
+  test('should register and resolve instance', () => {
+    class TestService {
+      public value = 'pre-created';
+    }
+
+    const instance = new TestService();
+    container.registerInstance(TestService, instance);
+
+    const resolved = container.resolve(TestService);
+
+    expect(resolved).toBe(instance);
+    expect(resolved.value).toBe('pre-created');
+  });
+
+  test('should resolve dependencies registered in container via controller registry', () => {
+    @Injectable()
+    class Service {
+      public id = 'service';
+    }
+
+    @Injectable()
+    class Controller {
+      public constructor(@Inject(Service) public readonly service: Service) {}
+    }
+
+    container.register(Service);
+    container.register(Controller);
+
+    const instance = container.resolve(Controller);
+    expect(instance.service).toBeInstanceOf(Service);
+    expect(instance.service.id).toBe('service');
+  });
+
+  test('should resolve service when controller registered through registry', async () => {
+    @Injectable()
+    class Service {
+      public name = 'svc';
+    }
+
+    @Controller('/test-di')
+    class TestController {
+      public constructor(@Inject(Service) public readonly svc: Service) {}
+
+      @GET('/')
+      public get() {
+        return this.svc.name;
+      }
+    }
+
+    const controllerRegistry = ControllerRegistry.getInstance();
+    const routeRegistry = RouteRegistry.getInstance();
+    controllerRegistry.clear();
+    routeRegistry.clear();
+    controllerRegistry.getContainer().register(Service);
+    controllerRegistry.register(TestController);
+
+    const router = routeRegistry.getRouter();
+    const request = new Request('http://localhost/test-di');
+    const context = new Context(request);
+
+    const response = await router.handle(context);
+    expect(response?.status).toBe(200);
+    expect(await response?.text()).toBe('svc');
+    controllerRegistry.clear();
+    routeRegistry.clear();
+  });
+
+  test('should check if registered', () => {
+    class TestService {}
+
+    expect(container.isRegistered(TestService)).toBe(false);
+
+    container.register(TestService);
+
+    expect(container.isRegistered(TestService)).toBe(true);
+  });
+
+  test('should clear all registrations', () => {
+    class TestService {}
+
+    container.register(TestService);
+    expect(container.isRegistered(TestService)).toBe(true);
+
+    container.clear();
+    expect(container.isRegistered(TestService)).toBe(false);
+  });
+
+  test('should throw error for unregistered provider with dependencies', () => {
+    @Injectable()
+    class Dependency {}
+    
+    @Injectable()
+    class UnregisteredService {
+      public constructor(@Inject() dependency: Dependency) {}
+    }
+
+    // 只注册 Dependency，不注册 UnregisteredService
+    container.register(Dependency);
+
+    // 尝试解析未注册的服务，应该抛出错误
+    expect(() => {
+      container.resolve(UnregisteredService);
+    }).toThrow('Provider not found');
+  });
+
+  // 注意：循环依赖测试暂时跳过
+  // 因为类定义时的循环引用会导致编译错误
+  // 循环依赖检测可以在后续版本中实现
+  // test('should handle circular dependencies', () => {
+  //   // 循环依赖会导致无限递归，实际使用中应该避免
+  // });
+});
+

package/tests/di/module.test.ts

@@ -0,0 +1,128 @@
+import { beforeEach, afterEach, describe, expect, test } from 'bun:test';
+
+import { Application } from '../../src/core/application';
+import { Controller, ControllerRegistry } from '../../src/controller/controller';
+import { GET } from '../../src/router/decorators';
+import { Module } from '../../src/di/module';
+import { ModuleRegistry } from '../../src/di/module-registry';
+import { RouteRegistry } from '../../src/router/registry';
+import { Injectable, Inject } from '../../src/di/decorators';
+import { Context } from '../../src/core/context';
+
+describe('ModuleRegistry', () => {
+  beforeEach(() => {
+    // 清理全局注册表，避免测试间污染
+    RouteRegistry.getInstance().clear();
+    ControllerRegistry.getInstance().clear();
+    ModuleRegistry.getInstance().clear();
+  });
+
+  afterEach(() => {
+    // 确保测试后清理
+    RouteRegistry.getInstance().clear();
+    ControllerRegistry.getInstance().clear();
+    ModuleRegistry.getInstance().clear();
+  });
+
+  test('should register module providers and controllers', async () => {
+    @Injectable()
+    class UserService {
+      public list(): string {
+        return 'users';
+      }
+    }
+
+    @Controller('/module-users')
+    class UserController {
+      public constructor(private readonly service: UserService) {}
+
+      @GET('/')
+      public getUsers(): string {
+        return this.service.list();
+      }
+    }
+
+    @Module({
+      controllers: [UserController],
+      providers: [UserService],
+      exports: [UserService],
+    })
+    class UserModule {}
+
+    const app = new Application();
+    app.registerModule(UserModule);
+
+    const moduleRef = ModuleRegistry.getInstance().getModuleRef(UserModule);
+    expect(moduleRef).toBeDefined();
+    expect(moduleRef?.container.resolve(UserService).list()).toBe('users');
+
+    const router = RouteRegistry.getInstance().getRouter();
+    const context = new Context(new Request('http://localhost/module-users'));
+    const response = await router.handle(context);
+    expect(await response?.text()).toBe('users');
+  });
+
+  test('should share exported providers between imported modules', () => {
+    @Injectable()
+    class SharedService {
+      public readonly id = Math.random();
+    }
+
+    @Module({
+      providers: [SharedService],
+      exports: [SharedService],
+    })
+    class SharedModule {}
+
+    @Injectable()
+    class FeatureService {
+      public constructor(@Inject(SharedService) public readonly shared: SharedService) {}
+    }
+
+    @Module({
+      imports: [SharedModule],
+      providers: [FeatureService],
+      exports: [FeatureService],
+    })
+    class FeatureModule {}
+
+    const app = new Application();
+    app.registerModule(FeatureModule);
+
+    const registry = ModuleRegistry.getInstance();
+    const sharedRef = registry.getModuleRef(SharedModule);
+    const featureRef = registry.getModuleRef(FeatureModule);
+    expect(sharedRef).toBeDefined();
+    expect(featureRef).toBeDefined();
+
+    const sharedFromFeature = featureRef!.container.resolve(SharedService);
+    const sharedFromModule = sharedRef!.container.resolve(SharedService);
+    expect(sharedFromFeature).toBe(sharedFromModule);
+
+    const featureService = featureRef!.container.resolve(FeatureService);
+    expect(featureService.shared).toBe(sharedFromModule);
+  });
+
+  test('should throw error for circular module dependencies', () => {
+    @Module({
+      imports: [],
+    })
+    class ModuleA {}
+
+    @Module({
+      imports: [ModuleA],
+    })
+    class ModuleB {}
+
+    // 重新装饰 ModuleA，使其导入 ModuleB，形成环
+    Module({
+      imports: [ModuleB],
+    })(ModuleA);
+
+    const app = new Application();
+    expect(() => app.registerModule(ModuleA)).toThrowError(
+      /Circular module dependency detected/,
+    );
+  });
+});
+

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

@@ -0,0 +1,121 @@
+import { describe, expect, test, beforeEach } from 'bun:test';
+import {
+  HttpException,
+  BadRequestException,
+  UnauthorizedException,
+  ForbiddenException,
+  NotFoundException,
+  InternalServerErrorException,
+} from '../../src/error/http-exception';
+import { ErrorCode, ERROR_CODE_MESSAGES, ERROR_CODE_TO_STATUS } from '../../src/error/error-codes';
+import { ErrorMessageI18n } from '../../src/error/i18n';
+
+describe('ErrorCode', () => {
+  test('should have all error codes defined', () => {
+    expect(ErrorCode.INTERNAL_ERROR).toBe('INTERNAL_ERROR');
+    expect(ErrorCode.AUTH_REQUIRED).toBe('AUTH_REQUIRED');
+    expect(ErrorCode.VALIDATION_FAILED).toBe('VALIDATION_FAILED');
+  });
+
+  test('should have status code mapping for all error codes', () => {
+    const codes = Object.values(ErrorCode);
+    for (const code of codes) {
+      expect(ERROR_CODE_TO_STATUS[code]).toBeDefined();
+      expect(typeof ERROR_CODE_TO_STATUS[code]).toBe('number');
+    }
+  });
+
+  test('should have default messages for all error codes', () => {
+    const codes = Object.values(ErrorCode);
+    for (const code of codes) {
+      expect(ERROR_CODE_MESSAGES[code]).toBeDefined();
+      expect(typeof ERROR_CODE_MESSAGES[code]).toBe('string');
+    }
+  });
+});
+
+describe('HttpException with ErrorCode', () => {
+  test('should create exception with error code', () => {
+    const exception = HttpException.withCode(
+      ErrorCode.AUTH_REQUIRED,
+      'Custom message',
+    );
+
+    expect(exception.code).toBe(ErrorCode.AUTH_REQUIRED);
+    expect(exception.status).toBe(401);
+    expect(exception.message).toBe('Custom message');
+  });
+
+  test('should use default message when not provided', () => {
+    const exception = HttpException.withCode(ErrorCode.AUTH_REQUIRED);
+
+    expect(exception.code).toBe(ErrorCode.AUTH_REQUIRED);
+    expect(exception.status).toBe(401);
+    expect(exception.message).toBe(ERROR_CODE_MESSAGES[ErrorCode.AUTH_REQUIRED]);
+  });
+
+  test('should support details with error code', () => {
+    const details = { userId: '123', reason: 'Token expired' };
+    const exception = HttpException.withCode(
+      ErrorCode.AUTH_TOKEN_EXPIRED,
+      undefined,
+      details,
+    );
+
+    expect(exception.code).toBe(ErrorCode.AUTH_TOKEN_EXPIRED);
+    expect(exception.details).toEqual(details);
+  });
+
+  test('should allow custom exception classes with error code', () => {
+    const exception = new UnauthorizedException(
+      'Custom message',
+      { token: 'invalid' },
+      ErrorCode.AUTH_INVALID_TOKEN,
+    );
+
+    expect(exception.code).toBe(ErrorCode.AUTH_INVALID_TOKEN);
+    expect(exception.status).toBe(401);
+    expect(exception.message).toBe('Custom message');
+    expect(exception.details).toEqual({ token: 'invalid' });
+  });
+});
+
+describe('ErrorMessageI18n', () => {
+  beforeEach(() => {
+    ErrorMessageI18n.setLanguage('en');
+  });
+
+  test('should get English message by default', () => {
+    const message = ErrorMessageI18n.getMessage(ErrorCode.AUTH_REQUIRED);
+    expect(message).toBe('Authentication Required');
+  });
+
+  test('should get Chinese message when language is zh-CN', () => {
+    ErrorMessageI18n.setLanguage('zh-CN');
+    const message = ErrorMessageI18n.getMessage(ErrorCode.AUTH_REQUIRED);
+    expect(message).toBe('需要认证');
+  });
+
+  test('should parse language from Accept-Language header', () => {
+    expect(ErrorMessageI18n.parseLanguageFromHeader('zh-CN,zh;q=0.9')).toBe('zh-CN');
+    expect(ErrorMessageI18n.parseLanguageFromHeader('zh,en;q=0.9')).toBe('zh-CN');
+    expect(ErrorMessageI18n.parseLanguageFromHeader('en-US,en;q=0.9')).toBe('en');
+    expect(ErrorMessageI18n.parseLanguageFromHeader(null)).toBe('en');
+    expect(ErrorMessageI18n.parseLanguageFromHeader(undefined)).toBe('en');
+  });
+
+  test('should get message for specific language', () => {
+    const enMessage = ErrorMessageI18n.getMessage(ErrorCode.AUTH_REQUIRED, 'en');
+    const zhMessage = ErrorMessageI18n.getMessage(ErrorCode.AUTH_REQUIRED, 'zh-CN');
+
+    expect(enMessage).toBe('Authentication Required');
+    expect(zhMessage).toBe('需要认证');
+  });
+
+  test('should fallback to English if message not found', () => {
+    // 测试未定义的错误码应该回退到英文
+    const message = ErrorMessageI18n.getMessage(ErrorCode.INTERNAL_ERROR, 'zh-CN');
+    expect(message).toBeDefined();
+  });
+});
+

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

@@ -0,0 +1,68 @@
+import { describe, expect, test } from 'bun:test';
+
+import { Context } from '../../src/core/context';
+import { handleError } from '../../src/error/handler';
+import { HttpException, BadRequestException } from '../../src/error/http-exception';
+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');
+  });
+
+  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);
+  });
+
+  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();
+  });
+
+  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');
+  });
+});
+
+