@dangao/bun-server 1.0.1 → 1.1.2

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

@@ -0,0 +1,76 @@
+import 'reflect-metadata';
+import { Propagation } from './transaction-types';
+import type { TransactionOptions } from './transaction-types';
+
+/**
+ * Transaction 元数据键
+ */
+export const TRANSACTION_METADATA_KEY = Symbol('@dangao/bun-server:orm:transaction');
+
+/**
+ * Transactional 装饰器
+ * 标记方法需要在事务中执行
+ * @param options - 事务配置选项
+ */
+export function Transactional(options?: TransactionOptions): MethodDecorator {
+  return (target, propertyKey, descriptor) => {
+    if (!descriptor || typeof descriptor.value !== 'function') {
+      throw new Error('@Transactional() can only be applied to methods');
+    }
+
+    const metadata = {
+      propagation: options?.propagation ?? Propagation.REQUIRED,
+      isolationLevel: options?.isolationLevel,
+      timeout: options?.timeout,
+      readOnly: options?.readOnly ?? false,
+      rollbackFor: options?.rollbackFor ?? [],
+      noRollbackFor: options?.noRollbackFor ?? [],
+    };
+
+    Reflect.defineMetadata(TRANSACTION_METADATA_KEY, metadata, target, propertyKey);
+  };
+}
+
+/**
+ * 获取 Transaction 元数据
+ * 支持从实例或原型上获取元数据（元数据通常存储在原型上）
+ */
+export function getTransactionMetadata(
+  target: unknown,
+  propertyKey: string | symbol,
+): TransactionOptions | undefined {
+  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

@@ -0,0 +1,263 @@
+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, TRANSACTION_METADATA_KEY } from './transaction-decorator';
+import { Propagation, TransactionStatus } from './transaction-types';
+
+/**
+ * 事务拦截器
+ * 在方法调用时检查 @Transactional() 装饰器并执行事务逻辑
+ * 实现 Interceptor 接口，通过拦截器机制注册和执行
+ */
+export class TransactionInterceptor implements Interceptor {
+  /**
+   * 执行拦截器逻辑
+   * 实现 Interceptor 接口
+   */
+  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);
+
+    // 如果没有事务元数据，直接执行原方法
+    if (!transactionMetadata) {
+      return await Promise.resolve(originalMethod.apply(target, args));
+    }
+
+    // 获取事务管理器
+    let transactionManager: TransactionManager;
+    try {
+      transactionManager = container.resolve<TransactionManager>(
+        TRANSACTION_SERVICE_TOKEN,
+      );
+    } catch (error) {
+      // 如果没有注册事务管理器，直接执行原方法
+      console.warn('TransactionManager not found, executing without transaction');
+      return await Promise.resolve(originalMethod.apply(target, args));
+    }
+
+    const propagation = transactionMetadata.propagation ?? Propagation.REQUIRED;
+    const currentTransaction = transactionManager.getCurrentTransaction();
+
+    // 根据传播行为决定事务策略
+    switch (propagation) {
+      case Propagation.REQUIRED:
+        if (currentTransaction) {
+          // 加入现有事务
+          return await TransactionInterceptor.executeInExistingTransaction(
+            originalMethod,
+            target,
+            args,
+            currentTransaction.id,
+            transactionManager,
+          );
+        } else {
+          // 创建新事务
+          return await TransactionInterceptor.executeInNewTransaction(
+            originalMethod,
+            target,
+            args,
+            transactionMetadata,
+            transactionManager,
+          );
+        }
+
+      case Propagation.REQUIRES_NEW:
+        // 总是创建新事务
+        return await TransactionInterceptor.executeInNewTransaction(
+          originalMethod,
+          target,
+          args,
+          transactionMetadata,
+          transactionManager,
+        );
+
+      case Propagation.SUPPORTS:
+        if (currentTransaction) {
+          // 加入现有事务
+          return await TransactionInterceptor.executeInExistingTransaction(
+            originalMethod,
+            target,
+            args,
+            currentTransaction.id,
+            transactionManager,
+          );
+        } else {
+          // 非事务执行
+          return await Promise.resolve(originalMethod.apply(target, args));
+        }
+
+      case Propagation.NOT_SUPPORTED:
+        // 非事务执行
+        return await Promise.resolve(originalMethod.apply(target, args));
+
+      case Propagation.NEVER:
+        if (currentTransaction) {
+          throw new Error(
+            'Transaction propagation NEVER requires no existing transaction',
+          );
+        }
+        return await Promise.resolve(originalMethod.apply(target, args));
+
+      case Propagation.NESTED:
+        if (currentTransaction) {
+          // 创建嵌套事务（保存点）
+          return await TransactionInterceptor.executeInNestedTransaction(
+            originalMethod,
+            target,
+            args,
+            currentTransaction.id,
+            transactionMetadata,
+            transactionManager,
+          );
+        } else {
+          // 创建新事务
+          return await TransactionInterceptor.executeInNewTransaction(
+            originalMethod,
+            target,
+            args,
+            transactionMetadata,
+            transactionManager,
+          );
+        }
+
+      default:
+        return await Promise.resolve(originalMethod.apply(target, args));
+    }
+  }
+
+  /**
+   * 执行带事务的方法（静态方法，保持向后兼容）
+   * @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);
+  }
+
+  /**
+   * 在新事务中执行方法
+   */
+  private static async executeInNewTransaction<T>(
+    method: (...args: unknown[]) => T | Promise<T>,
+    target: unknown,
+    args: unknown[],
+    options: {
+      timeout?: number;
+      rollbackFor?: Array<new () => Error>;
+      noRollbackFor?: Array<new () => Error>;
+    },
+    transactionManager: TransactionManager,
+  ): Promise<T> {
+    const context = await transactionManager.beginTransaction({
+      timeout: options.timeout,
+    });
+
+    try {
+      const result = await Promise.resolve(method.apply(target, args));
+      await transactionManager.commitTransaction(context.id);
+      return result;
+    } catch (error) {
+      // 检查是否需要回滚
+      if (this.shouldRollback(error, options.rollbackFor, options.noRollbackFor)) {
+        await transactionManager.rollbackTransaction(context.id);
+      } else {
+        await transactionManager.commitTransaction(context.id);
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * 在现有事务中执行方法
+   */
+  private static async executeInExistingTransaction<T>(
+    method: (...args: unknown[]) => T | Promise<T>,
+    target: unknown,
+    args: unknown[],
+    transactionId: string,
+    transactionManager: TransactionManager,
+  ): Promise<T> {
+    // 直接执行，不提交或回滚（由外层事务管理）
+    return await Promise.resolve(method.apply(target, args));
+  }
+
+  /**
+   * 在嵌套事务中执行方法
+   */
+  private static async executeInNestedTransaction<T>(
+    method: (...args: unknown[]) => T | Promise<T>,
+    target: unknown,
+    args: unknown[],
+    parentTransactionId: string,
+    options: {
+      timeout?: number;
+      rollbackFor?: Array<new () => Error>;
+      noRollbackFor?: Array<new () => Error>;
+    },
+    transactionManager: TransactionManager,
+  ): Promise<T> {
+    const savepointName = await transactionManager.createSavepoint(parentTransactionId);
+
+    try {
+      const result = await Promise.resolve(method.apply(target, args));
+      // 嵌套事务成功，不执行任何操作（保存点保留）
+      return result;
+    } catch (error) {
+      // 检查是否需要回滚到保存点
+      if (this.shouldRollback(error, options.rollbackFor, options.noRollbackFor)) {
+        await transactionManager.rollbackToSavepoint(parentTransactionId, savepointName);
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * 判断是否应该回滚
+   */
+  private static shouldRollback(
+    error: unknown,
+    rollbackFor?: Array<new () => Error>,
+    noRollbackFor?: Array<new () => Error>,
+  ): boolean {
+    if (!error) {
+      return false;
+    }
+
+    // 如果指定了 noRollbackFor，且错误匹配，则不回滚
+    if (noRollbackFor && noRollbackFor.length > 0) {
+      for (const ErrorClass of noRollbackFor) {
+        if (error instanceof ErrorClass) {
+          return false;
+        }
+      }
+    }
+
+    // 如果指定了 rollbackFor，且错误匹配，则回滚
+    if (rollbackFor && rollbackFor.length > 0) {
+      for (const ErrorClass of rollbackFor) {
+        if (error instanceof ErrorClass) {
+          return true;
+        }
+      }
+      // 如果指定了 rollbackFor 但错误不匹配，则不回滚
+      return false;
+    }
+
+    // 默认情况下，所有错误都回滚
+    return true;
+  }
+}

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

@@ -0,0 +1,276 @@
+import { Injectable, Inject } from '../../di/decorators';
+import { DATABASE_SERVICE_TOKEN } from '../types';
+import type { DatabaseService } from '../service';
+import {
+  Propagation,
+  IsolationLevel,
+  TransactionStatus,
+  type TransactionOptions,
+  type TransactionContext,
+} from './transaction-types';
+
+/**
+ * 事务管理器
+ * 管理数据库事务的生命周期
+ */
+@Injectable()
+export class TransactionManager {
+  private readonly transactions = new Map<string, TransactionContext>();
+  private readonly connectionTransactions = new Map<unknown, string>(); // connection -> transactionId
+
+  public constructor(
+    @Inject(DATABASE_SERVICE_TOKEN)
+    private readonly databaseService: DatabaseService,
+  ) {}
+
+  /**
+   * 开始事务
+   */
+  public async beginTransaction(
+    options: TransactionOptions = {},
+  ): Promise<TransactionContext> {
+    const transactionId = this.generateTransactionId();
+    const context: TransactionContext = {
+      id: transactionId,
+      status: TransactionStatus.ACTIVE,
+      startTime: Date.now(),
+      level: 0,
+      savepoints: [],
+    };
+
+    // 获取数据库连接
+    const connection = await this.databaseService.getConnection();
+    this.connectionTransactions.set(connection, transactionId);
+    this.transactions.set(transactionId, context);
+
+    // 开始事务（根据数据库类型）
+    await this.executeBegin(connection, options);
+
+    return context;
+  }
+
+  /**
+   * 提交事务
+   */
+  public async commitTransaction(transactionId: string): Promise<void> {
+    const context = this.transactions.get(transactionId);
+    if (!context) {
+      throw new Error(`Transaction ${transactionId} not found`);
+    }
+
+    if (context.status !== TransactionStatus.ACTIVE) {
+      throw new Error(`Transaction ${transactionId} is not active`);
+    }
+
+    // 查找连接
+    const connection = this.findConnectionByTransactionId(transactionId);
+    if (!connection) {
+      throw new Error(`Connection not found for transaction ${transactionId}`);
+    }
+
+    // 提交事务
+    await this.executeCommit(connection);
+
+    context.status = TransactionStatus.COMMITTED;
+    this.cleanupTransaction(transactionId);
+  }
+
+  /**
+   * 回滚事务
+   */
+  public async rollbackTransaction(transactionId: string): Promise<void> {
+    const context = this.transactions.get(transactionId);
+    if (!context) {
+      throw new Error(`Transaction ${transactionId} not found`);
+    }
+
+    // 查找连接
+    const connection = this.findConnectionByTransactionId(transactionId);
+    if (!connection) {
+      throw new Error(`Connection not found for transaction ${transactionId}`);
+    }
+
+    // 回滚事务
+    await this.executeRollback(connection);
+
+    context.status = TransactionStatus.ROLLED_BACK;
+    this.cleanupTransaction(transactionId);
+  }
+
+  /**
+   * 创建保存点（用于嵌套事务）
+   */
+  public async createSavepoint(transactionId: string): Promise<string> {
+    const context = this.transactions.get(transactionId);
+    if (!context) {
+      throw new Error(`Transaction ${transactionId} not found`);
+    }
+
+    const savepointName = `sp_${context.level}_${Date.now()}`;
+    context.savepoints = context.savepoints || [];
+    context.savepoints.push(savepointName);
+    context.level += 1;
+
+    const connection = this.findConnectionByTransactionId(transactionId);
+    if (connection) {
+      await this.executeSavepoint(connection, savepointName);
+    }
+
+    return savepointName;
+  }
+
+  /**
+   * 回滚到保存点
+   */
+  public async rollbackToSavepoint(
+    transactionId: string,
+    savepointName: string,
+  ): Promise<void> {
+    const context = this.transactions.get(transactionId);
+    if (!context) {
+      throw new Error(`Transaction ${transactionId} not found`);
+    }
+
+    const connection = this.findConnectionByTransactionId(transactionId);
+    if (connection) {
+      await this.executeRollbackToSavepoint(connection, savepointName);
+    }
+
+    // 移除该保存点之后的所有保存点
+    const index = context.savepoints?.indexOf(savepointName) ?? -1;
+    if (index >= 0 && context.savepoints) {
+      context.savepoints = context.savepoints.slice(0, index);
+      context.level = index;
+    }
+  }
+
+  /**
+   * 获取当前事务上下文
+   */
+  public getCurrentTransaction(): TransactionContext | null {
+    // 简化实现：返回最后一个活动事务
+    // 实际实现中应该使用 ThreadLocal 或类似机制
+    for (const context of this.transactions.values()) {
+      if (context.status === TransactionStatus.ACTIVE) {
+        return context;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * 检查是否有活动事务
+   */
+  public hasActiveTransaction(): boolean {
+    return this.getCurrentTransaction() !== null;
+  }
+
+  /**
+   * 生成事务 ID
+   */
+  private generateTransactionId(): string {
+    return `tx_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+  }
+
+  /**
+   * 查找连接对应的事务 ID
+   */
+  private findConnectionByTransactionId(transactionId: string): unknown {
+    for (const [connection, txId] of this.connectionTransactions.entries()) {
+      if (txId === transactionId) {
+        return connection;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * 清理事务
+   */
+  private cleanupTransaction(transactionId: string): void {
+    this.transactions.delete(transactionId);
+    // 清理连接映射
+    for (const [connection, txId] of this.connectionTransactions.entries()) {
+      if (txId === transactionId) {
+        this.connectionTransactions.delete(connection);
+        break;
+      }
+    }
+  }
+
+  /**
+   * 执行 BEGIN 语句
+   */
+  private async executeBegin(connection: unknown, options: TransactionOptions): Promise<void> {
+    const dbType = this.databaseService['config'].database.type;
+
+    if (dbType === 'sqlite') {
+      // SQLite 默认自动提交，需要显式开始事务
+      await this.databaseService.query('BEGIN TRANSACTION');
+    } else if (dbType === 'postgres' || dbType === 'mysql') {
+      // PostgreSQL 和 MySQL 使用 Bun.SQL，需要设置隔离级别
+      let sql = 'START TRANSACTION';
+      if (options.isolationLevel) {
+        const isolation = this.getIsolationLevelSQL(options.isolationLevel);
+        sql += ` ${isolation}`;
+      }
+      if (options.readOnly) {
+        sql += ' READ ONLY';
+      }
+      await this.databaseService.query(sql);
+    }
+  }
+
+  /**
+   * 执行 COMMIT 语句
+   */
+  private async executeCommit(connection: unknown): Promise<void> {
+    await this.databaseService.query('COMMIT');
+  }
+
+  /**
+   * 执行 ROLLBACK 语句
+   */
+  private async executeRollback(connection: unknown): Promise<void> {
+    await this.databaseService.query('ROLLBACK');
+  }
+
+  /**
+   * 执行 SAVEPOINT 语句
+   */
+  private async executeSavepoint(connection: unknown, savepointName: string): Promise<void> {
+    await this.databaseService.query(`SAVEPOINT ${savepointName}`);
+  }
+
+  /**
+   * 执行 ROLLBACK TO SAVEPOINT 语句
+   */
+  private async executeRollbackToSavepoint(
+    connection: unknown,
+    savepointName: string,
+  ): Promise<void> {
+    await this.databaseService.query(`ROLLBACK TO SAVEPOINT ${savepointName}`);
+  }
+
+  /**
+   * 获取隔离级别的 SQL
+   */
+  private getIsolationLevelSQL(level: IsolationLevel): string {
+    const dbType = this.databaseService['config'].database.type;
+    const levelMap: Record<IsolationLevel, string> = {
+      [IsolationLevel.READ_UNCOMMITTED]: 'READ UNCOMMITTED',
+      [IsolationLevel.READ_COMMITTED]: 'READ COMMITTED',
+      [IsolationLevel.REPEATABLE_READ]: 'REPEATABLE READ',
+      [IsolationLevel.SERIALIZABLE]: 'SERIALIZABLE',
+    };
+
+    if (dbType === 'postgres') {
+      return `SET TRANSACTION ISOLATION LEVEL ${levelMap[level]}`;
+    } else if (dbType === 'mysql') {
+      return `SET TRANSACTION ISOLATION LEVEL ${levelMap[level]}`;
+    }
+
+    // SQLite 不支持隔离级别设置
+    return '';
+  }
+}