@dangao/bun-server 1.0.0 → 1.0.3

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

@@ -0,0 +1,243 @@
+import { Container } from '../../di/container';
+import { TRANSACTION_SERVICE_TOKEN } from './transaction-types';
+import { TransactionManager } from './transaction-manager';
+import { getTransactionMetadata } from './transaction-decorator';
+import { Propagation, TransactionStatus } from './transaction-types';
+
+/**
+ * 事务拦截器
+ * 在方法调用时检查 @Transactional() 装饰器并执行事务逻辑
+ */
+export class TransactionInterceptor {
+  /**
+   * 执行带事务的方法
+   */
+  public static async executeWithTransaction<T>(
+    target: unknown,
+    propertyKey: string | symbol,
+    originalMethod: (...args: unknown[]) => T | Promise<T>,
+    args: unknown[],
+    container: Container,
+  ): 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 this.executeInExistingTransaction(
+            originalMethod,
+            target,
+            args,
+            currentTransaction.id,
+            transactionManager,
+          );
+        } else {
+          // 创建新事务
+          return await this.executeInNewTransaction(
+            originalMethod,
+            target,
+            args,
+            transactionMetadata,
+            transactionManager,
+          );
+        }
+
+      case Propagation.REQUIRES_NEW:
+        // 总是创建新事务
+        return await this.executeInNewTransaction(
+          originalMethod,
+          target,
+          args,
+          transactionMetadata,
+          transactionManager,
+        );
+
+      case Propagation.SUPPORTS:
+        if (currentTransaction) {
+          // 加入现有事务
+          return await this.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 this.executeInNestedTransaction(
+            originalMethod,
+            target,
+            args,
+            currentTransaction.id,
+            transactionMetadata,
+            transactionManager,
+          );
+        } else {
+          // 创建新事务
+          return await this.executeInNewTransaction(
+            originalMethod,
+            target,
+            args,
+            transactionMetadata,
+            transactionManager,
+          );
+        }
+
+      default:
+        return await Promise.resolve(originalMethod.apply(target, args));
+    }
+  }
+
+  /**
+   * 在新事务中执行方法
+   */
+  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 '';
+  }
+}

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

@@ -0,0 +1,140 @@
+/**
+ * 事务传播行为
+ */
+export enum Propagation {
+  /**
+   * 如果当前存在事务，则加入该事务；如果当前不存在事务，则创建一个新的事务
+   */
+  REQUIRED = 'REQUIRED',
+  /**
+   * 创建一个新的事务，如果当前存在事务，则把当前事务挂起
+   */
+  REQUIRES_NEW = 'REQUIRES_NEW',
+  /**
+   * 如果当前存在事务，则加入该事务；如果当前不存在事务，则以非事务的方式继续运行
+   */
+  SUPPORTS = 'SUPPORTS',
+  /**
+   * 以非事务方式执行操作，如果当前存在事务，则把当前事务挂起
+   */
+  NOT_SUPPORTED = 'NOT_SUPPORTED',
+  /**
+   * 以非事务方式执行，如果当前存在事务，则抛出异常
+   */
+  NEVER = 'NEVER',
+  /**
+   * 如果当前存在事务，则在嵌套事务内执行；如果当前不存在事务，则创建一个新的事务
+   */
+  NESTED = 'NESTED',
+}
+
+/**
+ * 事务隔离级别
+ */
+export enum IsolationLevel {
+  /**
+   * 读未提交（最低级别）
+   */
+  READ_UNCOMMITTED = 'READ_UNCOMMITTED',
+  /**
+   * 读已提交
+   */
+  READ_COMMITTED = 'READ_COMMITTED',
+  /**
+   * 可重复读
+   */
+  REPEATABLE_READ = 'REPEATABLE_READ',
+  /**
+   * 串行化（最高级别）
+   */
+  SERIALIZABLE = 'SERIALIZABLE',
+}
+
+/**
+ * 事务状态
+ */
+export enum TransactionStatus {
+  /**
+   * 活动状态
+   */
+  ACTIVE = 'ACTIVE',
+  /**
+   * 已提交
+   */
+  COMMITTED = 'COMMITTED',
+  /**
+   * 已回滚
+   */
+  ROLLED_BACK = 'ROLLED_BACK',
+  /**
+   * 已挂起
+   */
+  SUSPENDED = 'SUSPENDED',
+}
+
+/**
+ * 事务配置选项
+ */
+export interface TransactionOptions {
+  /**
+   * 事务传播行为
+   * @default Propagation.REQUIRED
+   */
+  propagation?: Propagation;
+  /**
+   * 事务隔离级别
+   */
+  isolationLevel?: IsolationLevel;
+  /**
+   * 超时时间（秒）
+   */
+  timeout?: number;
+  /**
+   * 是否只读
+   * @default false
+   */
+  readOnly?: boolean;
+  /**
+   * 回滚异常类型（遇到这些异常时回滚）
+   */
+  rollbackFor?: Array<new () => Error>;
+  /**
+   * 不回滚异常类型（遇到这些异常时不回滚）
+   */
+  noRollbackFor?: Array<new () => Error>;
+}
+
+/**
+ * 事务上下文
+ */
+export interface TransactionContext {
+  /**
+   * 事务 ID
+   */
+  id: string;
+  /**
+   * 事务状态
+   */
+  status: TransactionStatus;
+  /**
+   * 事务开始时间
+   */
+  startTime: number;
+  /**
+   * 嵌套层级
+   */
+  level: number;
+  /**
+   * 父事务 ID（如果有）
+   */
+  parentId?: string;
+  /**
+   * 保存点（用于嵌套事务）
+   */
+  savepoints?: string[];
+}
+
+/**
+ * Transaction Service Token
+ */
+export const TRANSACTION_SERVICE_TOKEN = Symbol('@dangao/bun-server:orm:transaction:service');