@dangao/bun-server 2.0.3 → 2.1.0

package/src/database/database-module.ts

@@ -1,30 +1,207 @@
 import { Module, MODULE_METADATA_KEY, type ModuleProvider } from '../di/module';
-import type { ApplicationExtension } from '../extensions/types';
-import {
-  InterceptorRegistry,
-  INTERCEPTOR_REGISTRY_TOKEN,
-} from '../interceptor';
 import { type AsyncModuleOptions, registerAsyncProviders } from '../di/async-module';
+import type { Constructor } from '@/core/types';
+import type { Middleware } from '../middleware';
 
 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 {
+  BUN_SQL_MANAGER_TOKEN,
+  DB_TOKEN,
   DATABASE_OPTIONS_TOKEN,
   DATABASE_SERVICE_TOKEN,
+  SQLITE_MANAGER_TOKEN,
+  type BunSQLConfig,
   type DatabaseModuleOptions,
+  type SqliteV2Config,
 } from './types';
 import { ORM_SERVICE_TOKEN } from './orm/types';
 import { TRANSACTION_SERVICE_TOKEN } from './orm/transaction-types';
+import { BunSQLManager } from './sql-manager';
+import { SqliteManager } from './sqlite-adapter';
+import { db, initDbProxy } from './db-proxy';
+import { getDbStrategy } from './strategy-decorator';
+import { runWithSession, type DatabaseSession } from './database-context';
 
 @Module({
   providers: [],
 })
 export class DatabaseModule {
+  private static isBunSqlType(
+    type: DatabaseModuleOptions['type'] | undefined,
+  ): type is 'postgres' | 'mysql' {
+    return type === 'postgres' || type === 'mysql';
+  }
+
+  public static normalizeConfig(
+    options: DatabaseModuleOptions,
+  ): Array<{ tenantId: string; config: BunSQLConfig | SqliteV2Config }> {
+    if (options.tenants && options.tenants.length > 0) {
+      return options.tenants.map((tenant) => ({
+        tenantId: tenant.id,
+        config: tenant.config,
+      }));
+    }
+
+    if (options.database?.type === 'sqlite') {
+      if (options.pool) {
+        console.warn('[DatabaseModule] pool options are ignored for SQLite');
+      }
+      return [
+        {
+          tenantId: options.defaultTenant ?? 'default',
+          config: {
+            type: 'sqlite',
+            database: options.database.config.path,
+            wal: options.wal ?? true,
+            maxWriteConcurrency: options.maxWriteConcurrency ?? 1,
+          },
+        },
+      ];
+    }
+
+    if (options.database?.type === 'postgres' || options.database?.type === 'mysql') {
+      const db = options.database;
+      const protocol = db.type === 'mysql' ? 'mysql' : 'postgres';
+      const url =
+        `${protocol}://${db.config.user}:${db.config.password}@${db.config.host}:${db.config.port}/${db.config.database}`;
+      return [
+        {
+          tenantId: options.defaultTenant ?? 'default',
+          config: {
+            type: db.type,
+            url,
+            pool: options.bunSqlPool,
+          },
+        },
+      ];
+    }
+
+    if (options.type === 'sqlite') {
+      return [
+        {
+          tenantId: options.defaultTenant ?? 'default',
+          config: {
+            type: 'sqlite',
+            database: options.databasePath ?? ':memory:',
+            wal: options.wal ?? true,
+            maxWriteConcurrency: options.maxWriteConcurrency ?? 1,
+          },
+        },
+      ];
+    }
+
+    if (options.url && DatabaseModule.isBunSqlType(options.type)) {
+      return [
+        {
+          tenantId: options.defaultTenant ?? 'default',
+          config: {
+            type: options.type,
+            url: options.url,
+            pool: options.bunSqlPool,
+          },
+        },
+      ];
+    }
+
+    if (options.host && DatabaseModule.isBunSqlType(options.type)) {
+      const protocol = options.type === 'mysql' ? 'mysql' : 'postgres';
+      const url =
+        `${protocol}://${options.username}:${options.password}@${options.host}:${options.port ?? 5432}/${options.databasePath ?? ''}`;
+      return [
+        {
+          tenantId: options.defaultTenant ?? 'default',
+          config: {
+            type: options.type,
+            url,
+            pool: options.bunSqlPool,
+          },
+        },
+      ];
+    }
+
+    throw new Error(
+      '[DatabaseModule] invalid configuration: specify tenants or single tenant connection options',
+    );
+  }
+
+  private static createDatabaseMiddleware(
+    options: DatabaseModuleOptions,
+    normalized: Array<{ tenantId: string; config: BunSQLConfig | SqliteV2Config }>,
+    sqlManager: BunSQLManager,
+    sqliteManager: SqliteManager,
+  ): Middleware {
+    const defaultStrategy = options.defaultStrategy ?? 'pool';
+    const defaultTenant = options.defaultTenant ?? normalized[0]?.tenantId ?? 'default';
+
+    return async (context, next) => {
+      const routeHandler = (context as any).routeHandler as
+        | { controller: Constructor<unknown>; method: string }
+        | undefined;
+
+      let strategy: 'pool' | 'session' = defaultStrategy;
+      if (routeHandler) {
+        const routeStrategy = getDbStrategy(
+          routeHandler.controller,
+          routeHandler.method,
+        );
+        const hasTx = Boolean(
+          Reflect.getMetadata(
+            TRANSACTION_METADATA_KEY,
+            routeHandler.controller.prototype,
+            routeHandler.method,
+          ),
+        );
+        strategy = routeStrategy ?? (hasTx ? 'session' : defaultStrategy);
+      }
+
+      if (strategy !== 'session') {
+        return await next();
+      }
+
+      const selected = normalized.find((item) => item.tenantId === defaultTenant) ?? normalized[0];
+      if (!selected) {
+        return await next();
+      }
+
+      if (selected.config.type === 'sqlite') {
+        const sqlite = sqliteManager.getAdapter(selected.tenantId);
+        return await runWithSession(
+          {
+            tenantId: selected.tenantId,
+            sqlite,
+          },
+          async () => await next(),
+        );
+      }
+
+      const sql = sqlManager.getOrCreate(selected.tenantId, selected.config);
+      let reserved: any;
+      const session: DatabaseSession = {
+        tenantId: selected.tenantId,
+        lazyReserve: async () => {
+          if (!reserved) {
+            reserved = await sql.reserve();
+            session.reserved = reserved;
+          }
+          return reserved;
+        },
+      };
+
+      try {
+        return await runWithSession(session, async () => await next());
+      } finally {
+        if (reserved) {
+          await reserved.release().catch(() => undefined);
+        }
+      }
+    };
+  }
+
   /**
    * 创建数据库模块
    * @param options - 模块配置
@@ -33,8 +210,47 @@ export class DatabaseModule {
     options: DatabaseModuleOptions,
   ): typeof DatabaseModule {
     const providers: ModuleProvider[] = [];
+    const normalized = DatabaseModule.normalizeConfig(options);
+    const sqlManager = new BunSQLManager();
+    const sqliteManager = new SqliteManager();
+
+    for (const item of normalized) {
+      if (item.config.type === 'sqlite') {
+        sqliteManager.getOrCreate(item.tenantId, item.config);
+      } else {
+        sqlManager.getOrCreate(item.tenantId, item.config);
+      }
+    }
+    sqlManager.setDefaultTenant(options.defaultTenant ?? normalized[0]?.tenantId ?? 'default');
+    sqliteManager.setDefaultTenant(options.defaultTenant ?? normalized[0]?.tenantId ?? 'default');
+
+    const legacyOptions: DatabaseModuleOptions = options.database
+      ? options
+      : {
+          ...options,
+          database:
+            normalized[0]?.config.type === 'sqlite'
+              ? {
+                  type: 'sqlite',
+                  config: {
+                    path: (normalized[0].config as SqliteV2Config).database,
+                  },
+                }
+              : {
+                  type: (normalized[0]?.config.type ?? 'postgres') as 'postgres' | 'mysql',
+                  config: {
+                    host: options.host ?? 'localhost',
+                    port: options.port ?? (normalized[0]?.config.type === 'mysql' ? 3306 : 5432),
+                    database: options.databasePath ?? 'default',
+                    user: options.username ?? 'root',
+                    password: options.password ?? '',
+                  },
+                },
+        };
 
-    const service = new DatabaseService(options);
+    const service = new DatabaseService(legacyOptions);
+    const transactionManager = new TransactionManager(sqlManager);
+    initDbProxy(sqlManager, transactionManager);
 
     providers.push(
       {
@@ -45,7 +261,22 @@ export class DatabaseModule {
         provide: DATABASE_OPTIONS_TOKEN,
         useValue: options,
       },
-      DatabaseService,
+      {
+        provide: DatabaseService,
+        useValue: service,
+      },
+      {
+        provide: BUN_SQL_MANAGER_TOKEN,
+        useValue: sqlManager,
+      },
+      {
+        provide: SQLITE_MANAGER_TOKEN,
+        useValue: sqliteManager,
+      },
+      {
+        provide: DB_TOKEN,
+        useValue: db,
+      },
     );
 
     // 如果启用了 ORM，注册 ORM 服务
@@ -65,13 +296,15 @@ export class DatabaseModule {
     }
 
     // 注册事务管理器（总是注册，即使 ORM 未启用）
-    const transactionManager = new TransactionManager(service);
     providers.push(
       {
         provide: TRANSACTION_SERVICE_TOKEN,
         useValue: transactionManager,
       },
-      TransactionManager,
+      {
+        provide: TransactionManager,
+        useValue: transactionManager,
+      },
     );
 
     // 数据库健康检查指示器可以通过 DatabaseModule.createHealthIndicator() 方法获取
@@ -82,7 +315,13 @@ export class DatabaseModule {
       Reflect.getMetadata(MODULE_METADATA_KEY, DatabaseModule) || {};
     
     // 创建数据库扩展，用于在应用启动时初始化连接
-    const databaseExtension = new DatabaseExtension();
+    const databaseExtension = new DatabaseExtension(sqlManager, sqliteManager);
+    const middleware = DatabaseModule.createDatabaseMiddleware(
+      options,
+      normalized,
+      sqlManager,
+      sqliteManager,
+    );
     
     const metadata = {
       ...existingMetadata,
@@ -102,6 +341,10 @@ export class DatabaseModule {
         ...(existingMetadata.extensions || []),
         databaseExtension,
       ],
+      middlewares: [
+        ...(existingMetadata.middlewares || []),
+        middleware,
+      ],
     };
     Reflect.defineMetadata(MODULE_METADATA_KEY, metadata, DatabaseModule);
 

package/src/database/db-proxy.ts

@@ -0,0 +1,75 @@
+import type { BunSQLManager } from './sql-manager';
+import { getCurrentSession } from './database-context';
+import type { TransactionManager } from './orm/transaction-manager';
+
+type DbResult = Promise<unknown>;
+
+export interface DbProxy {
+  (strings: TemplateStringsArray, ...values: unknown[]): DbResult;
+  transaction<T>(fn: () => Promise<T>): Promise<T>;
+  tenant(tenantId: string): DbProxy;
+}
+
+let sqlManagerRef: BunSQLManager | undefined;
+let txManagerRef: TransactionManager | undefined;
+
+export function initDbProxy(
+  sqlManager: BunSQLManager,
+  txManager: TransactionManager,
+): void {
+  sqlManagerRef = sqlManager;
+  txManagerRef = txManager;
+}
+
+function ensureReady(): { sqlManager: BunSQLManager; txManager: TransactionManager } {
+  if (!sqlManagerRef || !txManagerRef) {
+    throw new Error(
+      '[db] proxy is not initialized. Ensure DatabaseModule.forRoot() is called before using db.',
+    );
+  }
+  return { sqlManager: sqlManagerRef, txManager: txManagerRef };
+}
+
+const baseDb = async (
+  tenantId: string | undefined,
+  strings: TemplateStringsArray,
+  ...values: unknown[]
+): DbResult => {
+  const session = getCurrentSession();
+  if (session?.reserved) {
+    return await session.reserved(strings, ...values);
+  }
+
+  if (session?.lazyReserve) {
+    const reserved = await session.lazyReserve();
+    return await reserved(strings, ...values);
+  }
+
+  const { sqlManager } = ensureReady();
+  if (tenantId) {
+    const tenantSql = sqlManager.get(tenantId);
+    if (tenantSql) {
+      return await tenantSql(strings, ...values);
+    }
+  }
+  return await sqlManager.getDefault()(strings, ...values);
+};
+
+function createDb(tenantId?: string): DbProxy {
+  const fn = (async (
+    strings: TemplateStringsArray,
+    ...values: unknown[]
+  ) => baseDb(tenantId, strings, ...values)) as DbProxy;
+
+  fn.transaction = async <T>(txFn: () => Promise<T>): Promise<T> => {
+    const { txManager } = ensureReady();
+    return await txManager.runInTransaction(txFn);
+  };
+
+  fn.tenant = (id: string): DbProxy => createDb(id);
+
+  return fn;
+}
+
+export const db: DbProxy = createDb();
+

package/src/database/index.ts

@@ -4,9 +4,36 @@ export { DatabaseConnectionManager } from './connection-manager';
 export { ConnectionPool } from './connection-pool';
 export { DatabaseHealthIndicator } from './health-indicator';
 export { DatabaseExtension } from './database-extension';
+export { BunSQLManager } from './sql-manager';
+export { SqliteAdapter, SqliteManager, Semaphore } from './sqlite-adapter';
 export {
+  db,
+  initDbProxy,
+  type DbProxy,
+} from './db-proxy';
+export {
+  DbStrategy,
+  Session as DbSession,
+  DB_STRATEGY_KEY,
+  getDbStrategy,
+  type DbStrategyType,
+} from './strategy-decorator';
+export {
+  databaseSessionStore,
+  getCurrentSession,
+  runWithSession,
+  type DatabaseSession,
+  type TransactionState,
+  type ReservedSqlSession,
+} from './database-context';
+export {
+  BUN_SQL_MANAGER_TOKEN,
+  DB_TOKEN,
   DATABASE_OPTIONS_TOKEN,
   DATABASE_SERVICE_TOKEN,
+  SQLITE_MANAGER_TOKEN,
+  type BunSQLConfig,
+  type BunSQLPoolOptions,
   type ConnectionInfo,
   type ConnectionPoolOptions,
   type DatabaseConfig,
@@ -14,7 +41,9 @@ export {
   type DatabaseType,
   type MysqlConfig,
   type PostgresConfig,
+  type SqliteV2Config,
   type SqliteConfig,
+  type TenantConfig,
 } from './types';
 // ORM 导出
 export {

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