@dangao/bun-server 2.0.8 → 2.2.0

package/src/controller/controller.ts

@@ -16,6 +16,7 @@ import {
   scanInterceptorMetadata,
 } from '../interceptor';
 import { LoggerManager } from '@dangao/logsmith';
+import { getIdleTimeout } from '../router/timeout-decorator';
 
 /**
  * 控制器元数据键
@@ -233,7 +234,16 @@ export class ControllerRegistry {
       }
 
       // 注册路由，传递控制器和方法信息
-      registry.register(route.method, fullPath, handler, middlewares, controllerClass, propertyKey);
+      const timeout = getIdleTimeout(controllerClass, propertyKey);
+      registry.register(
+        route.method,
+        fullPath,
+        handler,
+        middlewares,
+        controllerClass,
+        propertyKey,
+        timeout,
+      );
     }
   }
 

package/src/core/application.ts

@@ -10,7 +10,7 @@ import { WebSocketGatewayRegistry } from '../websocket/registry';
 import type { ApplicationExtension } from '../extensions/types';
 import { LoggerExtension } from '../extensions/logger-extension';
 import { ModuleRegistry } from '../di/module-registry';
-import type { ModuleClass } from '../di/module';
+import { MODULE_METADATA_KEY, type ModuleClass } from '../di/module';
 import type { Constructor } from './types';
 import { InterceptorRegistry, INTERCEPTOR_REGISTRY_TOKEN } from '../interceptor';
 import { CONFIG_SERVICE_TOKEN } from '../config/types';
@@ -20,6 +20,7 @@ import { CacheModule, CACHE_POST_PROCESSOR_TOKEN } from '../cache';
 import { LoggerManager } from '@dangao/logsmith';
 import { EventModule } from '../events/event-module';
 import { AsyncProviderRegistry } from '../di/async-module';
+import { ServiceRegistryModule } from '../microservice/service-registry/service-registry-module';
 
 /**
  * 应用配置选项
@@ -54,6 +55,12 @@ export interface ApplicationOptions {
    * @default false
    */
   reusePort?: boolean;
+
+  /**
+   * 连接空闲超时时间（毫秒）
+   * 框架内部会自动转换为 Bun.serve 的秒单位
+   */
+  idleTimeout?: number;
 }
 
 /**
@@ -77,6 +84,13 @@ export class Application {
     RouteRegistry.getInstance().clear();
     ControllerRegistry.getInstance().clear();
     ModuleRegistry.getInstance().clear();
+    const serviceRegistryMetadata = Reflect.getMetadata(
+      MODULE_METADATA_KEY,
+      ServiceRegistryModule,
+    );
+    if (!serviceRegistryMetadata) {
+      ServiceRegistryModule.autoRegister = true;
+    }
 
     // 注册 InterceptorRegistry 到 DI 容器
     const container = ControllerRegistry.getInstance().getContainer();
@@ -135,6 +149,7 @@ export class Application {
       port: finalPort,
       hostname: finalHostname,
       reusePort: this.options.reusePort,
+      idleTimeout: this.options.idleTimeout,
       fetch: this.handleRequest.bind(this),
       websocketRegistry: this.websocketRegistry,
       gracefulShutdownTimeout: this.options.gracefulShutdownTimeout,
@@ -309,6 +324,7 @@ export class Application {
    */
   private async handleRequest(context: Context): Promise<Response> {
     const logger = LoggerManager.getLogger();
+    const moduleRegistry = ModuleRegistry.getInstance();
     logger.debug('[Request] Incoming', {
       method: context.method,
       path: context.path,
@@ -317,34 +333,46 @@ export class Application {
 
     // 使用 AsyncLocalStorage 包裹请求处理，确保所有中间件和控制器都在请求上下文中执行
     return await contextStore.run(context, async () => {
-      // 对于 POST、PUT、PATCH 请求，提前解析 body 并缓存
-      // 这样可以确保 Request.body 流只读取一次
-      if (['POST', 'PUT', 'PATCH'].includes(context.method)) {
-        await context.getBody();
-      }
-
-      // 先通过路由解析出处理器信息，便于安全中间件等基于路由元数据做决策
-      const registry = RouteRegistry.getInstance();
-      const router = registry.getRouter();
-
-      // 预解析路由，仅设置上下文信息，不执行处理器
-      await router.preHandle(context);
-
-      // 再进入中间件管道，由中间件（如安全过滤器）根据 routeHandler 和 Auth 元数据做校验，
-      // 最后再由路由真正执行控制器方法
-      return await this.middlewarePipeline.run(context, async () => {
-        const response = await router.handle(context);
-        if (response) {
-          return response;
+      try {
+        // 对于 POST、PUT、PATCH 请求，提前解析 body 并缓存
+        // 这样可以确保 Request.body 流只读取一次
+        if (['POST', 'PUT', 'PATCH'].includes(context.method)) {
+          await context.getBody();
         }
 
-        logger.debug('[Router] No route matched', {
-          method: context.method,
-          path: context.path,
+        // 先通过路由解析出处理器信息，便于安全中间件等基于路由元数据做决策
+        const registry = RouteRegistry.getInstance();
+        const router = registry.getRouter();
+
+        // 预解析路由，仅设置上下文信息，不执行处理器
+        await router.preHandle(context);
+
+        // 再进入中间件管道，由中间件（如安全过滤器）根据 routeHandler 和 Auth 元数据做校验，
+        // 最后再由路由真正执行控制器方法
+        return await this.middlewarePipeline.run(context, async () => {
+          const response = await router.handle(context);
+          if (response) {
+            return response;
+          }
+
+          logger.debug('[Router] No route matched', {
+            method: context.method,
+            path: context.path,
+          });
+          context.setStatus(404);
+          return context.createErrorResponse({ error: 'Not Found' });
         });
-        context.setStatus(404);
-        return context.createErrorResponse({ error: 'Not Found' });
-      });
+      } finally {
+        try {
+          await moduleRegistry.disposeScopedInstances(context);
+        } catch (error) {
+          logger.warn('[Application] Failed to dispose scoped instances', {
+            path: context.path,
+            method: context.method,
+            errorMessage: error instanceof Error ? error.message : String(error),
+          });
+        }
+      }
     });
   }
 
@@ -430,7 +458,27 @@ export class Application {
    * 扫描所有使用 @ServiceRegistry 装饰器的控制器，自动注册服务
    */
   private async registerServices(port: number, hostname?: string): Promise<void> {
+    if (ServiceRegistryModule.autoRegister === false) {
+      return;
+    }
     try {
+      const configuredService = ServiceRegistryModule.autoRegisterService;
+      if (configuredService) {
+        const { SERVICE_REGISTRY_TOKEN } = await import(
+          '../microservice/service-registry/types'
+        );
+        const container = this.getContainer();
+        if (container.isRegistered(SERVICE_REGISTRY_TOKEN)) {
+          const registry = container.resolve<any>(SERVICE_REGISTRY_TOKEN);
+          await registry.register({
+            ...configuredService,
+            ip: configuredService.ip ?? hostname ?? '127.0.0.1',
+            port: configuredService.port ?? port,
+          });
+          return;
+        }
+      }
+
       // 动态导入服务注册装饰器（避免循环依赖）
       const { registerServiceInstance } = await import(
         '../microservice/service-registry/decorators'
@@ -456,7 +504,31 @@ export class Application {
    * 注销所有使用 @ServiceRegistry 装饰器的服务
    */
   private async deregisterServices(): Promise<void> {
+    if (ServiceRegistryModule.autoRegister === false) {
+      return;
+    }
     try {
+      const configuredService = ServiceRegistryModule.autoRegisterService;
+      if (configuredService) {
+        const { SERVICE_REGISTRY_TOKEN } = await import(
+          '../microservice/service-registry/types'
+        );
+        const container = this.getContainer();
+        if (container.isRegistered(SERVICE_REGISTRY_TOKEN)) {
+          const registry = container.resolve<any>(SERVICE_REGISTRY_TOKEN);
+          await registry.deregister({
+            serviceName: configuredService.serviceName,
+            ip:
+              configuredService.ip ??
+              this.server?.getHostname() ??
+              this.options.hostname ??
+              '127.0.0.1',
+            port: configuredService.port ?? this.server?.getPort() ?? this.options.port ?? 3000,
+          });
+          return;
+        }
+      }
+
       // 动态导入服务注册装饰器（避免循环依赖）
       const { deregisterServiceInstance } = await import(
         '../microservice/service-registry/decorators'

package/src/core/server.ts

@@ -41,6 +41,12 @@ export interface ServerOptions {
    * @default false
    */
   reusePort?: boolean;
+
+  /**
+   * 连接空闲超时时间（毫秒）
+   * 框架内部会转换为 Bun.serve 所需的秒
+   */
+  idleTimeout?: number;
 }
 
 /**
@@ -161,6 +167,10 @@ export class BunServer {
         port: this.options.port ?? 3000,
         hostname: this.options.hostname,
         reusePort: this.options.reusePort,
+        idleTimeout:
+          typeof this.options.idleTimeout === 'number'
+            ? Math.max(0, Math.ceil(this.options.idleTimeout / 1000))
+            : undefined,
         fetch: fetchHandler,
         websocket: websocketHandlers,
       });

package/src/database/database-context.ts

@@ -0,0 +1,43 @@
+import { AsyncLocalStorage } from 'node:async_hooks';
+
+import type { TransactionStatus } from './orm/transaction-types';
+import type { SqliteAdapter } from './sqlite-adapter';
+
+export type SqlTemplateCall = (
+  strings: TemplateStringsArray,
+  ...values: unknown[]
+) => Promise<unknown>;
+
+export interface ReservedSqlSession extends SqlTemplateCall {
+  begin<T>(fn: () => Promise<T>): Promise<T>;
+  release(): Promise<void> | void;
+}
+
+export interface TransactionState {
+  id: string;
+  status: TransactionStatus;
+  level: number;
+  savepoints: string[];
+}
+
+export interface DatabaseSession {
+  reserved?: ReservedSqlSession;
+  sqlite?: SqliteAdapter;
+  tenantId: string;
+  transaction?: TransactionState;
+  lazyReserve?: () => Promise<ReservedSqlSession>;
+}
+
+export const databaseSessionStore = new AsyncLocalStorage<DatabaseSession>();
+
+export function getCurrentSession(): DatabaseSession | undefined {
+  return databaseSessionStore.getStore();
+}
+
+export function runWithSession<T>(
+  session: DatabaseSession,
+  fn: () => Promise<T>,
+): Promise<T> {
+  return databaseSessionStore.run(session, fn);
+}
+

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