@dangao/bun-server 2.0.8 → 2.1.0

package/src/database/database-extension.ts

@@ -7,14 +7,19 @@ import {
 
 import { TransactionInterceptor } from './orm/transaction-interceptor';
 import { TRANSACTION_METADATA_KEY } from './orm/transaction-decorator';
-import { DATABASE_SERVICE_TOKEN } from './types';
-import type { DatabaseService } from './service';
+import type { BunSQLManager } from './sql-manager';
+import type { SqliteManager } from './sqlite-adapter';
 
 /**
  * 数据库扩展
- * 在应用启动时自动初始化数据库连接
+ * 注册事务拦截器，并在应用关闭时释放数据库资源
  */
 export class DatabaseExtension implements ApplicationExtension {
+  public constructor(
+    private readonly sqlManager?: BunSQLManager,
+    private readonly sqliteManager?: SqliteManager,
+  ) {}
+
   public register(container: Container): void {
     // 注册事务拦截器到拦截器注册表
     try {
@@ -36,48 +41,10 @@ export class DatabaseExtension implements ApplicationExtension {
   }
 
   /**
-   * 初始化数据库连接
-   * 应该在应用启动时调用
+   * 关闭数据库资源
    */
-  public async initialize(container: Container): Promise<void> {
-    try {
-      const databaseService = container.resolve<DatabaseService>(
-        DATABASE_SERVICE_TOKEN,
-      );
-      await databaseService.initialize();
-    } catch (error) {
-      // 如果 DatabaseService 未注册，忽略错误
-      // 这意味着用户可能没有使用 DatabaseModule
-      if (
-        error instanceof Error &&
-        error.message.includes('Provider not found')
-      ) {
-        return;
-      }
-      throw error;
-    }
-  }
-
-  /**
-   * 关闭数据库连接
-   * 应该在应用停止时调用
-   */
-  public async close(container: Container): Promise<void> {
-    try {
-      const databaseService = container.resolve<DatabaseService>(
-        DATABASE_SERVICE_TOKEN,
-      );
-      // 关闭连接池（关闭所有连接）
-      await databaseService.closePool();
-    } catch (error) {
-      // 如果 DatabaseService 未注册，忽略错误
-      if (
-        error instanceof Error &&
-        error.message.includes('Provider not found')
-      ) {
-        return;
-      }
-      throw error;
-    }
+  public async close(_container: Container): Promise<void> {
+    await this.sqlManager?.destroyAll(10);
+    this.sqliteManager?.destroyAll();
   }
 }

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 {