@dangao/bun-server 1.0.3 → 1.1.2

package/src/interceptor/interceptor-registry.ts

@@ -0,0 +1,132 @@
+import type { Interceptor, InterceptorMetadata } from './types';
+import { INTERCEPTOR_REGISTRY_TOKEN } from './types';
+
+/**
+ * 拦截器注册表
+ * 管理所有注册的拦截器，支持按优先级排序
+ */
+export class InterceptorRegistry {
+  /**
+   * 拦截器存储
+   * key: 元数据键（Symbol）
+   * value: 拦截器元数据列表
+   */
+  private readonly interceptors = new Map<symbol, InterceptorMetadata[]>();
+
+  /**
+   * 注册拦截器
+   * @param metadataKey - 元数据键（用于匹配装饰器）
+   * @param interceptor - 拦截器实例
+   * @param priority - 优先级（数字越小优先级越高，默认 100）
+   */
+  public register(
+    metadataKey: symbol,
+    interceptor: Interceptor,
+    priority: number = 100,
+  ): void {
+    if (!this.interceptors.has(metadataKey)) {
+      this.interceptors.set(metadataKey, []);
+    }
+
+    const metadataList = this.interceptors.get(metadataKey)!;
+    
+    // 检查是否已注册相同的拦截器
+    const exists = metadataList.some(
+      (meta) => meta.interceptor === interceptor,
+    );
+    
+    if (!exists) {
+      metadataList.push({
+        metadataKey,
+        interceptor,
+        priority,
+      });
+      
+      // 按优先级排序（数字越小优先级越高）
+      metadataList.sort((a, b) => a.priority - b.priority);
+    }
+  }
+
+  /**
+   * 获取拦截器元数据列表（按优先级排序）
+   * @param metadataKey - 元数据键
+   * @returns 拦截器元数据列表
+   */
+  public getInterceptorMetadata(metadataKey: symbol): InterceptorMetadata[] {
+    const metadataList = this.interceptors.get(metadataKey);
+    if (!metadataList || metadataList.length === 0) {
+      return [];
+    }
+    
+    // 返回已排序的拦截器元数据列表（包括优先级信息）
+    return [...metadataList];
+  }
+
+  /**
+   * 获取拦截器列表（按优先级排序）
+   * @param metadataKey - 元数据键
+   * @returns 拦截器列表
+   */
+  public getInterceptors(metadataKey: symbol): Interceptor[] {
+    const metadataList = this.interceptors.get(metadataKey);
+    if (!metadataList || metadataList.length === 0) {
+      return [];
+    }
+    
+    // 返回已排序的拦截器列表
+    return metadataList.map((meta) => meta.interceptor);
+  }
+
+  /**
+   * 检查是否有拦截器
+   * @param metadataKey - 元数据键
+   * @returns 是否有拦截器
+   */
+  public hasInterceptor(metadataKey: symbol): boolean {
+    const metadataList = this.interceptors.get(metadataKey);
+    return metadataList !== undefined && metadataList.length > 0;
+  }
+
+  /**
+   * 获取所有已注册的元数据键
+   * @returns 元数据键迭代器
+   */
+  public getAllMetadataKeys(): IterableIterator<symbol> {
+    return this.interceptors.keys();
+  }
+
+  /**
+   * 清除所有拦截器
+   */
+  public clear(): void {
+    this.interceptors.clear();
+  }
+
+  /**
+   * 移除指定元数据键的所有拦截器
+   * @param metadataKey - 元数据键
+   */
+  public remove(metadataKey: symbol): void {
+    this.interceptors.delete(metadataKey);
+  }
+
+  /**
+   * 获取拦截器数量
+   * @param metadataKey - 元数据键（可选）
+   * @returns 拦截器数量
+   */
+  public count(metadataKey?: symbol): number {
+    if (metadataKey) {
+      const metadataList = this.interceptors.get(metadataKey);
+      return metadataList ? metadataList.length : 0;
+    }
+    
+    // 返回所有拦截器的总数
+    let total = 0;
+    for (const metadataList of this.interceptors.values()) {
+      total += metadataList.length;
+    }
+    return total;
+  }
+}
+

package/src/interceptor/metadata.ts

@@ -0,0 +1,40 @@
+import 'reflect-metadata';
+import type { InterceptorRegistry } from './interceptor-registry';
+import type { Interceptor, InterceptorMetadata } from './types';
+
+/**
+ * 扫描方法上的所有拦截器元数据
+ * @param target - 目标对象（控制器实例的原型）
+ * @param propertyKey - 方法名
+ * @param registry - 拦截器注册表
+ * @returns 匹配的拦截器列表（按优先级排序）
+ */
+export function scanInterceptorMetadata(
+  target: object,
+  propertyKey: string | symbol,
+  registry: InterceptorRegistry,
+): Interceptor[] {
+  const interceptorMetadataList: InterceptorMetadata[] = [];
+
+  // 扫描所有已注册的元数据键
+  for (const metadataKey of registry.getAllMetadataKeys()) {
+    // 检查方法上是否有该元数据
+    const metadata = Reflect.getMetadata(metadataKey, target, propertyKey);
+    
+    if (metadata !== undefined && metadata !== null) {
+      // 找到匹配的元数据，获取对应的拦截器元数据
+      // 使用公共方法获取完整的元数据（包括优先级）
+      const metadataList = registry.getInterceptorMetadata(metadataKey);
+      if (metadataList.length > 0) {
+        interceptorMetadataList.push(...metadataList);
+      }
+    }
+  }
+
+  // 按优先级排序（数字越小优先级越高）
+  interceptorMetadataList.sort((a, b) => a.priority - b.priority);
+
+  // 返回排序后的拦截器列表
+  return interceptorMetadataList.map((meta) => meta.interceptor);
+}
+

package/src/interceptor/types.ts

@@ -0,0 +1,52 @@
+import type { Container } from '../di/container';
+import type { Context } from '../core/context';
+
+/**
+ * 拦截器接口
+ * 定义拦截器的核心执行方法
+ */
+export interface Interceptor {
+  /**
+   * 执行拦截器逻辑
+   * @param target - 目标对象（控制器实例的原型）
+   * @param propertyKey - 方法名
+   * @param originalMethod - 原始方法
+   * @param args - 方法参数
+   * @param container - DI 容器
+   * @param context - 请求上下文（可选）
+   * @returns 方法执行结果
+   */
+  execute<T>(
+    target: unknown,
+    propertyKey: string | symbol,
+    originalMethod: (...args: unknown[]) => T | Promise<T>,
+    args: unknown[],
+    container: Container,
+    context?: Context,
+  ): Promise<T>;
+}
+
+/**
+ * 拦截器元数据
+ * 用于存储拦截器的注册信息
+ */
+export interface InterceptorMetadata {
+  /**
+   * 元数据键（用于匹配装饰器）
+   */
+  metadataKey: symbol;
+  /**
+   * 拦截器实例
+   */
+  interceptor: Interceptor;
+  /**
+   * 优先级（数字越小优先级越高，默认 100）
+   */
+  priority: number;
+}
+
+/**
+ * 拦截器注册表 Token
+ */
+export const INTERCEPTOR_REGISTRY_TOKEN = Symbol('@dangao/bun-server:interceptor-registry');
+

package/src/middleware/decorators.ts

@@ -1,4 +1,5 @@
 import 'reflect-metadata';
+import type { Constructor } from '../core/types';
 import type { Middleware } from './middleware';
 import { createRateLimitMiddleware, type RateLimitOptions } from './builtin/rate-limit';
 
@@ -68,7 +69,7 @@ export function RateLimit(options: RateLimitOptions): MethodDecorator {
  * @param constructor - 控制器构造函数
  * @returns 中间件列表
  */
-export function getClassMiddlewares(constructor: new (...args: unknown[]) => unknown): Middleware[] {
+export function getClassMiddlewares(constructor: Constructor<unknown>): Middleware[] {
   return (
     (Reflect.getMetadata(CLASS_MIDDLEWARE_METADATA_KEY, constructor) as Middleware[]) || []
   );

package/src/router/decorators.ts

@@ -30,53 +30,55 @@ export interface RouteMetadata {
  */
 function createRouteDecorator(method: HttpMethod, path: string) {
   return function (target: any, propertyKey: string | symbol, descriptor: PropertyDescriptor) {
-    // 检查是否是控制器方法（有 Controller 装饰器）
-    const controllerMetadata = Reflect.getMetadata(CONTROLLER_METADATA_KEY, target.constructor);
+    // 注意：装饰器应用顺序问题
+    // 方法装饰器（@GET）在类装饰器（@Controller）之前应用
+    // 因此这里无法立即检查 @Controller，需要在 ControllerRegistry.register 时验证
     
-    if (controllerMetadata) {
-      // 控制器方法：只保存元数据，不直接注册路由
-      // 路由注册由 ControllerRegistry 处理
-      const existingRoutes: RouteMetadata[] = Reflect.getMetadata(ROUTE_METADATA_KEY, target) || [];
-      
-      // 获取方法名：优先使用 propertyKey，如果不可用则从函数名获取
-      let propertyKeyStr: string;
-      if (propertyKey && propertyKey !== '') {
-        propertyKeyStr = typeof propertyKey === 'string' ? propertyKey : String(propertyKey);
-      } else {
-        // 从函数名获取（可能不可靠，但作为后备方案）
-        propertyKeyStr = descriptor.value.name || '';
+    // 尝试检查类是否已经有 @Controller 装饰器（如果装饰器已经应用）
+    // 这可以捕获一些早期错误，但不是 100% 可靠（因为装饰器应用顺序）
+    const constructor = target.constructor;
+    if (constructor && typeof constructor === 'function') {
+      const hasController = Reflect.getMetadata(CONTROLLER_METADATA_KEY, constructor);
+      if (hasController === undefined) {
+        // 类装饰器可能还没有应用，这是正常的
+        // 如果类装饰器已经应用但没有 @Controller，这里会捕获到
+        // 但这种情况很少见，因为通常 @Controller 会在 @GET 之前应用
       }
-      
-      // 如果仍然没有方法名，尝试从原型中查找
-      if (!propertyKeyStr) {
-        const propertyNames = Object.getOwnPropertyNames(target);
-        for (const key of propertyNames) {
-          const targetDescriptor = Object.getOwnPropertyDescriptor(target, key);
-          if (targetDescriptor?.value === descriptor.value) {
-            propertyKeyStr = key;
-            break;
-          }
+    }
+    
+    // 保存元数据
+    // 注意：即使类没有 @Controller，元数据也会被保存
+    // 但 ControllerRegistry.register 会验证并抛出错误，所以不会造成问题
+    const existingRoutes: RouteMetadata[] = Reflect.getMetadata(ROUTE_METADATA_KEY, target) || [];
+    
+    // 获取方法名：优先使用 propertyKey，如果不可用则从函数名获取
+    let propertyKeyStr: string;
+    if (propertyKey && propertyKey !== '') {
+      propertyKeyStr = typeof propertyKey === 'string' ? propertyKey : String(propertyKey);
+    } else {
+      // 从函数名获取（可能不可靠，但作为后备方案）
+      propertyKeyStr = descriptor.value.name || '';
+    }
+    
+    // 如果仍然没有方法名，尝试从原型中查找
+    if (!propertyKeyStr) {
+      const propertyNames = Object.getOwnPropertyNames(target);
+      for (const key of propertyNames) {
+        const targetDescriptor = Object.getOwnPropertyDescriptor(target, key);
+        if (targetDescriptor?.value === descriptor.value) {
+          propertyKeyStr = key;
+          break;
         }
       }
-      
-      existingRoutes.push({ 
-        method, 
-        path, 
-        handler: descriptor.value as RouteHandler,
-        propertyKey: propertyKeyStr || undefined,
-      });
-      Reflect.defineMetadata(ROUTE_METADATA_KEY, existingRoutes, target);
-    } else {
-      // 普通函数：直接注册路由
-      const handler = descriptor.value as RouteHandler;
-      const registry = RouteRegistry.getInstance();
-      registry.register(method, path, handler);
-
-      // 保存元数据（用于兼容性）
-      const existingRoutes: RouteMetadata[] = Reflect.getMetadata(ROUTE_METADATA_KEY, target) || [];
-      existingRoutes.push({ method, path, handler });
-      Reflect.defineMetadata(ROUTE_METADATA_KEY, existingRoutes, target);
     }
+    
+    existingRoutes.push({ 
+      method, 
+      path, 
+      handler: descriptor.value as RouteHandler,
+      propertyKey: propertyKeyStr || undefined,
+    });
+    Reflect.defineMetadata(ROUTE_METADATA_KEY, existingRoutes, target);
   };
 }
 
@@ -119,4 +121,3 @@ export function DELETE(path: string) {
 export function PATCH(path: string) {
   return createRouteDecorator('PATCH', path);
 }
-

package/src/router/registry.ts

@@ -1,4 +1,5 @@
 import { Router } from './router';
+import type { Constructor } from '../core/types';
 import type { HttpMethod, RouteHandler } from './types';
 import type { Middleware } from '../middleware';
 
@@ -39,7 +40,7 @@ export class RouteRegistry {
     path: string,
     handler: RouteHandler,
     middlewares: Middleware[] = [],
-    controllerClass?: new (...args: unknown[]) => unknown,
+    controllerClass?: Constructor<unknown>,
     methodName?: string,
   ): void {
     this.router.register(method, path, handler, middlewares, controllerClass, methodName);

package/src/router/route.ts

@@ -1,4 +1,5 @@
 import type { Context } from '../core/context';
+import type { Constructor } from '../core/types';
 import type { HttpMethod, RouteHandler, RouteMatch } from './types';
 import { MiddlewarePipeline } from '../middleware/pipeline';
 import type { Middleware } from '../middleware';
@@ -26,7 +27,7 @@ export class Route {
   /**
    * 控制器类（可选，用于控制器路由）
    */
-  public readonly controllerClass?: new (...args: unknown[]) => unknown;
+  public readonly controllerClass?: Constructor<unknown>;
 
   /**
    * 方法名（可选，用于控制器路由）
@@ -52,7 +53,7 @@ export class Route {
     path: string,
     handler: RouteHandler,
     middlewares: Middleware[] = [],
-    controllerClass?: new (...args: unknown[]) => unknown,
+    controllerClass?: Constructor<unknown>,
     methodName?: string,
   ) {
     this.method = method;

package/src/router/router.ts

@@ -1,4 +1,5 @@
 import type { Context } from '../core/context';
+import type { Constructor } from '../core/types';
 import { Route } from './route';
 import type { HttpMethod, RouteHandler, RouteMatch } from './types';
 import type { Middleware } from '../middleware';
@@ -45,7 +46,7 @@ export class Router {
     path: string,
     handler: RouteHandler,
     middlewares: Middleware[] = [],
-    controllerClass?: new (...args: unknown[]) => unknown,
+    controllerClass?: Constructor<unknown>,
     methodName?: string,
   ): void {
     // 规范化路径

package/src/websocket/decorators.ts

@@ -36,8 +36,10 @@ export const OnOpen = createHandlerDecorator('open');
 export const OnMessage = createHandlerDecorator('message');
 export const OnClose = createHandlerDecorator('close');
 
+import type { Constructor } from '../core/types';
+
 export function getGatewayMetadata(
-  constructor: new (...args: unknown[]) => unknown,
+  constructor: Constructor<unknown>,
 ): WebSocketGatewayMetadata | undefined {
   return Reflect.getMetadata(GATEWAY_METADATA_KEY, constructor);
 }

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

@@ -0,0 +1,207 @@
+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';
+import { GET, POST } from '../../src/router/decorators';
+import { Param } from '../../src/controller/decorators';
+import { RouteRegistry } from '../../src/router/registry';
+import { getTestPort } from '../utils/test-port';
+
+describe('Controller Path Combination', () => {
+  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();
+  });
+
+  test('should correctly combine base path with method path starting with /', async () => {
+    @Controller('/api/products')
+    class ProductController {
+      @GET('/')
+      public listProducts() {
+        return { products: ['product1', 'product2'] };
+      }
+
+      @GET('/:id')
+      public getProduct(@Param('id') id: string) {
+        return { id, name: `Product ${id}` };
+      }
+    }
+
+    app.registerController(ProductController);
+    await app.listen();
+
+    // 应该访问 /api/products，而不是 /
+    const response = await fetch(`http://localhost:${port}/api/products`);
+    expect(response.status).toBe(200);
+    const data = await response.json();
+    expect(data.products).toBeDefined();
+
+    // 访问 / 应该返回 404，而不是访问到 listProducts
+    const rootResponse = await fetch(`http://localhost:${port}/`);
+    expect(rootResponse.status).toBe(404);
+  });
+
+  test('should correctly combine base path with empty method path', async () => {
+    @Controller('/api/users')
+    class UserController {
+      @GET('')
+      public listUsers() {
+        return { users: ['user1', 'user2'] };
+      }
+    }
+
+    app.registerController(UserController);
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/api/users`);
+    expect(response.status).toBe(200);
+    const data = await response.json();
+    expect(data.users).toBeDefined();
+
+    // 访问 / 应该返回 404
+    const rootResponse = await fetch(`http://localhost:${port}/`);
+    expect(rootResponse.status).toBe(404);
+  });
+
+  test('should correctly combine base path with method path without leading /', async () => {
+    @Controller('/api/orders')
+    class OrderController {
+      @GET('list')
+      public listOrders() {
+        return { orders: ['order1', 'order2'] };
+      }
+    }
+
+    app.registerController(OrderController);
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/api/orders/list`);
+    expect(response.status).toBe(200);
+    const data = await response.json();
+    expect(data.orders).toBeDefined();
+
+    // 访问 /api/orders 应该返回 404
+    const baseResponse = await fetch(`http://localhost:${port}/api/orders`);
+    expect(baseResponse.status).toBe(404);
+  });
+
+  test('should handle root controller with method path /', async () => {
+    @Controller('')
+    class RootController {
+      @GET('/')
+      public root() {
+        return { message: 'root' };
+      }
+    }
+
+    app.registerController(RootController);
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/`);
+    expect(response.status).toBe(200);
+    const data = await response.json();
+    expect(data.message).toBe('root');
+  });
+
+  test('should handle root controller with empty method path', async () => {
+    @Controller('/')
+    class RootController {
+      @GET('')
+      public root() {
+        return { message: 'root' };
+      }
+    }
+
+    app.registerController(RootController);
+    await app.listen();
+
+    const response = await fetch(`http://localhost:${port}/`);
+    expect(response.status).toBe(200);
+    const data = await response.json();
+    expect(data.message).toBe('root');
+  });
+
+  test('should not allow / to match when controller has base path', async () => {
+    @Controller('/api/products')
+    class ProductController {
+      @GET('/')
+      public listProducts() {
+        return { products: ['product1'] };
+      }
+    }
+
+    @Controller('/')
+    class RootController {
+      @GET('/')
+      public root() {
+        return { message: 'root' };
+      }
+    }
+
+    app.registerController(ProductController);
+    app.registerController(RootController);
+    await app.listen();
+
+    // /api/products 应该访问 ProductController
+    const productsResponse = await fetch(`http://localhost:${port}/api/products`);
+    expect(productsResponse.status).toBe(200);
+    const productsData = await productsResponse.json();
+    expect(productsData.products).toBeDefined();
+
+    // / 应该访问 RootController
+    const rootResponse = await fetch(`http://localhost:${port}/`);
+    expect(rootResponse.status).toBe(200);
+    const rootData = await rootResponse.json();
+    expect(rootData.message).toBe('root');
+  });
+
+  test('should handle multiple controllers with different base paths', async () => {
+    @Controller('/api/products')
+    class ProductController {
+      @GET('/')
+      public listProducts() {
+        return { source: 'products' };
+      }
+    }
+
+    @Controller('/api/users')
+    class UserController {
+      @GET('/')
+      public listUsers() {
+        return { source: 'users' };
+      }
+    }
+
+    app.registerController(ProductController);
+    app.registerController(UserController);
+    await app.listen();
+
+    // 访问 /api/products 应该返回 products
+    const productsResponse = await fetch(`http://localhost:${port}/api/products`);
+    expect(productsResponse.status).toBe(200);
+    const productsData = await productsResponse.json();
+    expect(productsData.source).toBe('products');
+
+    // 访问 /api/users 应该返回 users
+    const usersResponse = await fetch(`http://localhost:${port}/api/users`);
+    expect(usersResponse.status).toBe(200);
+    const usersData = await usersResponse.json();
+    expect(usersData.source).toBe('users');
+
+    // 访问 / 应该返回 404
+    const rootResponse = await fetch(`http://localhost:${port}/`);
+    expect(rootResponse.status).toBe(404);
+  });
+});
+