@dangao/bun-server 1.0.3 → 1.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dangao/bun-server",
-  "version": "1.0.3",
+  "version": "1.1.2",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -56,6 +56,6 @@
   },
   "dependencies": {
     "reflect-metadata": "^0.2.2",
-    "@dangao/logsmith": "0.1.0"
+    "@dangao/logsmith": "0.1.1"
   }
 }

package/src/controller/controller.ts

@@ -8,7 +8,13 @@ import { getClassMiddlewares, getMethodMiddlewares } from '../middleware';
 import type { Middleware } from '../middleware';
 import { getValidationMetadata, validateParameters, ValidationError } from '../validation';
 import { HttpException } from '../error';
-import type { Constructor } from '@/core/types'
+import type { Constructor } from '@/core/types';
+import {
+  type InterceptorRegistry,
+  INTERCEPTOR_REGISTRY_TOKEN,
+  InterceptorChain,
+  scanInterceptorMetadata,
+} from '../interceptor';
 
 /**
  * 控制器元数据键
@@ -27,7 +33,7 @@ export interface ControllerMetadata {
   /**
    * 控制器类
    */
-  target: new (...args: unknown[]) => unknown;
+  target: Constructor<unknown>;
 }
 
 /**
@@ -49,7 +55,7 @@ export function Controller(path: string = '') {
 export class ControllerRegistry {
   private static instance: ControllerRegistry;
   private readonly container: Container;
-  private readonly controllers = new Map<new (...args: unknown[]) => unknown, unknown>();
+  private readonly controllers = new Map<Constructor<unknown>, unknown>();
   private readonly controllerContainers = new Map<Constructor<unknown>, Container>();
 
   private constructor() {
@@ -142,35 +148,56 @@ export class ControllerRegistry {
 
           // 调用控制器方法
           // 优先从实例获取，如果不存在则从原型获取
+          // 注意：prototype 已在上面声明（第 140 行），因为后续扫描拦截器元数据时需要用到
           let method = (controllerInstance as Record<string, (...args: unknown[]) => unknown>)[propertyKey!];
           if (!method || typeof method !== 'function') {
             // 从构造函数原型获取方法
-            const prototype = controllerClass.prototype;
             method = prototype[propertyKey!];
           }
           if (!method || typeof method !== 'function') {
             throw new Error(`Method ${propertyKey} not found on controller ${controllerClass.name}`);
           }
 
-          // 检查是否有事务装饰器
-          let result: unknown;
+          // 获取拦截器注册表
+          let interceptorRegistry: InterceptorRegistry | undefined;
           try {
-            const { TransactionInterceptor } = await import('../database/orm/transaction-interceptor');
-            const { getTransactionMetadata } = await import('../database/orm/transaction-decorator');
-            const hasTransaction = getTransactionMetadata(prototype, propertyKey!);
-            if (hasTransaction) {
-              result = TransactionInterceptor.executeWithTransaction(
-                prototype,
+            interceptorRegistry = controllerContainer.resolve<InterceptorRegistry>(
+              INTERCEPTOR_REGISTRY_TOKEN,
+            );
+          } catch (error) {
+            // 如果拦截器注册表未注册，继续执行（向后兼容）
+            interceptorRegistry = undefined;
+          }
+
+          // 执行拦截器链或直接调用方法
+          let result: unknown;
+          if (interceptorRegistry) {
+            // 扫描方法上的所有拦截器元数据
+            const interceptors = scanInterceptorMetadata(
+              prototype,
+              propertyKey!,
+              interceptorRegistry,
+            );
+
+            if (interceptors.length > 0) {
+              // 执行拦截器链
+              // 注意：传递 controllerInstance 以确保 originalMethod.apply 的 this 绑定正确
+              // getMetadata 方法已经修复以支持从原型链查找元数据
+              result = await InterceptorChain.execute(
+                interceptors,
+                controllerInstance,
                 propertyKey!,
                 method,
                 params,
                 controllerContainer,
+                context,
               );
             } else {
+              // 没有拦截器，直接执行方法
               result = method.apply(controllerInstance, params);
             }
-          } catch (error) {
-            // 如果导入失败或执行失败，回退到直接调用
+          } else {
+            // 拦截器注册表未注册，直接执行方法（向后兼容）
             result = method.apply(controllerInstance, params);
           }
 

package/src/core/application.ts

@@ -10,7 +10,8 @@ import type { ApplicationExtension } from '../extensions/types';
 import { LoggerExtension } from '../extensions/logger-extension';
 import { ModuleRegistry } from '../di/module-registry';
 import type { ModuleClass } from '../di/module';
-import type { Constructor } from './types'
+import type { Constructor } from './types';
+import { InterceptorRegistry, INTERCEPTOR_REGISTRY_TOKEN } from '../interceptor';
 
 /**
  * 应用配置选项
@@ -48,6 +49,11 @@ export class Application {
     ControllerRegistry.getInstance().clear();
     ModuleRegistry.getInstance().clear();
 
+    // 注册 InterceptorRegistry 到 DI 容器
+    const container = ControllerRegistry.getInstance().getContainer();
+    const interceptorRegistry = new InterceptorRegistry();
+    container.registerInstance(INTERCEPTOR_REGISTRY_TOKEN, interceptorRegistry);
+
     // 默认注册 Logger（如果通过模块注册，会被覆盖）
     this.registerExtension(new LoggerExtension());
   }

package/src/database/database-extension.ts

@@ -1,6 +1,12 @@
 import type { Container } from '../di/container';
 import type { ApplicationExtension } from '../extensions/types';
+import {
+  InterceptorRegistry,
+  INTERCEPTOR_REGISTRY_TOKEN,
+} from '../interceptor';
 
+import { TransactionInterceptor } from './orm/transaction-interceptor';
+import { TRANSACTION_METADATA_KEY } from './orm/transaction-decorator';
 import { DATABASE_SERVICE_TOKEN } from './types';
 import type { DatabaseService } from './service';
 
@@ -10,8 +16,23 @@ import type { DatabaseService } from './service';
  */
 export class DatabaseExtension implements ApplicationExtension {
   public register(container: Container): void {
-    // 扩展注册时不初始化，等待应用启动时初始化
-    // 这里只是标记需要初始化
+    // 注册事务拦截器到拦截器注册表
+    try {
+      const interceptorRegistry = container.resolve<InterceptorRegistry>(
+        INTERCEPTOR_REGISTRY_TOKEN,
+      );
+      const transactionInterceptor = new TransactionInterceptor();
+      // 使用 TRANSACTION_METADATA_KEY 作为元数据键
+      // 优先级设置为 50，确保事务拦截器在其他业务拦截器之前执行
+      interceptorRegistry.register(
+        TRANSACTION_METADATA_KEY,
+        transactionInterceptor,
+        50,
+      );
+    } catch (error) {
+      // 如果拦截器注册表未注册，忽略错误（向后兼容）
+      // 这意味着拦截器机制可能未启用
+    }
   }
 
   /**

package/src/database/database-module.ts

@@ -1,10 +1,16 @@
 import { Module, MODULE_METADATA_KEY, type ModuleProvider } from '../di/module';
 import type { ApplicationExtension } from '../extensions/types';
+import {
+  InterceptorRegistry,
+  INTERCEPTOR_REGISTRY_TOKEN,
+} from '../interceptor';
 
 import { DatabaseExtension } from './database-extension';
 import { DatabaseHealthIndicator } from './health-indicator';
 import { OrmService } from './orm/service';
 import { TransactionManager } from './orm/transaction-manager';
+import { TransactionInterceptor } from './orm/transaction-interceptor';
+import { TRANSACTION_METADATA_KEY } from './orm/transaction-decorator';
 import { DatabaseService } from './service';
 import {
   DATABASE_OPTIONS_TOKEN,

package/src/database/orm/transaction-decorator.ts

@@ -33,13 +33,44 @@ export function Transactional(options?: TransactionOptions): MethodDecorator {
 
 /**
  * 获取 Transaction 元数据
+ * 支持从实例或原型上获取元数据（元数据通常存储在原型上）
  */
 export function getTransactionMetadata(
   target: unknown,
   propertyKey: string | symbol,
 ): TransactionOptions | undefined {
-  if (typeof target === 'object' && target !== null) {
-    return Reflect.getMetadata(TRANSACTION_METADATA_KEY, target, propertyKey);
+  if (typeof target !== 'object' || target === null) {
+    return undefined;
   }
+
+  // 首先尝试直接从 target 获取（如果 target 是原型）
+  let metadata = Reflect.getMetadata(TRANSACTION_METADATA_KEY, target, propertyKey) as TransactionOptions | undefined;
+  if (metadata !== undefined) {
+    return metadata;
+  }
+
+  // 如果 target 是实例，尝试从原型获取
+  // 装饰器元数据通常存储在原型上，而不是实例上
+  const prototype = Object.getPrototypeOf(target);
+  if (prototype && prototype !== Object.prototype) {
+    metadata = Reflect.getMetadata(TRANSACTION_METADATA_KEY, prototype, propertyKey) as TransactionOptions | undefined;
+    if (metadata !== undefined) {
+      return metadata;
+    }
+  }
+
+  // 如果仍然找不到，尝试从构造函数原型获取
+  // 这处理了 target 是实例但原型链查找失败的情况
+  const constructor = (target as any).constructor;
+  if (constructor && typeof constructor === 'function') {
+    // 如果 target 本身不是构造函数原型，尝试从构造函数原型获取
+    if (target !== constructor.prototype) {
+      metadata = Reflect.getMetadata(TRANSACTION_METADATA_KEY, constructor.prototype, propertyKey) as TransactionOptions | undefined;
+      if (metadata !== undefined) {
+        return metadata;
+      }
+    }
+  }
+
   return undefined;
 }

package/src/database/orm/transaction-interceptor.ts

@@ -1,23 +1,28 @@
-import { Container } from '../../di/container';
+import type { Container } from '../../di/container';
+import type { Context } from '../../core/context';
+import type { Interceptor } from '../../interceptor';
 import { TRANSACTION_SERVICE_TOKEN } from './transaction-types';
 import { TransactionManager } from './transaction-manager';
-import { getTransactionMetadata } from './transaction-decorator';
+import { getTransactionMetadata, TRANSACTION_METADATA_KEY } from './transaction-decorator';
 import { Propagation, TransactionStatus } from './transaction-types';
 
 /**
  * 事务拦截器
  * 在方法调用时检查 @Transactional() 装饰器并执行事务逻辑
+ * 实现 Interceptor 接口，通过拦截器机制注册和执行
  */
-export class TransactionInterceptor {
+export class TransactionInterceptor implements Interceptor {
   /**
-   * 执行带事务的方法
+   * 执行拦截器逻辑
+   * 实现 Interceptor 接口
    */
-  public static async executeWithTransaction<T>(
+  public async execute<T>(
     target: unknown,
     propertyKey: string | symbol,
     originalMethod: (...args: unknown[]) => T | Promise<T>,
     args: unknown[],
     container: Container,
+    context?: Context,
   ): Promise<T> {
     const transactionMetadata = getTransactionMetadata(target, propertyKey);
 
@@ -46,7 +51,7 @@ export class TransactionInterceptor {
       case Propagation.REQUIRED:
         if (currentTransaction) {
           // 加入现有事务
-          return await this.executeInExistingTransaction(
+          return await TransactionInterceptor.executeInExistingTransaction(
             originalMethod,
             target,
             args,
@@ -55,7 +60,7 @@ export class TransactionInterceptor {
           );
         } else {
           // 创建新事务
-          return await this.executeInNewTransaction(
+          return await TransactionInterceptor.executeInNewTransaction(
             originalMethod,
             target,
             args,
@@ -66,7 +71,7 @@ export class TransactionInterceptor {
 
       case Propagation.REQUIRES_NEW:
         // 总是创建新事务
-        return await this.executeInNewTransaction(
+        return await TransactionInterceptor.executeInNewTransaction(
           originalMethod,
           target,
           args,
@@ -77,7 +82,7 @@ export class TransactionInterceptor {
       case Propagation.SUPPORTS:
         if (currentTransaction) {
           // 加入现有事务
-          return await this.executeInExistingTransaction(
+          return await TransactionInterceptor.executeInExistingTransaction(
             originalMethod,
             target,
             args,
@@ -104,7 +109,7 @@ export class TransactionInterceptor {
       case Propagation.NESTED:
         if (currentTransaction) {
           // 创建嵌套事务（保存点）
-          return await this.executeInNestedTransaction(
+          return await TransactionInterceptor.executeInNestedTransaction(
             originalMethod,
             target,
             args,
@@ -114,7 +119,7 @@ export class TransactionInterceptor {
           );
         } else {
           // 创建新事务
-          return await this.executeInNewTransaction(
+          return await TransactionInterceptor.executeInNewTransaction(
             originalMethod,
             target,
             args,
@@ -128,6 +133,21 @@ export class TransactionInterceptor {
     }
   }
 
+  /**
+   * 执行带事务的方法（静态方法，保持向后兼容）
+   * @deprecated 使用拦截器机制，此方法保留用于向后兼容
+   */
+  public static async executeWithTransaction<T>(
+    target: unknown,
+    propertyKey: string | symbol,
+    originalMethod: (...args: unknown[]) => T | Promise<T>,
+    args: unknown[],
+    container: Container,
+  ): Promise<T> {
+    const interceptor = new TransactionInterceptor();
+    return await interceptor.execute(target, propertyKey, originalMethod, args, container);
+  }
+
   /**
    * 在新事务中执行方法
    */

package/src/index.ts

@@ -17,6 +17,28 @@ export {
   type ModuleClass,
 } from './di/module';
 export { ModuleRegistry } from './di/module-registry';
+export {
+  InterceptorRegistry,
+  InterceptorChain,
+  scanInterceptorMetadata,
+  BaseInterceptor,
+  Cache,
+  CacheInterceptor,
+  Permission,
+  PermissionInterceptor,
+  Log,
+  LogInterceptor,
+  INTERCEPTOR_REGISTRY_TOKEN,
+  CACHE_METADATA_KEY,
+  PERMISSION_METADATA_KEY,
+  LOG_METADATA_KEY,
+  type Interceptor,
+  type InterceptorMetadata,
+  type CacheOptions,
+  type PermissionOptions,
+  type PermissionService,
+  type LogOptions,
+} from './interceptor';
 export { UseMiddleware, RateLimit, MiddlewarePipeline } from './middleware';
 export type { Middleware, NextFunction } from './middleware';
 export {

package/src/interceptor/base-interceptor.ts

@@ -0,0 +1,203 @@
+import type { Interceptor } from './types';
+import type { Container } from '../di/container';
+import type { Context } from '../core/context';
+import 'reflect-metadata';
+
+/**
+ * 拦截器基类
+ * 提供便捷的前置处理、后置处理和错误处理方法
+ */
+export abstract class BaseInterceptor implements Interceptor {
+  /**
+   * 执行拦截器逻辑
+   * 子类必须实现此方法
+   */
+  public abstract execute<T>(
+    target: unknown,
+    propertyKey: string | symbol,
+    originalMethod: (...args: unknown[]) => T | Promise<T>,
+    args: unknown[],
+    container: Container,
+    context?: Context,
+  ): Promise<T>;
+
+  /**
+   * 前置处理（可选）
+   * 在方法执行前调用，子类可以覆盖此方法
+   * @param target - 目标对象
+   * @param propertyKey - 方法名
+   * @param args - 方法参数
+   * @param container - DI 容器
+   * @param context - 请求上下文（可选）
+   */
+  protected async before(
+    target: unknown,
+    propertyKey: string | symbol,
+    args: unknown[],
+    container: Container,
+    context?: Context,
+  ): Promise<void> {
+    // 默认空实现，子类可覆盖
+  }
+
+  /**
+   * 后置处理（可选）
+   * 在方法执行后调用，子类可以覆盖此方法
+   * @param target - 目标对象
+   * @param propertyKey - 方法名
+   * @param result - 方法执行结果
+   * @param container - DI 容器
+   * @param context - 请求上下文（可选）
+   * @returns 处理后的结果（默认返回原结果）
+   */
+  protected async after<T>(
+    target: unknown,
+    propertyKey: string | symbol,
+    result: T,
+    container: Container,
+    context?: Context,
+  ): Promise<T> {
+    // 默认返回原结果，子类可覆盖
+    return result;
+  }
+
+  /**
+   * 错误处理（可选）
+   * 在方法执行出错时调用，子类可以覆盖此方法
+   * @param target - 目标对象
+   * @param propertyKey - 方法名
+   * @param error - 错误对象
+   * @param container - DI 容器
+   * @param context - 请求上下文（可选）
+   * @returns 永远不会返回（总是抛出错误）
+   * @throws 重新抛出错误或抛出新的错误
+   */
+  protected async onError(
+    target: unknown,
+    propertyKey: string | symbol,
+    error: unknown,
+    container: Container,
+    context?: Context,
+  ): Promise<never> {
+    // 默认重新抛出错误，子类可覆盖
+    throw error;
+  }
+
+  /**
+   * 获取元数据
+   * 从目标对象的方法上获取指定元数据键的元数据
+   * 支持从实例或原型上获取元数据（元数据通常存储在原型上）
+   * @param target - 目标对象（可能是实例或原型）
+   * @param propertyKey - 方法名
+   * @param metadataKey - 元数据键
+   * @returns 元数据值，如果不存在则返回 undefined
+   */
+  protected getMetadata<T = unknown>(
+    target: unknown,
+    propertyKey: string | symbol,
+    metadataKey: symbol,
+  ): T | undefined {
+    if (typeof target !== 'object' || target === null) {
+      return undefined;
+    }
+
+    // 首先尝试直接从 target 获取（如果 target 是原型）
+    let metadata = Reflect.getMetadata(metadataKey, target, propertyKey) as T | undefined;
+    if (metadata !== undefined) {
+      return metadata;
+    }
+
+    // 如果 target 是实例，尝试从原型获取
+    // 装饰器元数据通常存储在原型上，而不是实例上
+    const prototype = Object.getPrototypeOf(target);
+    if (prototype && prototype !== Object.prototype) {
+      metadata = Reflect.getMetadata(metadataKey, prototype, propertyKey) as T | undefined;
+      if (metadata !== undefined) {
+        return metadata;
+      }
+    }
+
+    // 如果仍然找不到，尝试从构造函数原型获取
+    // 这处理了 target 是实例但原型链查找失败的情况
+    const constructor = (target as any).constructor;
+    if (constructor && typeof constructor === 'function') {
+      // 如果 target 本身不是构造函数原型，尝试从构造函数原型获取
+      if (target !== constructor.prototype) {
+        metadata = Reflect.getMetadata(metadataKey, constructor.prototype, propertyKey) as T | undefined;
+        if (metadata !== undefined) {
+          return metadata;
+        }
+      }
+    }
+
+    return undefined;
+  }
+
+  /**
+   * 从容器解析服务
+   * @param container - DI 容器
+   * @param token - 服务标识符
+   * @returns 服务实例
+   */
+  protected resolveService<T>(
+    container: Container,
+    token: (new (...args: unknown[]) => T) | string | symbol,
+  ): T {
+    return container.resolve<T>(token);
+  }
+
+  /**
+   * 从上下文获取值
+   * @param context - 请求上下文
+   * @param key - 键名
+   * @returns 值，如果不存在则返回 undefined
+   */
+  protected getContextValue<T = unknown>(context: Context | undefined, key: string): T | undefined {
+    if (!context) {
+      return undefined;
+    }
+    // Context 没有直接的存储机制，可以通过 headers 或其他方式获取
+    // 这里提供一个基础实现，子类可以根据需要扩展
+    return undefined;
+  }
+
+  /**
+   * 从上下文获取请求头
+   * @param context - 请求上下文
+   * @param headerName - 请求头名称
+   * @returns 请求头值，如果不存在则返回 null
+   */
+  protected getHeader(context: Context | undefined, headerName: string): string | null {
+    if (!context) {
+      return null;
+    }
+    return context.getHeader(headerName);
+  }
+
+  /**
+   * 从上下文获取查询参数
+   * @param context - 请求上下文
+   * @param paramName - 参数名称
+   * @returns 参数值，如果不存在则返回 null
+   */
+  protected getQuery(context: Context | undefined, paramName: string): string | null {
+    if (!context) {
+      return null;
+    }
+    return context.getQuery(paramName);
+  }
+
+  /**
+   * 从上下文获取路径参数
+   * @param context - 请求上下文
+   * @param paramName - 参数名称
+   * @returns 参数值，如果不存在则返回 undefined
+   */
+  protected getParam(context: Context | undefined, paramName: string): string | undefined {
+    if (!context) {
+      return undefined;
+    }
+    return context.getParam(paramName);
+  }
+}
+