@dangao/bun-server 1.6.0 → 1.7.1

package/src/di/container.ts

@@ -1,6 +1,8 @@
 import "reflect-metadata";
 import {
   type DependencyMetadata,
+  type InstancePostProcessor,
+  INSTANCE_POST_PROCESSOR_TOKEN,
   Lifecycle,
   type ProviderConfig,
 } from "./types";
@@ -59,6 +61,11 @@ export class Container {
     DependencyPlan
   >();
 
+  /**
+   * 实例后处理器列表
+   */
+  private readonly postProcessors: InstancePostProcessor[] = [];
+
   /**
    * 注册提供者
    * @param token - 提供者标识符（类构造函数或 token）
@@ -112,6 +119,45 @@ export class Container {
     });
   }
 
+  /**
+   * 注册实例后处理器
+   * @param processor - 后处理器实例
+   */
+  public registerPostProcessor(processor: InstancePostProcessor): void {
+    this.postProcessors.push(processor);
+    // 按优先级排序（数字越小优先级越高）
+    this.postProcessors.sort((a, b) => (a.priority ?? 100) - (b.priority ?? 100));
+  }
+
+  /**
+   * 应用所有后处理器（包括父容器的后处理器）
+   * @param instance - 原始实例
+   * @param constructor - 构造函数
+   * @param originContainer - 原始调用容器（用于后处理器解析依赖）
+   * @returns 处理后的实例
+   */
+  private applyPostProcessors<T>(
+    instance: T,
+    constructor: Constructor<T>,
+    originContainer?: Container,
+  ): T {
+    // 使用原始容器或当前容器
+    const containerForProcessors = originContainer ?? this;
+    let result = instance;
+
+    // 先应用父容器的后处理器
+    if (this.parent) {
+      result = (this.parent as Container).applyPostProcessors(result, constructor, containerForProcessors);
+    }
+
+    // 再应用本容器的后处理器
+    // 传递原始调用容器，而不是当前容器
+    for (const processor of this.postProcessors) {
+      result = processor.postProcess(result, constructor, containerForProcessors);
+    }
+    return result;
+  }
+
   /**
    * 解析依赖
    * @param token - 提供者标识符
@@ -321,16 +367,19 @@ export class Container {
   private instantiate<T>(constructor: Constructor<T>): T {
     const plan = this.getDependencyPlan(constructor);
 
+    let instance: T;
     if (plan.paramLength === 0) {
-      return new constructor();
-    }
-
-    const dependencies = new Array(plan.paramLength);
-    for (let index = 0; index < plan.paramLength; index++) {
-      dependencies[index] = this.resolveFromPlan(constructor, plan, index);
+      instance = new constructor();
+    } else {
+      const dependencies = new Array(plan.paramLength);
+      for (let index = 0; index < plan.paramLength; index++) {
+        dependencies[index] = this.resolveFromPlan(constructor, plan, index);
+      }
+      instance = new constructor(...dependencies);
     }
 
-    return new constructor(...dependencies);
+    // 应用后处理器
+    return this.applyPostProcessors(instance, constructor);
   }
 
   /**
@@ -356,6 +405,7 @@ export class Container {
     this.singletons.clear();
     this.typeToToken.clear();
     this.dependencyPlans.clear();
+    this.postProcessors.length = 0;
     // scopedInstances 使用 WeakMap，当 Context 对象被 GC 时会自动清理
   }
 

package/src/di/index.ts

@@ -1,4 +1,10 @@
 export { Container } from './container';
 export { Injectable, Inject, getDependencyMetadata, isInjectable, getLifecycle } from './decorators';
-export { Lifecycle, type ProviderConfig, type DependencyMetadata } from './types';
+export {
+  Lifecycle,
+  INSTANCE_POST_PROCESSOR_TOKEN,
+  type ProviderConfig,
+  type DependencyMetadata,
+  type InstancePostProcessor,
+} from './types';
 

package/src/di/types.ts

@@ -1,5 +1,34 @@
 import type { Constructor } from '@/core/types'
 
+/**
+ * 实例后处理器接口
+ * 用于在 DI 容器创建实例后进行处理（如创建代理、注入额外依赖等）
+ */
+export interface InstancePostProcessor {
+  /**
+   * 处理新创建的实例
+   * @param instance - 原始实例
+   * @param constructor - 构造函数
+   * @param container - DI 容器引用
+   * @returns 处理后的实例（可以是代理）
+   */
+  postProcess<T>(
+    instance: T,
+    constructor: Constructor<T>,
+    container: unknown,
+  ): T;
+
+  /**
+   * 优先级（数字越小优先级越高，默认 100）
+   */
+  priority?: number;
+}
+
+/**
+ * 实例后处理器注册表 Token
+ */
+export const INSTANCE_POST_PROCESSOR_TOKEN = Symbol('@dangao/bun-server:di:post-processor');
+
 /**
  * 依赖生命周期类型
  */

package/src/index.ts

@@ -254,10 +254,17 @@ export {
   Cacheable,
   CacheEvict,
   CachePut,
+  EnableCacheProxy,
+  CacheServiceProxy,
+  CachePostProcessor,
+  CacheableInterceptor,
+  CacheEvictInterceptor,
+  CachePutInterceptor,
   MemoryCacheStore,
   RedisCacheStore,
   CACHE_SERVICE_TOKEN,
   CACHE_OPTIONS_TOKEN,
+  CACHE_POST_PROCESSOR_TOKEN,
 } from './cache';
 export type {
   CacheModuleOptions,

package/src/websocket/registry.ts

@@ -16,18 +16,24 @@ interface GatewayDefinition {
     message?: string;
     close?: string;
   };
+  pattern: RegExp;
+  paramNames: string[];
+  isStatic: boolean;
 }
 
 export interface WebSocketConnectionData {
   path: string;
   query?: URLSearchParams;
   context?: Context;
+  params?: Record<string, string>;
 }
 
 export class WebSocketGatewayRegistry {
   private static instance: WebSocketGatewayRegistry;
   private readonly container: Container;
   private readonly gateways = new Map<string, GatewayDefinition>();
+  private readonly staticGateways = new Map<string, GatewayDefinition>();
+  private readonly dynamicGateways: GatewayDefinition[] = [];
 
   private constructor() {
     this.container = ControllerRegistry.getInstance().getContainer();
@@ -40,6 +46,24 @@ export class WebSocketGatewayRegistry {
     return WebSocketGatewayRegistry.instance;
   }
 
+  /**
+   * 解析路径，生成匹配模式和参数名列表
+   * @param path - 路由路径
+   * @returns 匹配模式和参数名列表
+   */
+  private parsePath(path: string): { pattern: RegExp; paramNames: string[] } {
+    const paramNames: string[] = [];
+    const patternString = path
+      .replace(/:([^/]+)/g, (_, paramName) => {
+        paramNames.push(paramName);
+        return '([^/]+)';
+      })
+      .replace(/\*/g, '.*');
+
+    const pattern = new RegExp(`^${patternString}$`);
+    return { pattern, paramNames };
+  }
+
   public register(gatewayClass: Constructor<unknown>): void {
     const metadata = getGatewayMetadata(gatewayClass);
     if (!metadata) {
@@ -55,23 +79,82 @@ export class WebSocketGatewayRegistry {
       this.container.register(gatewayClass);
     }
 
-    this.gateways.set(metadata.path, {
+    // 解析路径
+    const { pattern, paramNames } = this.parsePath(metadata.path);
+    const isStatic = !metadata.path.includes(':') && !metadata.path.includes('*');
+
+    const definition: GatewayDefinition = {
       path: metadata.path,
       gatewayClass,
       handlers,
-    });
+      pattern,
+      paramNames,
+      isStatic,
+    };
+
+    this.gateways.set(metadata.path, definition);
+
+    // 分别存储静态和动态路由
+    if (isStatic) {
+      this.staticGateways.set(metadata.path, definition);
+    } else {
+      this.dynamicGateways.push(definition);
+    }
   }
 
+  /**
+   * 检查是否有匹配的网关（支持动态路径匹配）
+   * @param path - 请求路径
+   * @returns 是否有匹配的网关
+   */
   public hasGateway(path: string): boolean {
-    return this.gateways.has(path);
+    // 先检查静态路由
+    if (this.staticGateways.has(path)) {
+      return true;
+    }
+
+    // 遍历动态路由
+    for (const gateway of this.dynamicGateways) {
+      if (gateway.pattern.test(path)) {
+        return true;
+      }
+    }
+
+    return false;
   }
 
   public clear(): void {
     this.gateways.clear();
+    this.staticGateways.clear();
+    this.dynamicGateways.length = 0;
   }
 
-  private getGateway(path: string): GatewayDefinition | undefined {
-    return this.gateways.get(path);
+  /**
+   * 获取匹配的网关（支持动态路径匹配）
+   * @param path - 请求路径
+   * @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] ?? '';
+        }
+        return { definition: gateway, params };
+      }
+    }
+
+    return undefined;
   }
 
   /**
@@ -129,7 +212,16 @@ export class WebSocketGatewayRegistry {
           headers: new Headers(),
         });
         context = new Context(request);
+        // 设置路径参数到 Context
+        if (ws.data.params) {
+          context.params = ws.data.params;
+        }
         ws.data.context = context;
+      } else {
+        // 如果 Context 已存在，更新路径参数
+        if (ws.data.params) {
+          context.params = ws.data.params;
+        }
       }
 
       // 使用 ParamBinder 绑定参数
@@ -189,12 +281,16 @@ export class WebSocketGatewayRegistry {
 
   public async handleOpen(ws: ServerWebSocket<WebSocketConnectionData>): Promise<void> {
     const path = ws.data?.path;
-    const definition = path ? this.getGateway(path) : undefined;
-    if (!definition) {
+    const match = path ? this.getGateway(path) : undefined;
+    if (!match) {
       ws.close(1008, 'Gateway not found');
       return;
     }
-    await this.invokeHandler(ws, definition, definition.handlers.open);
+    // 保存路径参数到 WebSocket 连接数据
+    if (match.params && Object.keys(match.params).length > 0) {
+      ws.data.params = match.params;
+    }
+    await this.invokeHandler(ws, match.definition, match.definition.handlers.open);
   }
 
   public async handleMessage(
@@ -202,12 +298,16 @@ export class WebSocketGatewayRegistry {
     message: string | ArrayBuffer | ArrayBufferView,
   ): Promise<void> {
     const path = ws.data?.path;
-    const definition = path ? this.getGateway(path) : undefined;
-    if (!definition) {
+    const match = path ? this.getGateway(path) : undefined;
+    if (!match) {
       ws.close(1008, 'Gateway not found');
       return;
     }
-    await this.invokeHandler(ws, definition, definition.handlers.message, message);
+    // 保存路径参数到 WebSocket 连接数据（如果还没有）
+    if (match.params && Object.keys(match.params).length > 0 && !ws.data.params) {
+      ws.data.params = match.params;
+    }
+    await this.invokeHandler(ws, match.definition, match.definition.handlers.message, message);
   }
 
   public async handleClose(
@@ -216,11 +316,11 @@ export class WebSocketGatewayRegistry {
     reason: string,
   ): Promise<void> {
     const path = ws.data?.path;
-    const definition = path ? this.getGateway(path) : undefined;
-    if (!definition) {
+    const match = path ? this.getGateway(path) : undefined;
+    if (!match) {
       return;
     }
-    await this.invokeHandler(ws, definition, definition.handlers.close, code, reason);
+    await this.invokeHandler(ws, match.definition, match.definition.handlers.close, code, reason);
   }
 }
 

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

@@ -0,0 +1,284 @@
+import 'reflect-metadata';
+import { describe, expect, test, beforeEach, afterEach } from 'bun:test';
+import { Application } from '../../src/core/application';
+import { Controller } from '../../src/controller/controller';
+import { GET } from '../../src/router/decorators';
+import { Param } from '../../src/controller/decorators';
+import { Module } from '../../src/di/module';
+import { Injectable, Inject } from '../../src/di/decorators';
+import {
+  CacheModule,
+  CacheService,
+  Cacheable,
+  CacheEvict,
+  CachePut,
+  EnableCacheProxy,
+  CACHE_SERVICE_TOKEN,
+} from '../../src/cache';
+import { RouteRegistry } from '../../src/router/registry';
+import { ControllerRegistry } from '../../src/controller/controller';
+import { ModuleRegistry } from '../../src/di/module-registry';
+import { getTestPort } from '../utils/test-port';
+
+describe('Cache Decorators', () => {
+  let app: Application;
+  let port: number;
+  let callCount: number;
+
+  beforeEach(() => {
+    port = getTestPort();
+    callCount = 0;
+    CacheModule.reset();
+  });
+
+  afterEach(async () => {
+    if (app) {
+      await app.stop();
+    }
+    RouteRegistry.getInstance().clear();
+    ControllerRegistry.getInstance().clear();
+    ModuleRegistry.getInstance().clear();
+  });
+
+  test('@Cacheable should cache method results in service layer', async () => {
+    // 定义服务
+    @Injectable()
+    @EnableCacheProxy()
+    class UserService {
+      @Cacheable({ key: 'user:{0}', ttl: 5000 })
+      public async findById(id: string): Promise<{ id: string; name: string }> {
+        callCount++;
+        return { id, name: `User ${id}` };
+      }
+    }
+
+    // 定义控制器
+    @Controller('/api/users')
+    class UserController {
+      public constructor(private readonly userService: UserService) {}
+
+      @GET('/:id')
+      public async getUser(@Param('id') id: string): Promise<{ id: string; name: string }> {
+        return await this.userService.findById(id);
+      }
+    }
+
+    // 定义模块
+    @Module({
+      imports: [CacheModule.forRoot({ defaultTtl: 5000 })],
+      controllers: [UserController],
+      providers: [UserService],
+    })
+    class AppModule {}
+
+    // 创建应用
+    app = new Application({ port });
+    app.registerModule(AppModule);
+    await app.listen();
+
+    // 第一次调用 - 应该执行方法
+    const response1 = await fetch(`http://localhost:${port}/api/users/1`);
+    expect(response1.status).toBe(200);
+    const data1 = await response1.json();
+    expect(data1.id).toBe('1');
+    expect(data1.name).toBe('User 1');
+    expect(callCount).toBe(1);
+
+    // 第二次调用 - 应该使用缓存
+    const response2 = await fetch(`http://localhost:${port}/api/users/1`);
+    expect(response2.status).toBe(200);
+    const data2 = await response2.json();
+    expect(data2.id).toBe('1');
+    expect(data2.name).toBe('User 1');
+    expect(callCount).toBe(1); // 方法没有被再次调用
+
+    // 调用不同的 ID - 应该执行方法
+    const response3 = await fetch(`http://localhost:${port}/api/users/2`);
+    expect(response3.status).toBe(200);
+    const data3 = await response3.json();
+    expect(data3.id).toBe('2');
+    expect(data3.name).toBe('User 2');
+    expect(callCount).toBe(2);
+  });
+
+  test('@CacheEvict should clear cache', async () => {
+    // 定义服务
+    @Injectable()
+    @EnableCacheProxy()
+    class ProductService {
+      @Cacheable({ key: 'product:{0}', ttl: 5000 })
+      public async findById(id: string): Promise<{ id: string; name: string }> {
+        callCount++;
+        return { id, name: `Product ${id} v${callCount}` };
+      }
+
+      @CacheEvict({ key: 'product:{0}' })
+      public async deleteById(id: string): Promise<void> {
+        // 删除产品
+      }
+    }
+
+    // 定义控制器
+    @Controller('/api/products')
+    class ProductController {
+      public constructor(private readonly productService: ProductService) {}
+
+      @GET('/:id')
+      public async getProduct(@Param('id') id: string): Promise<{ id: string; name: string }> {
+        return await this.productService.findById(id);
+      }
+
+      @GET('/:id/delete')
+      public async deleteProduct(@Param('id') id: string): Promise<{ success: boolean }> {
+        await this.productService.deleteById(id);
+        return { success: true };
+      }
+    }
+
+    // 定义模块
+    @Module({
+      imports: [CacheModule.forRoot({ defaultTtl: 5000 })],
+      controllers: [ProductController],
+      providers: [ProductService],
+    })
+    class AppModule {}
+
+    // 创建应用
+    app = new Application({ port });
+    app.registerModule(AppModule);
+    await app.listen();
+
+    // 第一次调用 - 缓存产品
+    const response1 = await fetch(`http://localhost:${port}/api/products/1`);
+    expect(response1.status).toBe(200);
+    const data1 = await response1.json();
+    expect(data1.name).toBe('Product 1 v1');
+    expect(callCount).toBe(1);
+
+    // 第二次调用 - 使用缓存
+    const response2 = await fetch(`http://localhost:${port}/api/products/1`);
+    const data2 = await response2.json();
+    expect(data2.name).toBe('Product 1 v1');
+    expect(callCount).toBe(1);
+
+    // 删除产品 - 清除缓存
+    await fetch(`http://localhost:${port}/api/products/1/delete`);
+
+    // 再次获取 - 缓存已清除，应重新执行方法
+    const response3 = await fetch(`http://localhost:${port}/api/products/1`);
+    const data3 = await response3.json();
+    expect(data3.name).toBe('Product 1 v2');
+    expect(callCount).toBe(2);
+  });
+
+  test('@CachePut should always execute method and update cache', async () => {
+    // 定义服务
+    @Injectable()
+    @EnableCacheProxy()
+    class OrderService {
+      @Cacheable({ key: 'order:{0}', ttl: 5000 })
+      public async findById(id: string): Promise<{ id: string; status: string }> {
+        callCount++;
+        return { id, status: 'pending' };
+      }
+
+      @CachePut({ key: 'order:{0}', ttl: 5000 })
+      public async updateStatus(id: string, status: string): Promise<{ id: string; status: string }> {
+        return { id, status };
+      }
+    }
+
+    // 定义控制器
+    @Controller('/api/orders')
+    class OrderController {
+      public constructor(private readonly orderService: OrderService) {}
+
+      @GET('/:id')
+      public async getOrder(@Param('id') id: string): Promise<{ id: string; status: string }> {
+        return await this.orderService.findById(id);
+      }
+
+      @GET('/:id/update/:status')
+      public async updateOrder(
+        @Param('id') id: string,
+        @Param('status') status: string,
+      ): Promise<{ id: string; status: string }> {
+        return await this.orderService.updateStatus(id, status);
+      }
+    }
+
+    // 定义模块
+    @Module({
+      imports: [CacheModule.forRoot({ defaultTtl: 5000 })],
+      controllers: [OrderController],
+      providers: [OrderService],
+    })
+    class AppModule {}
+
+    // 创建应用
+    app = new Application({ port });
+    app.registerModule(AppModule);
+    await app.listen();
+
+    // 第一次调用 - 缓存订单
+    const response1 = await fetch(`http://localhost:${port}/api/orders/1`);
+    expect(response1.status).toBe(200);
+    const data1 = await response1.json();
+    expect(data1.status).toBe('pending');
+    expect(callCount).toBe(1);
+
+    // 更新订单状态 - @CachePut 会更新缓存
+    const response2 = await fetch(`http://localhost:${port}/api/orders/1/update/completed`);
+    const data2 = await response2.json();
+    expect(data2.status).toBe('completed');
+
+    // 再次获取 - 应该返回更新后的缓存
+    const response3 = await fetch(`http://localhost:${port}/api/orders/1`);
+    const data3 = await response3.json();
+    expect(data3.status).toBe('completed');
+    expect(callCount).toBe(1); // findById 没有被再次调用
+  });
+
+  test('Service without @EnableCacheProxy should not use cache', async () => {
+    // 定义服务（没有 @EnableCacheProxy）
+    @Injectable()
+    class NoCacheService {
+      @Cacheable({ key: 'nocache:{0}', ttl: 5000 })
+      public async findById(id: string): Promise<{ id: string }> {
+        callCount++;
+        return { id };
+      }
+    }
+
+    // 定义控制器
+    @Controller('/api/nocache')
+    class NoCacheController {
+      public constructor(private readonly noCacheService: NoCacheService) {}
+
+      @GET('/:id')
+      public async get(@Param('id') id: string): Promise<{ id: string }> {
+        return await this.noCacheService.findById(id);
+      }
+    }
+
+    // 定义模块
+    @Module({
+      imports: [CacheModule.forRoot({ defaultTtl: 5000 })],
+      controllers: [NoCacheController],
+      providers: [NoCacheService],
+    })
+    class AppModule {}
+
+    // 创建应用
+    app = new Application({ port });
+    app.registerModule(AppModule);
+    await app.listen();
+
+    // 两次调用都应该执行方法（没有缓存）
+    await fetch(`http://localhost:${port}/api/nocache/1`);
+    expect(callCount).toBe(1);
+
+    await fetch(`http://localhost:${port}/api/nocache/1`);
+    expect(callCount).toBe(2); // 方法被再次调用
+  });
+});