@dangao/bun-server 2.0.8 → 2.2.0

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');
     }

package/src/database/sql-manager.ts

@@ -0,0 +1,62 @@
+import { SQL } from 'bun';
+
+import type { BunSQLConfig } from './types';
+
+export class BunSQLManager {
+  private readonly instances = new Map<string, SQL>();
+  private defaultTenantId = 'default';
+
+  public getOrCreate(tenantId: string, config: BunSQLConfig): SQL {
+    const existing = this.instances.get(tenantId);
+    if (existing) {
+      return existing;
+    }
+
+    const pool = config.pool ?? {};
+    const sql = new SQL(config.url, {
+      max: pool.max ?? 10,
+      idleTimeout: pool.idleTimeout ?? 30,
+      maxLifetime: pool.maxLifetime ?? 0,
+      connectionTimeout: pool.connectionTimeout ?? 30000,
+    });
+    this.instances.set(tenantId, sql);
+    return sql;
+  }
+
+  public hasTenant(tenantId: string): boolean {
+    return this.instances.has(tenantId);
+  }
+
+  public get(tenantId: string): SQL | undefined {
+    return this.instances.get(tenantId);
+  }
+
+  public setDefaultTenant(tenantId: string): void {
+    this.defaultTenantId = tenantId;
+  }
+
+  public getDefault(): SQL {
+    const sql = this.instances.get(this.defaultTenantId);
+    if (!sql) {
+      throw new Error(
+        `[BunSQLManager] default tenant '${this.defaultTenantId}' not initialized`,
+      );
+    }
+    return sql;
+  }
+
+  public async destroy(tenantId: string, timeout = 10): Promise<void> {
+    const sql = this.instances.get(tenantId);
+    if (!sql) {
+      return;
+    }
+    await sql.close({ timeout });
+    this.instances.delete(tenantId);
+  }
+
+  public async destroyAll(timeout = 10): Promise<void> {
+    const tenantIds = Array.from(this.instances.keys());
+    await Promise.all(tenantIds.map((tenantId) => this.destroy(tenantId, timeout)));
+  }
+}
+

package/src/database/sqlite-adapter.ts

@@ -0,0 +1,121 @@
+import { Database, type SQLQueryBindings } from 'bun:sqlite';
+
+import type { SqliteV2Config } from './types';
+
+export interface DisposableLock {
+  [Symbol.dispose](): void;
+}
+
+export class Semaphore {
+  private active = 0;
+  private readonly queue: Array<() => void> = [];
+
+  public constructor(private readonly max: number) {}
+
+  public async acquire(): Promise<DisposableLock> {
+    if (this.active < this.max) {
+      this.active += 1;
+      return this.createDisposable();
+    }
+
+    await new Promise<void>((resolve) => this.queue.push(resolve));
+    this.active += 1;
+    return this.createDisposable();
+  }
+
+  private createDisposable(): DisposableLock {
+    let released = false;
+    return {
+      [Symbol.dispose]: () => {
+        if (released) {
+          return;
+        }
+        released = true;
+        this.active = Math.max(0, this.active - 1);
+        const next = this.queue.shift();
+        next?.();
+      },
+    };
+  }
+}
+
+export class SqliteAdapter {
+  private readonly db: Database;
+  public readonly semaphore: Semaphore;
+
+  public constructor(config: SqliteV2Config) {
+    this.db = new Database(config.database);
+    if (config.wal !== false) {
+      this.db.exec('PRAGMA journal_mode = WAL;');
+    }
+    this.semaphore = new Semaphore(config.maxWriteConcurrency ?? 1);
+  }
+
+  public query<T = unknown>(sql: string, params: SQLQueryBindings[] = []): T[] {
+    const stmt = this.db.query(sql);
+    return stmt.all(...params) as T[];
+  }
+
+  public async execute(sql: string, params: SQLQueryBindings[] = []): Promise<void> {
+    const stmt = this.db.query(sql);
+    stmt.run(...params);
+  }
+
+  public close(): void {
+    this.db.close();
+  }
+}
+
+export class SqliteManager {
+  private readonly instances = new Map<string, SqliteAdapter>();
+  private defaultTenantId = 'default';
+
+  public getOrCreate(tenantId: string, config: SqliteV2Config): SqliteAdapter {
+    const existing = this.instances.get(tenantId);
+    if (existing) {
+      return existing;
+    }
+    const adapter = new SqliteAdapter(config);
+    this.instances.set(tenantId, adapter);
+    return adapter;
+  }
+
+  public setDefaultTenant(tenantId: string): void {
+    this.defaultTenantId = tenantId;
+  }
+
+  public getDefault(): SqliteAdapter {
+    const adapter = this.instances.get(this.defaultTenantId);
+    if (!adapter) {
+      throw new Error(
+        `[SqliteManager] default tenant '${this.defaultTenantId}' not initialized`,
+      );
+    }
+    return adapter;
+  }
+
+  public getAdapter(tenantId: string): SqliteAdapter {
+    const adapter = this.instances.get(tenantId);
+    if (!adapter) {
+      throw new Error(`[SqliteManager] tenant '${tenantId}' not initialized`);
+    }
+    return adapter;
+  }
+
+  public destroy(tenantId: string): void {
+    const adapter = this.instances.get(tenantId);
+    if (!adapter) {
+      return;
+    }
+    adapter.close();
+    this.instances.delete(tenantId);
+  }
+
+  public destroyAll(): void {
+    for (const [tenantId, adapter] of this.instances.entries()) {
+      adapter.close();
+      this.instances.delete(tenantId);
+    }
+  }
+}
+

package/src/database/strategy-decorator.ts

@@ -0,0 +1,42 @@
+import 'reflect-metadata';
+
+import type { Constructor } from '@/core/types';
+
+export const DB_STRATEGY_KEY = Symbol('@dangao/bun-server:database:strategy');
+
+export type DbStrategyType = 'pool' | 'session';
+
+export function DbStrategy(
+  strategy: DbStrategyType,
+): MethodDecorator & ClassDecorator {
+  return (target: object, propertyKey?: string | symbol) => {
+    if (propertyKey !== undefined) {
+      Reflect.defineMetadata(DB_STRATEGY_KEY, strategy, target, propertyKey);
+      return;
+    }
+    Reflect.defineMetadata(DB_STRATEGY_KEY, strategy, target);
+  };
+}
+
+export function Session(): MethodDecorator & ClassDecorator {
+  return DbStrategy('session');
+}
+
+export function getDbStrategy(
+  controllerClass: Constructor<unknown>,
+  methodName: string,
+): DbStrategyType | undefined {
+  const methodStrategy = Reflect.getMetadata(
+    DB_STRATEGY_KEY,
+    controllerClass.prototype,
+    methodName,
+  ) as DbStrategyType | undefined;
+  if (methodStrategy) {
+    return methodStrategy;
+  }
+  return Reflect.getMetadata(
+    DB_STRATEGY_KEY,
+    controllerClass,
+  ) as DbStrategyType | undefined;
+}
+