@dangao/bun-server 1.9.0 → 1.12.0

package/tests/core/apply-decorators.test.ts

@@ -0,0 +1,109 @@
+import 'reflect-metadata';
+import { describe, expect, test } from 'bun:test';
+import { applyDecorators } from '../../src/core/apply-decorators';
+
+const TEST_KEY_A = Symbol('test:a');
+const TEST_KEY_B = Symbol('test:b');
+const TEST_KEY_C = Symbol('test:c');
+
+function MarkA(value: string): MethodDecorator {
+  return (target, propertyKey) => {
+    Reflect.defineMetadata(TEST_KEY_A, value, target, propertyKey);
+  };
+}
+
+function MarkB(value: number): MethodDecorator {
+  return (target, propertyKey) => {
+    Reflect.defineMetadata(TEST_KEY_B, value, target, propertyKey);
+  };
+}
+
+function ClassMark(value: string): ClassDecorator {
+  return (target) => {
+    Reflect.defineMetadata(TEST_KEY_C, value, target);
+  };
+}
+
+describe('applyDecorators', () => {
+  test('should compose method decorators', () => {
+    const Combined = applyDecorators(MarkA('hello'), MarkB(42));
+
+    class TestClass {
+      @Combined
+      public myMethod(): void {}
+    }
+
+    const a = Reflect.getMetadata(TEST_KEY_A, TestClass.prototype, 'myMethod');
+    const b = Reflect.getMetadata(TEST_KEY_B, TestClass.prototype, 'myMethod');
+    expect(a).toBe('hello');
+    expect(b).toBe(42);
+  });
+
+  test('should compose class decorators', () => {
+    const Combined = applyDecorators(
+      ClassMark('cls-value'),
+    );
+
+    @Combined
+    class TestClass {}
+
+    const c = Reflect.getMetadata(TEST_KEY_C, TestClass);
+    expect(c).toBe('cls-value');
+  });
+
+  test('should apply decorators in correct order (last applied first)', () => {
+    const order: string[] = [];
+
+    function Track(label: string): MethodDecorator {
+      return (target, propertyKey) => {
+        order.push(label);
+      };
+    }
+
+    const Combined = applyDecorators(Track('first'), Track('second'));
+
+    class TestClass {
+      @Combined
+      public myMethod(): void {}
+    }
+
+    // decorators.reverse() means 'second' is applied first, then 'first'
+    expect(order).toEqual(['second', 'first']);
+  });
+
+  test('should work with single decorator', () => {
+    const Combined = applyDecorators(MarkA('solo'));
+
+    class TestClass {
+      @Combined
+      public myMethod(): void {}
+    }
+
+    const a = Reflect.getMetadata(TEST_KEY_A, TestClass.prototype, 'myMethod');
+    expect(a).toBe('solo');
+  });
+
+  test('should work with many decorators', () => {
+    const keys: symbol[] = [];
+    const decorators: MethodDecorator[] = [];
+    for (let i = 0; i < 10; i++) {
+      const key = Symbol(`test:${i}`);
+      keys.push(key);
+      decorators.push((target, propertyKey) => {
+        Reflect.defineMetadata(key, i, target, propertyKey);
+      });
+    }
+
+    const Combined = applyDecorators(...decorators);
+
+    class TestClass {
+      @Combined
+      public myMethod(): void {}
+    }
+
+    for (let i = 0; i < 10; i++) {
+      const val = Reflect.getMetadata(keys[i]!, TestClass.prototype, 'myMethod');
+      expect(val).toBe(i);
+    }
+  });
+});

package/tests/core/cluster.test.ts

@@ -0,0 +1,32 @@
+import 'reflect-metadata';
+import { describe, expect, test } from 'bun:test';
+import { ClusterManager } from '../../src/core/cluster';
+
+describe('ClusterManager', () => {
+  test('isWorker should return false in test environment', () => {
+    expect(ClusterManager.isWorker()).toBe(false);
+  });
+
+  test('getWorkerId should return -1 when not in worker', () => {
+    expect(ClusterManager.getWorkerId()).toBe(-1);
+  });
+
+  test('should calculate worker count from auto', () => {
+    const manager = new ClusterManager({
+      workers: 'auto',
+      scriptPath: '/tmp/test.ts',
+      port: 3000,
+    });
+    // auto should resolve to CPU core count
+    expect(manager).toBeDefined();
+  });
+
+  test('should accept explicit worker count', () => {
+    const manager = new ClusterManager({
+      workers: 4,
+      scriptPath: '/tmp/test.ts',
+      port: 3000,
+    });
+    expect(manager).toBeDefined();
+  });
+});

package/tests/dashboard/dashboard-module.test.ts

@@ -0,0 +1,85 @@
+import { describe, expect, test, beforeEach } from 'bun:test';
+import { Application } from '../../src/core/application';
+import { DashboardModule } from '../../src/dashboard';
+import { RouteRegistry } from '../../src/router/registry';
+import { MODULE_METADATA_KEY } from '../../src/di/module';
+
+describe('DashboardModule', () => {
+  beforeEach(() => {
+    Reflect.deleteMetadata(MODULE_METADATA_KEY, DashboardModule);
+  });
+
+  test('should register dashboard extension in forRoot', () => {
+    DashboardModule.forRoot({ path: '/_dashboard' });
+    const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, DashboardModule);
+    expect(metadata).toBeDefined();
+    expect(metadata.extensions).toHaveLength(1);
+  });
+
+  test('should use default path when not specified', () => {
+    DashboardModule.forRoot({});
+    const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, DashboardModule);
+    expect(metadata).toBeDefined();
+    expect(metadata.extensions).toHaveLength(1);
+  });
+
+  test('should register routes when extension is used', async () => {
+    const app = new Application();
+    app.registerModule(DashboardModule.forRoot({ path: '/_dashboard' }));
+    await app.listen(0);
+    try {
+      const port = app.getServer()?.getPort() ?? 0;
+      const baseRes = await fetch(`http://127.0.0.1:${port}/_dashboard`);
+      expect(baseRes.status).toBe(200);
+      expect(baseRes.headers.get('Content-Type')).toContain('text/html');
+
+      const systemRes = await fetch(`http://127.0.0.1:${port}/_dashboard/api/system`);
+      expect(systemRes.status).toBe(200);
+      const systemData = await systemRes.json();
+      expect(systemData).toHaveProperty('uptime');
+      expect(systemData).toHaveProperty('memory');
+      expect(systemData.memory).toHaveProperty('rss');
+      expect(systemData.memory).toHaveProperty('heapUsed');
+      expect(systemData).toHaveProperty('platform');
+      expect(systemData).toHaveProperty('bunVersion');
+
+      const routesRes = await fetch(`http://127.0.0.1:${port}/_dashboard/api/routes`);
+      expect(routesRes.status).toBe(200);
+      const routesData = await routesRes.json();
+      expect(Array.isArray(routesData)).toBe(true);
+
+      const healthRes = await fetch(`http://127.0.0.1:${port}/_dashboard/api/health`);
+      expect(healthRes.status).toBe(200);
+      const healthData = await healthRes.json();
+      expect(healthData).toHaveProperty('status');
+      expect(healthData).toHaveProperty('timestamp');
+    } finally {
+      await app.stop();
+    }
+  });
+
+  test('should require Basic Auth when configured', async () => {
+    const app = new Application();
+    app.registerModule(
+      DashboardModule.forRoot({
+        path: '/_dashboard',
+        auth: { username: 'admin', password: 'secret' },
+      }),
+    );
+    await app.listen(0);
+    try {
+      const port = app.getServer()?.getPort() ?? 0;
+      const res = await fetch(`http://127.0.0.1:${port}/_dashboard/api/system`);
+      expect(res.status).toBe(401);
+
+      const authRes = await fetch(`http://127.0.0.1:${port}/_dashboard/api/system`, {
+        headers: {
+          Authorization: 'Basic ' + btoa('admin:secret'),
+        },
+      });
+      expect(authRes.status).toBe(200);
+    } finally {
+      await app.stop();
+    }
+  });
+});

package/tests/database/database-module.test.ts

@@ -3,7 +3,6 @@ import { DatabaseModule, DatabaseService, DATABASE_SERVICE_TOKEN } from '../../s
 import { Container } from '../../src/di/container';
 import { ModuleRegistry } from '../../src/di/module-registry';
 import { MODULE_METADATA_KEY } from '../../src/di/module';
-import 'reflect-metadata';
 
 describe('DatabaseModule', () => {
   let container: Container;

package/tests/database/orm.test.ts

@@ -11,7 +11,6 @@ import {
 } from '../../src/database/orm';
 import { DatabaseService, DATABASE_SERVICE_TOKEN } from '../../src/database';
 import { Container } from '../../src/di/container';
-import 'reflect-metadata';
 
 // 测试实体
 @Entity('test_users')

package/tests/database/postgres-mysql-integration.test.ts

@@ -7,7 +7,6 @@ import {
 import { Container } from '../../src/di/container';
 import { ModuleRegistry } from '../../src/di/module-registry';
 import { MODULE_METADATA_KEY } from '../../src/di/module';
-import 'reflect-metadata';
 
 /**
  * PostgreSQL/MySQL 集成测试

package/tests/database/transaction.test.ts

@@ -9,7 +9,6 @@ import {
 } from '../../src/database/orm';
 import { DatabaseService, DATABASE_SERVICE_TOKEN } from '../../src/database';
 import { Container } from '../../src/di/container';
-import 'reflect-metadata';
 
 describe('TransactionManager', () => {
   let container: Container;

package/tests/debug/debug-module.test.ts

@@ -0,0 +1,141 @@
+import { describe, expect, test, beforeEach, afterEach } from 'bun:test';
+import { Application } from '../../src/core/application';
+import { DebugModule, RequestRecorder } from '../../src/debug';
+import { MODULE_METADATA_KEY } from '../../src/di/module';
+import { getTestPort } from '../utils/test-port';
+
+describe('RequestRecorder', () => {
+  let recorder: RequestRecorder;
+
+  beforeEach(() => {
+    recorder = new RequestRecorder(10);
+  });
+
+  test('should record and retrieve requests', () => {
+    recorder.record({
+      timestamp: 1000,
+      request: { method: 'GET', path: '/test', headers: {} },
+      response: { status: 200, headers: {}, bodySize: 0 },
+      timing: { total: 5 },
+      metadata: {},
+    });
+
+    const all = recorder.getAll();
+    expect(all).toHaveLength(1);
+    expect(all[0].request.method).toBe('GET');
+    expect(all[0].request.path).toBe('/test');
+    expect(all[0].id).toBeDefined();
+  });
+
+  test('should get record by id', () => {
+    recorder.record({
+      timestamp: 1000,
+      request: { method: 'POST', path: '/api', headers: {} },
+      response: { status: 201, headers: {}, bodySize: 10 },
+      timing: { total: 10 },
+      metadata: {},
+    });
+
+    const all = recorder.getAll();
+    const id = all[0].id;
+    const found = recorder.getById(id);
+    expect(found).toBeDefined();
+    expect(found?.request.method).toBe('POST');
+  });
+
+  test('should use ring buffer when maxRecords exceeded', () => {
+    for (let i = 0; i < 15; i++) {
+      recorder.record({
+        timestamp: 1000 + i,
+        request: { method: 'GET', path: `/test/${i}`, headers: {} },
+        response: { status: 200, headers: {}, bodySize: 0 },
+        timing: { total: 1 },
+        metadata: {},
+      });
+    }
+
+    expect(recorder.getCount()).toBe(10);
+    expect(recorder.getAll()).toHaveLength(10);
+  });
+
+  test('should clear all records', () => {
+    recorder.record({
+      timestamp: 1000,
+      request: { method: 'GET', path: '/test', headers: {} },
+      response: { status: 200, headers: {}, bodySize: 0 },
+      timing: { total: 1 },
+      metadata: {},
+    });
+
+    recorder.clear();
+    expect(recorder.getCount()).toBe(0);
+    expect(recorder.getAll()).toHaveLength(0);
+  });
+});
+
+describe('DebugModule', () => {
+  beforeEach(() => {
+    Reflect.deleteMetadata(MODULE_METADATA_KEY, DebugModule);
+  });
+
+  test('should register providers and middlewares via forRoot', () => {
+    DebugModule.forRoot({ maxRecords: 100, path: '/_debug' });
+
+    const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, DebugModule);
+    expect(metadata.providers).toBeDefined();
+    expect(metadata.providers.length).toBeGreaterThanOrEqual(2);
+    expect(metadata.middlewares).toBeDefined();
+    expect(metadata.middlewares.length).toBe(2);
+  });
+
+  test('should not add middlewares when disabled', () => {
+    DebugModule.forRoot({ enabled: false });
+
+    const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, DebugModule);
+    expect(metadata.middlewares).toHaveLength(0);
+  });
+});
+
+describe('DebugModule Integration', () => {
+  let app: Application;
+  let port: number;
+
+  beforeEach(() => {
+    Reflect.deleteMetadata(MODULE_METADATA_KEY, DebugModule);
+    port = getTestPort();
+    app = new Application();
+    app.registerModule(DebugModule.forRoot({ path: '/_debug', maxRecords: 50 }));
+  });
+
+  afterEach(async () => {
+    await app.stop();
+  });
+
+  test('should serve debug UI at configured path', async () => {
+    await app.listen(port);
+    const res = await fetch(`http://localhost:${port}/_debug`);
+    expect(res.status).toBe(200);
+    expect(res.headers.get('content-type')).toContain('text/html');
+    const html = await res.text();
+    expect(html).toContain('Debug - Request Replay');
+  });
+
+  test('should list records via API', async () => {
+    await app.listen(port);
+    await fetch(`http://localhost:${port}/api/test`);
+    const res = await fetch(`http://localhost:${port}/_debug/api/records`);
+    expect(res.status).toBe(200);
+    const data = await res.json();
+    expect(Array.isArray(data)).toBe(true);
+  });
+
+  test('should clear records via API', async () => {
+    await app.listen(port);
+    const res = await fetch(`http://localhost:${port}/_debug/api/records`, {
+      method: 'DELETE',
+    });
+    expect(res.status).toBe(200);
+    const data = await res.json();
+    expect(data.ok).toBe(true);
+  });
+});

package/tests/di/async-module.test.ts

@@ -0,0 +1,125 @@
+import 'reflect-metadata';
+import { describe, expect, test, beforeEach } from 'bun:test';
+import { AsyncProviderRegistry, registerAsyncProviders } from '../../src/di/async-module';
+import { Module, MODULE_METADATA_KEY } from '../../src/di/module';
+import { Container } from '../../src/di/container';
+
+const TEST_TOKEN_A = Symbol('test:a');
+const TEST_TOKEN_B = Symbol('test:b');
+const DEP_TOKEN = Symbol('test:dep');
+
+describe('AsyncProviderRegistry', () => {
+  beforeEach(() => {
+    AsyncProviderRegistry.getInstance().clear();
+  });
+
+  test('should register and initialize async providers', async () => {
+    const registry = AsyncProviderRegistry.getInstance();
+    const container = new Container();
+
+    registry.register(TEST_TOKEN_A, async () => {
+      return { value: 'async-value' };
+    });
+
+    expect(registry.hasPending()).toBe(true);
+
+    await registry.initializeAll(container);
+
+    expect(registry.hasPending()).toBe(false);
+    const resolved = container.resolve<{ value: string }>(TEST_TOKEN_A);
+    expect(resolved.value).toBe('async-value');
+  });
+
+  test('should resolve inject dependencies from container', async () => {
+    const registry = AsyncProviderRegistry.getInstance();
+    const container = new Container();
+
+    container.registerInstance(DEP_TOKEN, { url: 'postgres://localhost' });
+
+    registry.register(TEST_TOKEN_A, async (c) => {
+      const dep = c.resolve<{ url: string }>(DEP_TOKEN);
+      return { connectionUrl: dep.url };
+    });
+
+    await registry.initializeAll(container);
+
+    const resolved = container.resolve<{ connectionUrl: string }>(TEST_TOKEN_A);
+    expect(resolved.connectionUrl).toBe('postgres://localhost');
+  });
+
+  test('should initialize multiple async providers in order', async () => {
+    const registry = AsyncProviderRegistry.getInstance();
+    const container = new Container();
+    const order: string[] = [];
+
+    registry.register(TEST_TOKEN_A, async () => {
+      order.push('a');
+      return 'value-a';
+    });
+
+    registry.register(TEST_TOKEN_B, async () => {
+      order.push('b');
+      return 'value-b';
+    });
+
+    await registry.initializeAll(container);
+
+    expect(order).toEqual(['a', 'b']);
+    expect(container.resolve(TEST_TOKEN_A)).toBe('value-a');
+    expect(container.resolve(TEST_TOKEN_B)).toBe('value-b');
+  });
+});
+
+describe('registerAsyncProviders', () => {
+  beforeEach(() => {
+    AsyncProviderRegistry.getInstance().clear();
+  });
+
+  test('should register async tokens on module metadata', () => {
+    @Module({ providers: [] })
+    class TestModule {}
+
+    Reflect.deleteMetadata(MODULE_METADATA_KEY, TestModule);
+
+    const tokenMap = new Map<symbol, (config: { name: string }) => unknown>();
+    tokenMap.set(TEST_TOKEN_A, (config) => config.name);
+
+    registerAsyncProviders(
+      TestModule,
+      {
+        useFactory: () => ({ name: 'hello' }),
+      },
+      tokenMap,
+    );
+
+    const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, TestModule);
+    expect(metadata).toBeDefined();
+    expect(metadata.exports).toContain(TEST_TOKEN_A);
+  });
+
+  test('should work end-to-end with AsyncProviderRegistry', async () => {
+    const registry = AsyncProviderRegistry.getInstance();
+    const container = new Container();
+
+    @Module({ providers: [] })
+    class TestModule {}
+
+    Reflect.deleteMetadata(MODULE_METADATA_KEY, TestModule);
+
+    const tokenMap = new Map<symbol, (config: { port: number }) => unknown>();
+    tokenMap.set(TEST_TOKEN_A, (config) => ({ port: config.port }));
+
+    registerAsyncProviders(
+      TestModule,
+      {
+        useFactory: async () => ({ port: 5432 }),
+      },
+      tokenMap,
+    );
+
+    await registry.initializeAll(container);
+
+    const resolved = container.resolve<{ port: number }>(TEST_TOKEN_A);
+    expect(resolved.port).toBe(5432);
+  });
+});

package/tests/di/container.test.ts

@@ -1,4 +1,3 @@
-import 'reflect-metadata';
 import { describe, expect, test, beforeEach } from 'bun:test';
 import { Container } from '../../src/di/container';
 import { Lifecycle } from '../../src/di/types';

package/tests/di/lifecycle.test.ts

@@ -0,0 +1,140 @@
+import 'reflect-metadata';
+import { describe, expect, test, beforeEach } from 'bun:test';
+import { Application } from '../../src/core/application';
+import { Module } from '../../src/di/module';
+import { Injectable, Inject } from '../../src/di/decorators';
+import { Controller } from '../../src/controller';
+import { GET } from '../../src/router/decorators';
+import type {
+  OnModuleInit,
+  OnModuleDestroy,
+  OnApplicationBootstrap,
+  OnApplicationShutdown,
+} from '../../src/di/lifecycle';
+import {
+  callOnModuleInit,
+  callOnModuleDestroy,
+  callOnApplicationBootstrap,
+  callOnApplicationShutdown,
+} from '../../src/di/lifecycle';
+
+describe('Lifecycle Hooks', () => {
+  describe('type guards and runners', () => {
+    test('callOnModuleInit should invoke onModuleInit', async () => {
+      const calls: string[] = [];
+      const instances = [
+        { onModuleInit: () => { calls.push('a'); } },
+        { onModuleInit: async () => { calls.push('b'); } },
+        { notAHook: true },
+      ];
+
+      await callOnModuleInit(instances);
+      expect(calls).toEqual(['a', 'b']);
+    });
+
+    test('callOnModuleDestroy should invoke in reverse order', async () => {
+      const calls: string[] = [];
+      const instances = [
+        { onModuleDestroy: () => { calls.push('first'); } },
+        { onModuleDestroy: () => { calls.push('second'); } },
+        { onModuleDestroy: () => { calls.push('third'); } },
+      ];
+
+      await callOnModuleDestroy(instances);
+      expect(calls).toEqual(['third', 'second', 'first']);
+    });
+
+    test('callOnApplicationBootstrap should invoke onApplicationBootstrap', async () => {
+      const calls: string[] = [];
+      const instances = [
+        { onApplicationBootstrap: () => { calls.push('boot'); } },
+      ];
+
+      await callOnApplicationBootstrap(instances);
+      expect(calls).toEqual(['boot']);
+    });
+
+    test('callOnApplicationShutdown should pass signal and call in reverse', async () => {
+      const calls: Array<{ name: string; signal?: string }> = [];
+      const instances = [
+        { onApplicationShutdown: (signal?: string) => { calls.push({ name: 'a', signal }); } },
+        { onApplicationShutdown: (signal?: string) => { calls.push({ name: 'b', signal }); } },
+      ];
+
+      await callOnApplicationShutdown(instances, 'SIGTERM');
+      expect(calls).toEqual([
+        { name: 'b', signal: 'SIGTERM' },
+        { name: 'a', signal: 'SIGTERM' },
+      ]);
+    });
+
+    test('should skip non-hook instances', async () => {
+      const calls: string[] = [];
+      const instances = [
+        null,
+        undefined,
+        42,
+        'string',
+        { someOther: true },
+        { onModuleInit: () => { calls.push('ok'); } },
+      ];
+
+      await callOnModuleInit(instances as unknown[]);
+      expect(calls).toEqual(['ok']);
+    });
+  });
+
+  describe('integration with Application', () => {
+    test('should call lifecycle hooks during start and stop', async () => {
+      const calls: string[] = [];
+
+      @Injectable()
+      class LifecycleService implements OnModuleInit, OnModuleDestroy, OnApplicationBootstrap, OnApplicationShutdown {
+        public onModuleInit(): void {
+          calls.push('onModuleInit');
+        }
+        public onModuleDestroy(): void {
+          calls.push('onModuleDestroy');
+        }
+        public onApplicationBootstrap(): void {
+          calls.push('onApplicationBootstrap');
+        }
+        public onApplicationShutdown(signal?: string): void {
+          calls.push(`onApplicationShutdown:${signal ?? 'none'}`);
+        }
+      }
+
+      @Controller('/test')
+      class TestController {
+        @GET('/')
+        public get(): string {
+          return 'ok';
+        }
+      }
+
+      @Module({
+        controllers: [TestController],
+        providers: [LifecycleService],
+      })
+      class TestModule {}
+
+      const app = new Application({ port: 0, enableSignalHandlers: false });
+      app.registerModule(TestModule);
+      await app.listen(0);
+
+      expect(calls).toContain('onModuleInit');
+      expect(calls).toContain('onApplicationBootstrap');
+
+      const initIdx = calls.indexOf('onModuleInit');
+      const bootIdx = calls.indexOf('onApplicationBootstrap');
+      expect(initIdx).toBeLessThan(bootIdx);
+
+      await app.stop();
+
+      expect(calls).toContain('onModuleDestroy');
+      // onApplicationShutdown with no signal when using stop() directly
+      const shutdownEntry = calls.find((c) => c.startsWith('onApplicationShutdown'));
+      expect(shutdownEntry).toBeDefined();
+    });
+  });
+});

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

@@ -1,5 +1,4 @@
 import { describe, expect, test, beforeEach } from 'bun:test';
-import 'reflect-metadata';
 
 import { handleError } from '../../src/error/handler';
 import { HttpException, BadRequestException, UnauthorizedException, ForbiddenException, NotFoundException } from '../../src/error';

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

@@ -1,5 +1,4 @@
 import { describe, expect, test, beforeEach } from 'bun:test';
-import 'reflect-metadata';
 import {
   OnEvent,
   getOnEventMetadata,