@dangao/bun-server 1.9.0 → 1.12.0

package/src/testing/test-client.ts

@@ -0,0 +1,112 @@
+import type { Application } from '../core/application';
+
+interface RequestOptions {
+  headers?: Record<string, string>;
+  body?: unknown;
+  query?: Record<string, string>;
+}
+
+interface TestResponse {
+  status: number;
+  headers: Headers;
+  body: unknown;
+  text: string;
+  ok: boolean;
+}
+
+/**
+ * HTTP 测试客户端
+ * 基于 fetch API，提供简洁的 HTTP 请求方法
+ */
+export class TestHttpClient {
+  private readonly baseUrl: string;
+  private readonly app: Application;
+
+  public constructor(baseUrl: string, app: Application) {
+    this.baseUrl = baseUrl;
+    this.app = app;
+  }
+
+  /**
+   * 发送 GET 请求
+   */
+  public async get(path: string, options?: RequestOptions): Promise<TestResponse> {
+    return this.request('GET', path, options);
+  }
+
+  /**
+   * 发送 POST 请求
+   */
+  public async post(path: string, options?: RequestOptions): Promise<TestResponse> {
+    return this.request('POST', path, options);
+  }
+
+  /**
+   * 发送 PUT 请求
+   */
+  public async put(path: string, options?: RequestOptions): Promise<TestResponse> {
+    return this.request('PUT', path, options);
+  }
+
+  /**
+   * 发送 DELETE 请求
+   */
+  public async delete(path: string, options?: RequestOptions): Promise<TestResponse> {
+    return this.request('DELETE', path, options);
+  }
+
+  /**
+   * 发送 PATCH 请求
+   */
+  public async patch(path: string, options?: RequestOptions): Promise<TestResponse> {
+    return this.request('PATCH', path, options);
+  }
+
+  /**
+   * 关闭测试服务器
+   */
+  public async close(): Promise<void> {
+    await this.app.stop();
+  }
+
+  private async request(method: string, path: string, options?: RequestOptions): Promise<TestResponse> {
+    let url = `${this.baseUrl}${path}`;
+
+    if (options?.query) {
+      const params = new URLSearchParams(options.query);
+      url += `?${params.toString()}`;
+    }
+
+    const fetchOptions: RequestInit = {
+      method,
+      headers: {
+        'Content-Type': 'application/json',
+        ...(options?.headers || {}),
+      },
+    };
+
+    if (options?.body && method !== 'GET') {
+      fetchOptions.body = typeof options.body === 'string'
+        ? options.body
+        : JSON.stringify(options.body);
+    }
+
+    const response = await fetch(url, fetchOptions);
+    const text = await response.text();
+
+    let body: unknown;
+    try {
+      body = JSON.parse(text);
+    } catch {
+      body = text;
+    }
+
+    return {
+      status: response.status,
+      headers: response.headers,
+      body,
+      text,
+      ok: response.ok,
+    };
+  }
+}

package/src/testing/testing-module.ts

@@ -0,0 +1,238 @@
+import 'reflect-metadata';
+
+import { Application, type ApplicationOptions } from '../core/application';
+import { Container } from '../di/container';
+import { ModuleRegistry } from '../di/module-registry';
+import { ControllerRegistry } from '../controller/controller';
+import { RouteRegistry } from '../router/registry';
+import { MODULE_METADATA_KEY, type ModuleMetadata, type ModuleClass, type ModuleProvider, type ProviderToken } from '../di/module';
+import type { Constructor } from '../core/types';
+import { TestHttpClient } from './test-client';
+
+interface ProviderOverride {
+  token: ProviderToken;
+  useValue?: unknown;
+  useClass?: Constructor<unknown>;
+  useFactory?: () => unknown;
+}
+
+/**
+ * 测试模块构建器
+ * 提供流畅的 API 来创建测试用的隔离模块环境
+ */
+export class TestingModuleBuilder {
+  private readonly metadata: ModuleMetadata;
+  private readonly overrides: ProviderOverride[] = [];
+
+  public constructor(metadata: ModuleMetadata) {
+    this.metadata = { ...metadata };
+  }
+
+  /**
+   * 覆盖指定 provider
+   * @param token - 要覆盖的 provider token
+   */
+  public overrideProvider(token: ProviderToken): ProviderOverrideBuilder {
+    return new ProviderOverrideBuilder(this, token);
+  }
+
+  /**
+   * 编译测试模块，返回可用的 TestingModule 实例
+   */
+  public async compile(): Promise<TestingModule> {
+    const providers = this.buildProviders();
+    return new TestingModule(this.metadata, providers, this.overrides);
+  }
+
+  /** @internal */
+  public addOverride(override: ProviderOverride): void {
+    this.overrides.push(override);
+  }
+
+  private buildProviders(): ModuleProvider[] {
+    const providers = [...(this.metadata.providers || [])];
+    const overrideMap = new Map<string | symbol, ProviderOverride>();
+
+    for (const override of this.overrides) {
+      const key = typeof override.token === 'function'
+        ? override.token.name
+        : override.token;
+      overrideMap.set(key as string | symbol, override);
+    }
+
+    const result: ModuleProvider[] = [];
+
+    for (const provider of providers) {
+      const token = typeof provider === 'function'
+        ? provider.name
+        : (provider as { provide?: ProviderToken }).provide;
+      const key = typeof token === 'function' ? token.name : token;
+
+      const override = overrideMap.get(key as string | symbol);
+      if (override) {
+        if (override.useValue !== undefined) {
+          result.push({ provide: override.token, useValue: override.useValue });
+        } else if (override.useClass) {
+          result.push({ provide: override.token, useClass: override.useClass });
+        } else if (override.useFactory) {
+          result.push({ provide: override.token, useFactory: override.useFactory as (container: Container) => unknown });
+        }
+        overrideMap.delete(key as string | symbol);
+      } else {
+        result.push(provider);
+      }
+    }
+
+    for (const override of overrideMap.values()) {
+      if (override.useValue !== undefined) {
+        result.push({ provide: override.token, useValue: override.useValue });
+      }
+    }
+
+    return result;
+  }
+}
+
+class ProviderOverrideBuilder {
+  private readonly builder: TestingModuleBuilder;
+  private readonly token: ProviderToken;
+
+  public constructor(builder: TestingModuleBuilder, token: ProviderToken) {
+    this.builder = builder;
+    this.token = token;
+  }
+
+  /**
+   * 使用固定值覆盖
+   */
+  public useValue(value: unknown): TestingModuleBuilder {
+    this.builder.addOverride({ token: this.token, useValue: value });
+    return this.builder;
+  }
+
+  /**
+   * 使用替代类覆盖
+   */
+  public useClass(cls: Constructor<unknown>): TestingModuleBuilder {
+    this.builder.addOverride({ token: this.token, useClass: cls });
+    return this.builder;
+  }
+
+  /**
+   * 使用工厂函数覆盖
+   */
+  public useFactory(factory: () => unknown): TestingModuleBuilder {
+    this.builder.addOverride({ token: this.token, useFactory: factory });
+    return this.builder;
+  }
+}
+
+/**
+ * 编译后的测试模块
+ * 提供 DI 容器访问和 HTTP 测试客户端创建
+ */
+export class TestingModule {
+  private readonly metadata: ModuleMetadata;
+  private readonly providers: ModuleProvider[];
+  private readonly overrides: ProviderOverride[];
+  private app?: Application;
+  private container?: Container;
+
+  public constructor(
+    metadata: ModuleMetadata,
+    providers: ModuleProvider[],
+    overrides: ProviderOverride[],
+  ) {
+    this.metadata = metadata;
+    this.providers = providers;
+    this.overrides = overrides;
+  }
+
+  /**
+   * 从容器中获取 provider 实例
+   */
+  public get<T>(token: Constructor<T> | string | symbol): T {
+    return this.getContainer().resolve<T>(token);
+  }
+
+  /**
+   * 创建一个 Application 实例并注册所有 providers、controllers
+   * @param options - 应用配置
+   */
+  public createApplication(options: ApplicationOptions = {}): Application {
+    if (this.app) return this.app;
+
+    this.app = new Application({
+      enableSignalHandlers: false,
+      ...options,
+    });
+
+    const container = this.app.getContainer();
+    this.container = container;
+
+    for (const provider of this.providers) {
+      if (typeof provider === 'function') {
+        container.register(provider);
+      } else if ('useValue' in provider && provider.provide) {
+        container.registerInstance(provider.provide, provider.useValue);
+      } else if ('useFactory' in provider && provider.provide) {
+        container.register(provider.provide as Constructor<unknown>, {
+          factory: () => (provider as { useFactory: (container: Container) => unknown }).useFactory(container),
+        });
+      } else if ('useClass' in provider) {
+        const token = (provider as { provide?: ProviderToken }).provide ?? (provider as { useClass: Constructor<unknown> }).useClass;
+        container.register(token as Constructor<unknown>, {
+          implementation: (provider as { useClass: Constructor<unknown> }).useClass,
+        });
+      }
+    }
+
+    if (this.metadata.imports) {
+      for (const moduleClass of this.metadata.imports) {
+        this.app.registerModule(moduleClass);
+      }
+    }
+
+    if (this.metadata.controllers) {
+      for (const ctrl of this.metadata.controllers) {
+        this.app.registerController(ctrl);
+      }
+    }
+
+    return this.app;
+  }
+
+  /**
+   * 创建 HTTP 测试客户端
+   * 自动启动应用，获取随机端口，返回 TestHttpClient
+   */
+  public async createHttpClient(options: ApplicationOptions = {}): Promise<TestHttpClient> {
+    const app = this.createApplication(options);
+    await app.listen(0);
+    const server = app.getServer();
+    const port = server?.getPort() ?? 3000;
+    return new TestHttpClient(`http://localhost:${port}`, app);
+  }
+
+  /**
+   * 获取 DI 容器
+   */
+  public getContainer(): Container {
+    if (this.container) return this.container;
+    this.createApplication();
+    return this.container!;
+  }
+}
+
+/**
+ * 测试工具入口
+ */
+export class Test {
+  /**
+   * 创建测试模块
+   * @param metadata - 模块元数据
+   */
+  public static createTestingModule(metadata: ModuleMetadata): TestingModuleBuilder {
+    return new TestingModuleBuilder(metadata);
+  }
+}

package/src/websocket/registry.ts

@@ -46,12 +46,7 @@ export class WebSocketGatewayRegistry {
     return WebSocketGatewayRegistry.instance;
   }
 
-  /**
-   * 解析路径，生成匹配模式和参数名列表
-   * @param path - 路由路径
-   * @returns 匹配模式和参数名列表
-   */
-  private parsePath(path: string): { pattern: RegExp; paramNames: string[] } {
+  private static parsePath(path: string): { pattern: RegExp; paramNames: string[] } {
     const paramNames: string[] = [];
     const patternString = path
       .replace(/:([^/]+)/g, (_, paramName) => {
@@ -60,8 +55,7 @@ export class WebSocketGatewayRegistry {
       })
       .replace(/\*/g, '.*');
 
-    const pattern = new RegExp(`^${patternString}$`);
-    return { pattern, paramNames };
+    return { pattern: new RegExp(`^${patternString}$`), paramNames };
   }
 
   public register(gatewayClass: Constructor<unknown>): void {
@@ -79,8 +73,7 @@ export class WebSocketGatewayRegistry {
       this.container.register(gatewayClass);
     }
 
-    // 解析路径
-    const { pattern, paramNames } = this.parsePath(metadata.path);
+    const { pattern, paramNames } = WebSocketGatewayRegistry.parsePath(metadata.path);
     const isStatic = !metadata.path.includes(':') && !metadata.path.includes('*');
 
     const definition: GatewayDefinition = {
@@ -94,7 +87,6 @@ export class WebSocketGatewayRegistry {
 
     this.gateways.set(metadata.path, definition);
 
-    // 分别存储静态和动态路由
     if (isStatic) {
       this.staticGateways.set(metadata.path, definition);
     } else {
@@ -108,12 +100,10 @@ export class WebSocketGatewayRegistry {
    * @returns 是否有匹配的网关
    */
   public hasGateway(path: string): boolean {
-    // 先检查静态路由
     if (this.staticGateways.has(path)) {
       return true;
     }
 
-    // 遍历动态路由
     for (const gateway of this.dynamicGateways) {
       if (gateway.pattern.test(path)) {
         return true;
@@ -135,17 +125,14 @@ export class WebSocketGatewayRegistry {
    * @returns 匹配的网关定义和路径参数
    */
   private getGateway(path: string): { definition: GatewayDefinition; params: Record<string, string> } | undefined {
-    // 先检查静态路由
     const staticGateway = this.staticGateways.get(path);
     if (staticGateway) {
       return { definition: staticGateway, params: {} };
     }
 
-    // 遍历动态路由
     for (const gateway of this.dynamicGateways) {
       const match = path.match(gateway.pattern);
       if (match) {
-        // 提取路径参数
         const params: Record<string, string> = {};
         for (let i = 0; i < gateway.paramNames.length; i++) {
           params[gateway.paramNames[i]] = match[i + 1] ?? '';

package/tests/auth/auth-decorators.test.ts

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

package/tests/auth/oauth2-service.test.ts

@@ -1,5 +1,4 @@
 import { describe, expect, test, beforeEach } from 'bun:test';
-import 'reflect-metadata';
 
 import { OAuth2Service } from '../../src/auth/oauth2';
 import { JWTUtil } from '../../src/auth/jwt';

package/tests/cache/cache-decorators-extended.test.ts

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

package/tests/cache/cache-decorators.test.ts

@@ -1,4 +1,3 @@
-import 'reflect-metadata';
 import { describe, expect, test, beforeEach, afterEach } from 'bun:test';
 import { Application } from '../../src/core/application';
 import { Controller } from '../../src/controller/controller';

package/tests/cache/cache-interceptors.test.ts

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

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

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

package/tests/cache/cache-service-proxy.test.ts

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

package/tests/client/client-generator.test.ts

@@ -0,0 +1,142 @@
+import 'reflect-metadata';
+import { describe, expect, test, afterEach } from 'bun:test';
+import { ClientGenerator } from '../../src/client/generator';
+import { createClient } from '../../src/client/runtime';
+import { Application } from '../../src/core/application';
+import { Controller } from '../../src/controller';
+import { GET, POST } from '../../src/router/decorators';
+import { Param, Body } from '../../src/controller';
+
+@Controller('/api/users')
+class UserController {
+  @GET('/')
+  public listUsers(): object {
+    return [{ id: 1, name: 'Alice' }];
+  }
+
+  @GET('/:id')
+  public getUser(@Param('id') id: string): object {
+    return { id, name: 'Alice' };
+  }
+
+  @POST('/')
+  public createUser(@Body() body: unknown): object {
+    return { ...(body as object), id: '99' };
+  }
+}
+
+@Controller('/api/posts')
+class PostController {
+  @GET('/')
+  public listPosts(): object {
+    return [{ id: 1, title: 'Hello' }];
+  }
+}
+
+describe('ClientGenerator', () => {
+  let app: Application | undefined;
+
+  afterEach(async () => {
+    if (app) {
+      await app.stop();
+      app = undefined;
+    }
+  });
+
+  test('should generate route manifest from registered controllers', () => {
+    app = new Application({ enableSignalHandlers: false });
+    app.registerController(UserController);
+    app.registerController(PostController);
+
+    const manifest = ClientGenerator.generate();
+
+    expect(manifest.routes.length).toBeGreaterThanOrEqual(4);
+
+    const userList = manifest.routes.find(
+      (r) => r.controllerName === 'UserController' && r.methodName === 'listUsers',
+    );
+    expect(userList).toBeDefined();
+    expect(userList!.method).toBe('GET');
+    expect(userList!.path).toMatch(/^\/api\/users\/?$/);
+
+    const userGet = manifest.routes.find(
+      (r) => r.controllerName === 'UserController' && r.methodName === 'getUser',
+    );
+    expect(userGet).toBeDefined();
+    expect(userGet!.path).toBe('/api/users/:id');
+
+    const userCreate = manifest.routes.find(
+      (r) => r.controllerName === 'UserController' && r.methodName === 'createUser',
+    );
+    expect(userCreate).toBeDefined();
+    expect(userCreate!.method).toBe('POST');
+  });
+
+  test('should generate valid JSON', () => {
+    app = new Application({ enableSignalHandlers: false });
+    app.registerController(UserController);
+
+    const json = ClientGenerator.generateJSON();
+    const parsed = JSON.parse(json);
+    expect(parsed.routes).toBeArray();
+  });
+});
+
+describe('createClient', () => {
+  let app: Application | undefined;
+
+  afterEach(async () => {
+    if (app) {
+      await app.stop();
+      app = undefined;
+    }
+  });
+
+  test('should create client from manifest and make requests', async () => {
+    app = new Application({ enableSignalHandlers: false });
+    app.registerController(UserController);
+    app.registerController(PostController);
+    await app.listen(0);
+
+    const port = app.getServer()!.getPort();
+    const manifest = ClientGenerator.generate();
+
+    const client = createClient(manifest, {
+      baseUrl: `http://localhost:${port}`,
+    });
+
+    expect(client.user).toBeDefined();
+    expect(client.post).toBeDefined();
+
+    const users = await client.user.listUsers();
+    expect(users).toEqual([{ id: 1, name: 'Alice' }]);
+
+    const user = await client.user.getUser({ params: { id: '42' } });
+    expect(user).toEqual({ id: '42', name: 'Alice' });
+
+    const created = await client.user.createUser({
+      body: { name: 'Bob' },
+    });
+    expect(created).toEqual({ name: 'Bob', id: '99' });
+
+    const posts = await client.post.listPosts();
+    expect(posts).toEqual([{ id: 1, title: 'Hello' }]);
+  });
+
+  test('should support custom headers', async () => {
+    app = new Application({ enableSignalHandlers: false });
+    app.registerController(UserController);
+    await app.listen(0);
+
+    const port = app.getServer()!.getPort();
+    const manifest = ClientGenerator.generate();
+
+    const client = createClient(manifest, {
+      baseUrl: `http://localhost:${port}`,
+      headers: { 'X-Custom': 'test' },
+    });
+
+    const users = await client.user.listUsers();
+    expect(users).toBeDefined();
+  });
+});

package/tests/config/config-center-integration.test.ts

@@ -1,5 +1,4 @@
 import { describe, expect, test, beforeEach, afterEach } from 'bun:test';
-import 'reflect-metadata';
 
 import { MODULE_METADATA_KEY } from '../../src/di/module';
 import {

package/tests/config/config-module-extended.test.ts

@@ -1,5 +1,4 @@
 import { describe, expect, test, beforeEach, afterEach } from 'bun:test';
-import 'reflect-metadata';
 
 import { ConfigModule } from '../../src/config/config-module';
 import { ConfigService } from '../../src/config/service';

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

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

package/tests/controller/controller.test.ts

@@ -1,4 +1,3 @@
-import 'reflect-metadata';
 import { describe, expect, test, beforeEach, afterEach } from 'bun:test';
 import { Application } from '../../src/core/application';
 import { Controller, ControllerRegistry } from '../../src/controller/controller';

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

@@ -1,5 +1,4 @@
 import { describe, expect, test, beforeEach } from 'bun:test';
-import 'reflect-metadata';
 
 import { ParamBinder } from '../../src/controller/param-binder';
 import {

package/tests/controller/path-combination.test.ts

@@ -1,4 +1,3 @@
-import 'reflect-metadata';
 import { describe, expect, test, beforeEach, afterEach } from 'bun:test';
 import { Application } from '../../src/core/application';
 import { Controller, ControllerRegistry } from '../../src/controller/controller';

package/tests/core/application.test.ts

@@ -53,5 +53,39 @@ describe('Application', () => {
     const data = await response.json();
     expect(data.error).toBe('Not Found');
   });
+
+  test('should accept reusePort option', async () => {
+    const port = getTestPort();
+    app = new Application({ port, reusePort: true });
+    await app.listen();
+
+    const server = app.getServer();
+    expect(server).toBeDefined();
+    expect(server?.isRunning()).toBe(true);
+
+    const response = await fetch(`http://localhost:${port}/api/ping`);
+    expect(response.status).toBe(404);
+  });
+
+  test('should allow two servers on same port with reusePort (Linux only)', async () => {
+    if (process.platform !== 'linux') {
+      console.log('Skipping reusePort dual-bind test: only works on Linux');
+      return;
+    }
+
+    const port = getTestPort();
+    app = new Application({ port, reusePort: true });
+    await app.listen();
+
+    const app2 = new Application({ port, reusePort: true });
+    await app2.listen();
+
+    try {
+      const response = await fetch(`http://localhost:${port}/api/test`);
+      expect(response.status).toBe(404);
+    } finally {
+      await app2.stop();
+    }
+  });
 });