@dangao/bun-server 1.6.0 → 1.7.1

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

@@ -203,5 +203,358 @@ describe('Controller Path Combination', () => {
     const rootResponse = await fetch(`http://localhost:${port}/`);
     expect(rootResponse.status).toBe(404);
   });
+
+  test('should correctly combine root controller "/" with method path "/health"', async () => {
+    // 这是 metrics-rate-limit-app.ts 示例中的场景
+    // @Controller('/') + @GET('/health') 应该映射到 /health，而不是 //health
+    @Controller('/')
+    class HealthController {
+      @GET('/health')
+      public health() {
+        return { status: 'ok' };
+      }
+
+      @GET('/')
+      public index() {
+        return { message: 'index' };
+      }
+    }
+
+    app.registerController(HealthController);
+    await app.listen();
+
+    // /health 应该正常访问（修复前会得到 404，因为注册的路径是 //health）
+    const healthResponse = await fetch(`http://localhost:${port}/health`);
+    expect(healthResponse.status).toBe(200);
+    const healthData = await healthResponse.json();
+    expect(healthData.status).toBe('ok');
+
+    // / 应该正常访问
+    const rootResponse = await fetch(`http://localhost:${port}/`);
+    expect(rootResponse.status).toBe(200);
+    const rootData = await rootResponse.json();
+    expect(rootData.message).toBe('index');
+
+    // //health 不应该被访问到（或者应该重定向/返回 404）
+    // 注：大多数 HTTP 服务器会规范化 //health 为 /health，所以这里可能返回 200
+  });
+
+  test('should correctly combine root controller "/" with multiple method paths', async () => {
+    @Controller('/')
+    class RootController {
+      @GET('/api/status')
+      public status() {
+        return { status: 'running' };
+      }
+
+      @GET('/api/info')
+      public info() {
+        return { info: 'test' };
+      }
+
+      @POST('/api/data')
+      public data() {
+        return { received: true };
+      }
+    }
+
+    app.registerController(RootController);
+    await app.listen();
+
+    // 所有路径都应该正常工作
+    const statusResponse = await fetch(`http://localhost:${port}/api/status`);
+    expect(statusResponse.status).toBe(200);
+    expect((await statusResponse.json()).status).toBe('running');
+
+    const infoResponse = await fetch(`http://localhost:${port}/api/info`);
+    expect(infoResponse.status).toBe(200);
+    expect((await infoResponse.json()).info).toBe('test');
+
+    const dataResponse = await fetch(`http://localhost:${port}/api/data`, {
+      method: 'POST',
+    });
+    expect(dataResponse.status).toBe(200);
+    expect((await dataResponse.json()).received).toBe(true);
+  });
+});
+
+/**
+ * 路径规范化测试
+ * 根据图片中的测试矩阵，验证各种路径组合是否都能正确映射到 /api/base
+ *
+ * 配置组合          | 拼接结果       | 规范化后路径  | 是否命中 /api/base
+ * [/ + /api/base]   | //api/base    | /api/base    | 是
+ * [// + /api/base]  | ///api/base   | /api/base    | 是
+ * [/api + /base]    | /api/base     | /api/base    | 是
+ * [/api/ + base]    | /api/base     | /api/base    | 是
+ * [/api/base + ""]  | /api/base     | /api/base    | 是
+ */
+describe('Controller Path Normalization', () => {
+  let app: Application;
+  let port: number;
+
+  beforeEach(() => {
+    port = getTestPort();
+    app = new Application({ port });
+  });
+
+  afterEach(async () => {
+    if (app) {
+      await app.stop();
+    }
+    RouteRegistry.getInstance().clear();
+    ControllerRegistry.getInstance().clear();
+  });
+
+  // 场景 1: [/ + /api/base] -> //api/base -> /api/base
+  test('should normalize "/" + "/api/base" to "/api/base"', async () => {
+    @Controller('/')
+    class TestController {
+      @GET('/api/base')
+      public handler() {
+        return { success: true, scenario: 1 };
+      }
+    }
+
+    app.registerController(TestController);
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/api/base`);
+    expect(response.status).toBe(200);
+    const data = await response.json();
+    expect(data.success).toBe(true);
+    expect(data.scenario).toBe(1);
+  });
+
+  // 场景 2: [// + /api/base] -> ///api/base -> /api/base
+  test('should normalize "//" + "/api/base" to "/api/base"', async () => {
+    @Controller('//')
+    class TestController {
+      @GET('/api/base')
+      public handler() {
+        return { success: true, scenario: 2 };
+      }
+    }
+
+    app.registerController(TestController);
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/api/base`);
+    expect(response.status).toBe(200);
+    const data = await response.json();
+    expect(data.success).toBe(true);
+    expect(data.scenario).toBe(2);
+  });
+
+  // 场景 3: [/api + /base] -> /api/base -> /api/base
+  test('should normalize "/api" + "/base" to "/api/base"', async () => {
+    @Controller('/api')
+    class TestController {
+      @GET('/base')
+      public handler() {
+        return { success: true, scenario: 3 };
+      }
+    }
+
+    app.registerController(TestController);
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/api/base`);
+    expect(response.status).toBe(200);
+    const data = await response.json();
+    expect(data.success).toBe(true);
+    expect(data.scenario).toBe(3);
+  });
+
+  // 场景 4: [/api/ + base] -> /api/base -> /api/base
+  test('should normalize "/api/" + "base" to "/api/base"', async () => {
+    @Controller('/api/')
+    class TestController {
+      @GET('base')
+      public handler() {
+        return { success: true, scenario: 4 };
+      }
+    }
+
+    app.registerController(TestController);
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/api/base`);
+    expect(response.status).toBe(200);
+    const data = await response.json();
+    expect(data.success).toBe(true);
+    expect(data.scenario).toBe(4);
+  });
+
+  // 场景 5: [/api/base + ""] -> /api/base -> /api/base
+  test('should normalize "/api/base" + "" to "/api/base"', async () => {
+    @Controller('/api/base')
+    class TestController {
+      @GET('')
+      public handler() {
+        return { success: true, scenario: 5 };
+      }
+    }
+
+    app.registerController(TestController);
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/api/base`);
+    expect(response.status).toBe(200);
+    const data = await response.json();
+    expect(data.success).toBe(true);
+    expect(data.scenario).toBe(5);
+  });
+
+  // 额外场景: [/api/base + /] -> /api/base/ 或 /api/base
+  test('should normalize "/api/base" + "/" to "/api/base"', async () => {
+    @Controller('/api/base')
+    class TestController {
+      @GET('/')
+      public handler() {
+        return { success: true, scenario: 6 };
+      }
+    }
+
+    app.registerController(TestController);
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/api/base`);
+    expect(response.status).toBe(200);
+    const data = await response.json();
+    expect(data.success).toBe(true);
+    expect(data.scenario).toBe(6);
+  });
+
+  // 场景: [/// + /api/base] -> /api/base (多个前导斜杠)
+  test('should normalize "///" + "/api/base" to "/api/base"', async () => {
+    @Controller('///')
+    class TestController {
+      @GET('/api/base')
+      public handler() {
+        return { success: true, scenario: 'triple-slash' };
+      }
+    }
+
+    app.registerController(TestController);
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/api/base`);
+    expect(response.status).toBe(200);
+    const data = await response.json();
+    expect(data.success).toBe(true);
+  });
+
+  // 场景: [/api// + //base] -> /api/base (多个连续斜杠)
+  test('should normalize "/api//" + "//base" to "/api/base"', async () => {
+    @Controller('/api//')
+    class TestController {
+      @GET('//base')
+      public handler() {
+        return { success: true, scenario: 'double-slashes' };
+      }
+    }
+
+    app.registerController(TestController);
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/api/base`);
+    expect(response.status).toBe(200);
+    const data = await response.json();
+    expect(data.success).toBe(true);
+  });
+
+  // 场景: ["" + /api/base] -> /api/base (空基础路径)
+  test('should normalize "" + "/api/base" to "/api/base"', async () => {
+    @Controller('')
+    class TestController {
+      @GET('/api/base')
+      public handler() {
+        return { success: true, scenario: 'empty-base' };
+      }
+    }
+
+    app.registerController(TestController);
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/api/base`);
+    expect(response.status).toBe(200);
+    const data = await response.json();
+    expect(data.success).toBe(true);
+  });
+
+  // 测试所有场景在同一应用中同时工作
+  test('should handle all path normalization scenarios simultaneously', async () => {
+    @Controller('/')
+    class RootController {
+      @GET('/health')
+      public health() {
+        return { endpoint: 'health' };
+      }
+    }
+
+    @Controller('/api')
+    class ApiController {
+      @GET('/users')
+      public users() {
+        return { endpoint: 'users' };
+      }
+
+      @GET('products')
+      public products() {
+        return { endpoint: 'products' };
+      }
+    }
+
+    @Controller('/api/')
+    class ApiSlashController {
+      @GET('orders')
+      public orders() {
+        return { endpoint: 'orders' };
+      }
+    }
+
+    @Controller('/v1/api')
+    class V1Controller {
+      @GET('')
+      public root() {
+        return { endpoint: 'v1-root' };
+      }
+
+      @GET('/')
+      public index() {
+        return { endpoint: 'v1-index' };
+      }
+    }
+
+    app.registerController(RootController);
+    app.registerController(ApiController);
+    app.registerController(ApiSlashController);
+    app.registerController(V1Controller);
+    await app.listen();
+
+    // 验证所有端点
+    const healthRes = await fetch(`http://localhost:${port}/health`);
+    expect(healthRes.status).toBe(200);
+    expect((await healthRes.json()).endpoint).toBe('health');
+
+    const usersRes = await fetch(`http://localhost:${port}/api/users`);
+    expect(usersRes.status).toBe(200);
+    expect((await usersRes.json()).endpoint).toBe('users');
+
+    const productsRes = await fetch(`http://localhost:${port}/api/products`);
+    expect(productsRes.status).toBe(200);
+    expect((await productsRes.json()).endpoint).toBe('products');
+
+    const ordersRes = await fetch(`http://localhost:${port}/api/orders`);
+    expect(ordersRes.status).toBe(200);
+    expect((await ordersRes.json()).endpoint).toBe('orders');
+
+    const v1Res = await fetch(`http://localhost:${port}/v1/api`);
+    expect(v1Res.status).toBe(200);
+    // v1-root 或 v1-index，取决于哪个先注册
+    const v1Data = await v1Res.json();
+    expect(['v1-root', 'v1-index']).toContain(v1Data.endpoint);
+  });
 });
 

package/tests/websocket/gateway.test.ts

@@ -5,7 +5,7 @@ import { WebSocketGateway, OnOpen, OnMessage, OnClose } from '../../src/websocke
 import { WebSocketGatewayRegistry } from '../../src/websocket/registry';
 import { ControllerRegistry } from '../../src/controller/controller';
 import { Application } from '../../src/core/application';
-import { Query, Context } from '../../src/controller/decorators';
+import { Query, Context, Param } from '../../src/controller/decorators';
 import { getTestPort } from '../utils/test-port';
 import type { WebSocketConnectionData } from '../../src/websocket/registry';
 import type { Context as RequestContext } from '../../src/core/context';
@@ -1087,6 +1087,212 @@ describe('WebSocket Gateway Integration', () => {
 
     ws.close();
   });
+
+  test('should support dynamic path matching with path parameters', async () => {
+    @WebSocketGateway('/ws/rooms/:roomId')
+    class DynamicPathGateway {
+      public static connected = false;
+      public static roomIds: string[] = [];
+      public static params: Record<string, string>[] = [];
+
+      @OnOpen
+      public handleOpen(ws: ServerWebSocket<WebSocketConnectionData>): void {
+        DynamicPathGateway.connected = true;
+        const roomId = ws.data?.params?.roomId;
+        if (roomId) {
+          DynamicPathGateway.roomIds.push(roomId);
+          DynamicPathGateway.params.push(ws.data.params || {});
+        }
+      }
+
+      @OnMessage
+      public handleMessage(
+        ws: ServerWebSocket<WebSocketConnectionData>,
+        message: string,
+      ): void {
+        const roomId = ws.data?.params?.roomId;
+        if (roomId) {
+          ws.send(`Room ${roomId}: ${message}`);
+        }
+      }
+    }
+
+    app.registerWebSocketGateway(DynamicPathGateway);
+    await app.listen();
+
+    const registry = WebSocketGatewayRegistry.getInstance();
+
+    // 验证动态路径匹配
+    expect(registry.hasGateway('/ws/rooms/123')).toBe(true);
+    expect(registry.hasGateway('/ws/rooms/abc')).toBe(true);
+    expect(registry.hasGateway('/ws/rooms/room-xyz')).toBe(true);
+    // 不匹配的路径
+    expect(registry.hasGateway('/ws/rooms')).toBe(false);
+    expect(registry.hasGateway('/ws/rooms/123/users')).toBe(false);
+
+    // 测试访问动态路径
+    const roomId1 = 'room-123';
+    const ws1 = new WebSocket(`ws://localhost:${port}/ws/rooms/${roomId1}`);
+
+    await new Promise<void>((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error('WebSocket connection timeout'));
+      }, 2000);
+
+      ws1.onopen = () => {
+        clearTimeout(timeout);
+        resolve();
+      };
+
+      ws1.onerror = (error) => {
+        clearTimeout(timeout);
+        reject(error);
+      };
+    });
+
+    await new Promise((resolve) => setTimeout(resolve, 200));
+    expect(DynamicPathGateway.connected).toBe(true);
+    expect(DynamicPathGateway.roomIds).toContain(roomId1);
+    expect(DynamicPathGateway.params[0]?.roomId).toBe(roomId1);
+
+    // 测试另一个房间 ID
+    const roomId2 = 'room-456';
+    const ws2 = new WebSocket(`ws://localhost:${port}/ws/rooms/${roomId2}`);
+
+    await new Promise<void>((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error('WebSocket connection timeout'));
+      }, 2000);
+
+      ws2.onopen = () => {
+        clearTimeout(timeout);
+        resolve();
+      };
+
+      ws2.onerror = (error) => {
+        clearTimeout(timeout);
+        reject(error);
+      };
+    });
+
+    await new Promise((resolve) => setTimeout(resolve, 200));
+    expect(DynamicPathGateway.roomIds).toContain(roomId2);
+    expect(DynamicPathGateway.params.some((p) => p.roomId === roomId2)).toBe(true);
+
+    ws1.close();
+    ws2.close();
+  });
+
+  test('should support multiple path parameters', async () => {
+    @WebSocketGateway('/ws/users/:userId/rooms/:roomId')
+    class MultiParamGateway {
+      public static connections: Array<{
+        userId: string;
+        roomId: string;
+      }> = [];
+
+      @OnOpen
+      public handleOpen(ws: ServerWebSocket<WebSocketConnectionData>): void {
+        const params = ws.data?.params || {};
+        MultiParamGateway.connections.push({
+          userId: params.userId || '',
+          roomId: params.roomId || '',
+        });
+      }
+    }
+
+    app.registerWebSocketGateway(MultiParamGateway);
+    await app.listen();
+
+    const registry = WebSocketGatewayRegistry.getInstance();
+
+    // 验证多参数路径匹配
+    expect(registry.hasGateway('/ws/users/user1/rooms/room1')).toBe(true);
+    expect(registry.hasGateway('/ws/users/user2/rooms/room2')).toBe(true);
+
+    const userId = 'user-123';
+    const roomId = 'room-456';
+    const ws = new WebSocket(
+      `ws://localhost:${port}/ws/users/${userId}/rooms/${roomId}`,
+    );
+
+    await new Promise<void>((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error('WebSocket connection timeout'));
+      }, 2000);
+
+      ws.onopen = () => {
+        clearTimeout(timeout);
+        resolve();
+      };
+
+      ws.onerror = (error) => {
+        clearTimeout(timeout);
+        reject(error);
+      };
+    });
+
+    await new Promise((resolve) => setTimeout(resolve, 200));
+
+    // 验证路径参数被正确提取
+    expect(MultiParamGateway.connections.length).toBeGreaterThan(0);
+    const connection = MultiParamGateway.connections[0];
+    expect(connection.userId).toBe(userId);
+    expect(connection.roomId).toBe(roomId);
+
+    ws.close();
+  });
+
+  test('should support @Param decorator with dynamic path parameters', async () => {
+    @WebSocketGateway('/ws/param-test/:id')
+    class ParamDecoratorGateway {
+      public static receivedIds: string[] = [];
+      public static paramValues: string[] = [];
+
+      @OnMessage
+      public handleMessage(
+        _ws: ServerWebSocket<WebSocketConnectionData>,
+        message: string,
+        @Param('id') id: string,
+      ): void {
+        ParamDecoratorGateway.receivedIds.push(message);
+        ParamDecoratorGateway.paramValues.push(id);
+      }
+    }
+
+    app.registerWebSocketGateway(ParamDecoratorGateway);
+    await app.listen();
+
+    const testId = 'test-123';
+    const ws = new WebSocket(`ws://localhost:${port}/ws/param-test/${testId}`);
+
+    await new Promise<void>((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error('WebSocket connection timeout'));
+      }, 2000);
+
+      ws.onopen = () => {
+        clearTimeout(timeout);
+        resolve();
+      };
+
+      ws.onerror = (error) => {
+        clearTimeout(timeout);
+        reject(error);
+      };
+    });
+
+    await new Promise((resolve) => setTimeout(resolve, 100));
+    ws.send('test-message');
+    await new Promise((resolve) => setTimeout(resolve, 200));
+
+    // 验证消息被接收
+    expect(ParamDecoratorGateway.receivedIds).toContain('test-message');
+    // 验证 @Param 装饰器正确提取了路径参数
+    expect(ParamDecoratorGateway.paramValues).toContain(testId);
+
+    ws.close();
+  });
 });