@dangao/bun-server 2.0.8 → 2.1.0

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

@@ -3,8 +3,8 @@ 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';
+import { getTransactionMetadata } from './transaction-decorator';
+import { Propagation } from './transaction-types';
 
 /**
  * 事务拦截器
@@ -51,44 +51,26 @@ export class TransactionInterceptor implements Interceptor {
       case Propagation.REQUIRED:
         if (currentTransaction) {
           // 加入现有事务
-          return await TransactionInterceptor.executeInExistingTransaction(
-            originalMethod,
-            target,
-            args,
-            currentTransaction.id,
-            transactionManager,
-          );
+          return await Promise.resolve(originalMethod.apply(target, args));
         } else {
           // 创建新事务
-          return await TransactionInterceptor.executeInNewTransaction(
-            originalMethod,
-            target,
-            args,
+          return await transactionManager.runInTransaction(
+            async () => await Promise.resolve(originalMethod.apply(target, args)),
             transactionMetadata,
-            transactionManager,
           );
         }
 
       case Propagation.REQUIRES_NEW:
         // 总是创建新事务
-        return await TransactionInterceptor.executeInNewTransaction(
-          originalMethod,
-          target,
-          args,
+        return await transactionManager.runInNewTransaction(
+          async () => await Promise.resolve(originalMethod.apply(target, args)),
           transactionMetadata,
-          transactionManager,
         );
 
       case Propagation.SUPPORTS:
         if (currentTransaction) {
           // 加入现有事务
-          return await TransactionInterceptor.executeInExistingTransaction(
-            originalMethod,
-            target,
-            args,
-            currentTransaction.id,
-            transactionManager,
-          );
+          return await Promise.resolve(originalMethod.apply(target, args));
         } else {
           // 非事务执行
           return await Promise.resolve(originalMethod.apply(target, args));
@@ -109,22 +91,15 @@ export class TransactionInterceptor implements Interceptor {
       case Propagation.NESTED:
         if (currentTransaction) {
           // 创建嵌套事务（保存点）
-          return await TransactionInterceptor.executeInNestedTransaction(
-            originalMethod,
-            target,
-            args,
-            currentTransaction.id,
+          return await transactionManager.runInNestedTransaction(
+            async () => await Promise.resolve(originalMethod.apply(target, args)),
             transactionMetadata,
-            transactionManager,
           );
         } else {
           // 创建新事务
-          return await TransactionInterceptor.executeInNewTransaction(
-            originalMethod,
-            target,
-            args,
+          return await transactionManager.runInTransaction(
+            async () => await Promise.resolve(originalMethod.apply(target, args)),
             transactionMetadata,
-            transactionManager,
           );
         }
 
@@ -148,116 +123,4 @@ export class TransactionInterceptor implements Interceptor {
     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

@@ -1,8 +1,8 @@
-import { Injectable, Inject } from '../../di/decorators';
-import { DATABASE_SERVICE_TOKEN } from '../types';
-import type { DatabaseService } from '../service';
+import { Inject, Injectable } from '../../di/decorators';
+import { getCurrentSession, runWithSession } from '../database-context';
+import { BUN_SQL_MANAGER_TOKEN } from '../types';
+import type { BunSQLManager } from '../sql-manager';
 import {
-  Propagation,
   IsolationLevel,
   TransactionStatus,
   type TransactionOptions,
@@ -15,262 +15,195 @@ import {
  */
 @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,
+    @Inject(BUN_SQL_MANAGER_TOKEN)
+    private readonly sqlManager: BunSQLManager,
   ) {}
 
   /**
-   * 开始事务
+   * 在当前 session 中执行事务
    */
-  public async beginTransaction(
+  public async runInTransaction<T>(
+    fn: () => Promise<T>,
     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`);
+  ): Promise<T> {
+    const session = getCurrentSession();
+    if (!session) {
+      throw new Error(
+        '[TransactionManager] No database session in current request context',
+      );
     }
 
-    if (context.status !== TransactionStatus.ACTIVE) {
-      throw new Error(`Transaction ${transactionId} is not active`);
+    if (session.sqlite) {
+      return await this.runInSqliteTransaction(fn);
     }
 
-    // 查找连接
-    const connection = this.findConnectionByTransactionId(transactionId);
-    if (!connection) {
-      throw new Error(`Connection not found for transaction ${transactionId}`);
+    let reserved = session.reserved;
+    if (!reserved && session.lazyReserve) {
+      reserved = await session.lazyReserve();
+    }
+    if (!reserved) {
+      throw new Error(
+        '[TransactionManager] No reserved session in current context. Add @Session() or @DbStrategy("session").',
+      );
     }
 
-    // 提交事务
-    await this.executeCommit(connection);
-
-    context.status = TransactionStatus.COMMITTED;
-    this.cleanupTransaction(transactionId);
-  }
+    const transactionId = this.generateTransactionId();
+    session.transaction = {
+      id: transactionId,
+      status: TransactionStatus.ACTIVE,
+      level: 0,
+      savepoints: [],
+    };
 
-  /**
-   * 回滚事务
-   */
-  public async rollbackTransaction(transactionId: string): Promise<void> {
-    const context = this.transactions.get(transactionId);
-    if (!context) {
-      throw new Error(`Transaction ${transactionId} not found`);
+    if (options.isolationLevel) {
+      const isolationLevel = this.getIsolationLevelSQL(options.isolationLevel);
+      if (isolationLevel) {
+        await reserved`SET TRANSACTION ISOLATION LEVEL ${isolationLevel}`;
+      }
     }
 
-    // 查找连接
-    const connection = this.findConnectionByTransactionId(transactionId);
-    if (!connection) {
-      throw new Error(`Connection not found for transaction ${transactionId}`);
+    try {
+      const result = await reserved.begin(fn);
+      if (session.transaction) {
+        session.transaction.status = TransactionStatus.COMMITTED;
+      }
+      return result;
+    } catch (error) {
+      if (session.transaction) {
+        session.transaction.status = TransactionStatus.ROLLED_BACK;
+      }
+      throw error;
+    } finally {
+      session.transaction = undefined;
     }
-
-    // 回滚事务
-    await this.executeRollback(connection);
-
-    context.status = TransactionStatus.ROLLED_BACK;
-    this.cleanupTransaction(transactionId);
   }
 
   /**
-   * 创建保存点（用于嵌套事务）
+   * REQUIRES_NEW：使用独立连接开启新事务
    */
-  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);
+  public async runInNewTransaction<T>(
+    fn: () => Promise<T>,
+    options: TransactionOptions = {},
+  ): Promise<T> {
+    const reserved = await this.sqlManager.getDefault().reserve();
+    try {
+      const tenantId = getCurrentSession()?.tenantId ?? 'default';
+      return await runWithSession(
+        {
+          tenantId,
+          reserved: reserved as any,
+        },
+        () => this.runInTransaction(fn, options),
+      );
+    } finally {
+      await reserved.release();
     }
-
-    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`);
+  public async runInNestedTransaction<T>(
+    fn: () => Promise<T>,
+    options: TransactionOptions = {},
+  ): Promise<T> {
+    const session = getCurrentSession();
+    if (!session?.transaction || !session.reserved) {
+      throw new Error(
+        '[TransactionManager] NESTED propagation requires an active transaction',
+      );
     }
 
-    const connection = this.findConnectionByTransactionId(transactionId);
-    if (connection) {
-      await this.executeRollbackToSavepoint(connection, savepointName);
-    }
+    const savepointName = `sp_${session.transaction.level}_${Date.now()}`;
+    session.transaction.level += 1;
+    session.transaction.savepoints.push(savepointName);
 
-    // 移除该保存点之后的所有保存点
-    const index = context.savepoints?.indexOf(savepointName) ?? -1;
-    if (index >= 0 && context.savepoints) {
-      context.savepoints = context.savepoints.slice(0, index);
-      context.level = index;
+    await session.reserved`SAVEPOINT ${savepointName}`;
+    try {
+      return await fn();
+    } catch (error) {
+      if (this.shouldRollback(error, options)) {
+        await session.reserved`ROLLBACK TO SAVEPOINT ${savepointName}`;
+      }
+      throw error;
+    } finally {
+      session.transaction.level = Math.max(0, session.transaction.level - 1);
+      session.transaction.savepoints = session.transaction.savepoints.filter(
+        (item) => item !== savepointName,
+      );
     }
   }
 
-  /**
-   * 获取当前事务上下文
-   */
   public getCurrentTransaction(): TransactionContext | null {
-    // 简化实现：返回最后一个活动事务
-    // 实际实现中应该使用 ThreadLocal 或类似机制
-    for (const context of this.transactions.values()) {
-      if (context.status === TransactionStatus.ACTIVE) {
-        return context;
-      }
+    const tx = getCurrentSession()?.transaction;
+    if (!tx) {
+      return null;
     }
-    return null;
+    return {
+      id: tx.id,
+      status: tx.status,
+      startTime: 0,
+      level: tx.level,
+      savepoints: tx.savepoints,
+    };
   }
 
-  /**
-   * 检查是否有活动事务
-   */
   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;
+    const tx = this.getCurrentTransaction();
+    return tx?.status === TransactionStatus.ACTIVE;
   }
 
-  /**
-   * 清理事务
-   */
-  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;
-      }
+  public async runInSqliteTransaction<T>(fn: () => Promise<T>): Promise<T> {
+    const session = getCurrentSession();
+    if (!session?.sqlite) {
+      throw new Error(
+        '[TransactionManager] No sqlite adapter found in current request context',
+      );
     }
-  }
 
-  /**
-   * 执行 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);
+    using _lock = await session.sqlite.semaphore.acquire();
+    await session.sqlite.execute('BEGIN TRANSACTION');
+    try {
+      const result = await fn();
+      await session.sqlite.execute('COMMIT');
+      return result;
+    } catch (error) {
+      await session.sqlite.execute('ROLLBACK');
+      throw error;
     }
   }
 
-  /**
-   * 执行 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}`);
+  private generateTransactionId(): string {
+    return `tx_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
   }
 
-  /**
-   * 获取隔离级别的 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]}`;
+    return levelMap[level];
+  }
+
+  private shouldRollback(
+    error: unknown,
+    options: Pick<TransactionOptions, 'rollbackFor' | 'noRollbackFor'>,
+  ): boolean {
+    if (options.noRollbackFor && options.noRollbackFor.length > 0) {
+      for (const ErrorClass of options.noRollbackFor) {
+        if (error instanceof ErrorClass) {
+          return false;
+        }
+      }
     }
-
-    // SQLite 不支持隔离级别设置
-    return '';
+    if (options.rollbackFor && options.rollbackFor.length > 0) {
+      for (const ErrorClass of options.rollbackFor) {
+        if (error instanceof ErrorClass) {
+          return true;
+        }
+      }
+      return false;
+    }
+    return true;
   }
 }

package/src/database/service.ts

@@ -1,6 +1,7 @@
 import { Injectable } from '../di/decorators';
 
 import { DatabaseConnectionManager } from './connection-manager';
+import { getCurrentSession } from './database-context';
 import type {
   ConnectionInfo,
   DatabaseConfig,
@@ -18,8 +19,27 @@ export class DatabaseService {
 
   public constructor(options: DatabaseModuleOptions) {
     this.options = options;
+    const databaseConfig: DatabaseConfig =
+      options.database ??
+      (options.type === 'sqlite'
+        ? {
+            type: 'sqlite',
+            config: {
+              path: options.databasePath ?? ':memory:',
+            },
+          }
+        : {
+            type: (options.type ?? 'postgres') as 'postgres' | 'mysql',
+            config: {
+              host: options.host ?? 'localhost',
+              port: options.port ?? 5432,
+              database: options.databasePath ?? 'default',
+              user: options.username ?? 'root',
+              password: options.password ?? '',
+            },
+          });
     this.connectionManager = new DatabaseConnectionManager(
-      options.database,
+      databaseConfig,
       options.pool,
     );
   }
@@ -96,7 +116,13 @@ export class DatabaseService {
    * SQLite 返回同步结果，PostgreSQL/MySQL 返回异步结果
    */
   public query<T = unknown>(sql: string, params?: unknown[]): T[] | Promise<T[]> {
-    const connection = this.getConnection();
+    const session = getCurrentSession();
+    if (session?.sqlite) {
+      return session.sqlite.query<T>(sql, (params ?? []) as any);
+    }
+
+    const perRequestConnection = session?.reserved;
+    const connection = perRequestConnection ?? this.getConnection();
     if (!connection) {
       throw new Error('Database connection is not established');
     }