@dangao/bun-server 2.0.8 → 2.2.0

package/src/database/types.ts

@@ -78,6 +78,59 @@ export type DatabaseConfig =
   | { type: 'postgres'; config: PostgresConfig }
   | { type: 'mysql'; config: MysqlConfig };
 
+/**
+ * Bun.SQL 连接池配置
+ */
+export interface BunSQLPoolOptions {
+  /**
+   * 最大物理连接数
+   * @default 10
+   */
+  max?: number;
+  /**
+   * 空闲连接超时（秒）
+   * @default 30
+   */
+  idleTimeout?: number;
+  /**
+   * 连接最大生存时间（秒）
+   * @default 0
+   */
+  maxLifetime?: number;
+  /**
+   * 获取连接超时（毫秒）
+   * @default 30000
+   */
+  connectionTimeout?: number;
+}
+
+/**
+ * Bun.SQL 配置（Postgres/MySQL）
+ */
+export interface BunSQLConfig {
+  type: 'postgres' | 'mysql';
+  url: string;
+  pool?: BunSQLPoolOptions;
+}
+
+/**
+ * SQLite V2 配置
+ */
+export interface SqliteV2Config {
+  type: 'sqlite';
+  database: string;
+  wal?: boolean;
+  maxWriteConcurrency?: number;
+}
+
+/**
+ * 多租户配置
+ */
+export interface TenantConfig {
+  id: string;
+  config: BunSQLConfig | SqliteV2Config;
+}
+
 /**
  * 连接池配置
  */
@@ -108,12 +161,59 @@ export interface ConnectionPoolOptions {
  * DatabaseModule 配置选项
  */
 export interface DatabaseModuleOptions {
+  /**
+   * 全局默认连接策略
+   * - pool: 每次查询走共享池（默认）
+   * - session: 首次查询惰性 reserve，整个请求复用同一连接
+   * @default "pool"
+   */
+  defaultStrategy?: 'pool' | 'session';
+
+  /**
+   * 多租户配置
+   */
+  tenants?: TenantConfig[];
+  /**
+   * 默认租户 ID
+   * @default "default"
+   */
+  defaultTenant?: string;
+
+  /**
+   * 单租户：数据库类型（V2）
+   */
+  type?: DatabaseType;
+  /**
+   * 单租户：Postgres/MySQL URL（V2）
+   */
+  url?: string;
+  /**
+   * 单租户：SQLite 文件路径（V2）
+   */
+  databasePath?: string;
+  /**
+   * 单租户：SQLite WAL 模式
+   * @default true
+   */
+  wal?: boolean;
+  /**
+   * 单租户：SQLite 最大写并发
+   * @default 1
+   */
+  maxWriteConcurrency?: number;
+  /**
+   * Bun.SQL 连接池参数（V2）
+   */
+  bunSqlPool?: BunSQLPoolOptions;
+
   /**
    * 数据库配置
+   * @deprecated 使用 V2 字段（type/url/databasePath）或 tenants
    */
-  database: DatabaseConfig;
+  database?: DatabaseConfig;
   /**
    * 连接池配置
+   * @deprecated 旧连接池配置，仅用于兼容旧 DatabaseService
    */
   pool?: ConnectionPoolOptions;
   /**
@@ -135,6 +235,23 @@ export interface DatabaseModuleOptions {
      */
     drizzle?: unknown;
   };
+
+  /**
+   * @deprecated 旧字段兼容（用于构造 URL）
+   */
+  host?: string;
+  /**
+   * @deprecated 旧字段兼容（用于构造 URL）
+   */
+  port?: number;
+  /**
+   * @deprecated 旧字段兼容（用于构造 URL）
+   */
+  username?: string;
+  /**
+   * @deprecated 旧字段兼容（用于构造 URL）
+   */
+  password?: string;
 }
 
 /**
@@ -169,3 +286,18 @@ export const DATABASE_SERVICE_TOKEN = Symbol('@dangao/bun-server:database:servic
  * DatabaseModule Options Token
  */
 export const DATABASE_OPTIONS_TOKEN = Symbol('@dangao/bun-server:database:options');
+
+/**
+ * BunSQLManager Token
+ */
+export const BUN_SQL_MANAGER_TOKEN = Symbol('@dangao/bun-server:database:bun-sql-manager');
+
+/**
+ * SQLite manager Token
+ */
+export const SQLITE_MANAGER_TOKEN = Symbol('@dangao/bun-server:database:sqlite-manager');
+
+/**
+ * db proxy Token
+ */
+export const DB_TOKEN = Symbol('@dangao/bun-server:database:db');

package/src/di/container.ts

@@ -14,6 +14,13 @@ import {
 import { LoggerManager } from "@dangao/logsmith";
 import type { Constructor } from "@/core/types";
 import { contextStore } from "../core/context-service";
+import {
+  callComponentBeforeCreate,
+  callOnAfterCreate,
+  callOnBeforeDestroy,
+  callOnModuleDestroy,
+  callOnAfterDestroy,
+} from "./lifecycle";
 
 /**
  * 依赖注入容器
@@ -365,6 +372,7 @@ export class Container {
    * @returns 实例
    */
   private instantiate<T>(constructor: Constructor<T>): T {
+    callComponentBeforeCreate(constructor);
     const plan = this.getDependencyPlan(constructor);
 
     let instance: T;
@@ -379,7 +387,9 @@ export class Container {
     }
 
     // 应用后处理器
-    return this.applyPostProcessors(instance, constructor);
+    const processed = this.applyPostProcessors(instance, constructor);
+    callOnAfterCreate(processed);
+    return processed;
   }
 
   /**
@@ -409,6 +419,50 @@ export class Container {
     // scopedInstances 使用 WeakMap，当 Context 对象被 GC 时会自动清理
   }
 
+  /**
+   * 获取指定请求上下文下的 scoped 实例
+   * @param context - 请求上下文对象
+   * @returns 去重后的 scoped 实例列表
+   */
+  public getScopedInstances(context: object): unknown[] {
+    const scopedMap = this.scopedInstances.get(context);
+    if (!scopedMap || scopedMap.size === 0) {
+      return [];
+    }
+    const seen = new Set<unknown>();
+    const instances: unknown[] = [];
+    for (const instance of scopedMap.values()) {
+      if (!seen.has(instance)) {
+        seen.add(instance);
+        instances.push(instance);
+      }
+    }
+    return instances;
+  }
+
+  /**
+   * 清理指定请求上下文的 scoped 实例缓存
+   * @param context - 请求上下文对象
+   */
+  public clearScopedInstances(context: object): void {
+    this.scopedInstances.delete(context);
+  }
+
+  /**
+   * 触发指定请求上下文下 scoped 实例的销毁钩子并清理缓存
+   * @param context - 请求上下文对象
+   */
+  public async disposeScopedInstances(context: object): Promise<void> {
+    const instances = this.getScopedInstances(context);
+    if (instances.length === 0) {
+      return;
+    }
+    await callOnBeforeDestroy(instances);
+    await callOnModuleDestroy(instances);
+    await callOnAfterDestroy(instances);
+    this.clearScopedInstances(context);
+  }
+
   /**
    * 检查是否已注册
    * @param token - 提供者标识符

package/src/di/lifecycle.ts

@@ -30,6 +30,38 @@ export interface OnApplicationShutdown {
   onApplicationShutdown(signal?: string): Promise<void> | void;
 }
 
+/**
+ * 组件创建前钩子（静态类方法）
+ * 在实例化前调用，适用于 Controller / Injectable 类
+ */
+export type ComponentClassBeforeCreate = {
+  onBeforeCreate(): void;
+};
+
+/**
+ * 组件创建后钩子（实例）
+ * 在实例化并完成后处理后调用
+ */
+export interface OnAfterCreate {
+  onAfterCreate(): void;
+}
+
+/**
+ * 组件销毁前钩子（实例）
+ * 在 onModuleDestroy 之前调用（反向顺序）
+ */
+export interface OnBeforeDestroy {
+  onBeforeDestroy(): Promise<void> | void;
+}
+
+/**
+ * 组件销毁后钩子（实例）
+ * 在 onModuleDestroy 之后调用（反向顺序）
+ */
+export interface OnAfterDestroy {
+  onAfterDestroy(): Promise<void> | void;
+}
+
 export function hasOnModuleInit(instance: unknown): instance is OnModuleInit {
   return (
     instance !== null &&
@@ -70,6 +102,64 @@ export function hasOnApplicationShutdown(instance: unknown): instance is OnAppli
   );
 }
 
+export function hasComponentBeforeCreate(target: unknown): target is ComponentClassBeforeCreate {
+  return (
+    target !== null &&
+    target !== undefined &&
+    typeof target === 'function' &&
+    'onBeforeCreate' in target &&
+    typeof (target as ComponentClassBeforeCreate).onBeforeCreate === 'function'
+  );
+}
+
+export function hasOnAfterCreate(instance: unknown): instance is OnAfterCreate {
+  return (
+    instance !== null &&
+    instance !== undefined &&
+    typeof instance === 'object' &&
+    'onAfterCreate' in instance &&
+    typeof (instance as OnAfterCreate).onAfterCreate === 'function'
+  );
+}
+
+export function hasOnBeforeDestroy(instance: unknown): instance is OnBeforeDestroy {
+  return (
+    instance !== null &&
+    instance !== undefined &&
+    typeof instance === 'object' &&
+    'onBeforeDestroy' in instance &&
+    typeof (instance as OnBeforeDestroy).onBeforeDestroy === 'function'
+  );
+}
+
+export function hasOnAfterDestroy(instance: unknown): instance is OnAfterDestroy {
+  return (
+    instance !== null &&
+    instance !== undefined &&
+    typeof instance === 'object' &&
+    'onAfterDestroy' in instance &&
+    typeof (instance as OnAfterDestroy).onAfterDestroy === 'function'
+  );
+}
+
+/**
+ * 调用组件类静态 onBeforeCreate
+ */
+export function callComponentBeforeCreate(target: unknown): void {
+  if (hasComponentBeforeCreate(target)) {
+    target.onBeforeCreate();
+  }
+}
+
+/**
+ * 调用组件实例 onAfterCreate
+ */
+export function callOnAfterCreate(instance: unknown): void {
+  if (hasOnAfterCreate(instance)) {
+    instance.onAfterCreate();
+  }
+}
+
 /**
  * 按顺序调用 onModuleInit
  */
@@ -115,3 +205,27 @@ export async function callOnApplicationShutdown(instances: unknown[], signal?: s
     }
   }
 }
+
+/**
+ * 按反向顺序调用 onBeforeDestroy
+ */
+export async function callOnBeforeDestroy(instances: unknown[]): Promise<void> {
+  for (let i = instances.length - 1; i >= 0; i--) {
+    const instance = instances[i];
+    if (hasOnBeforeDestroy(instance)) {
+      await instance.onBeforeDestroy();
+    }
+  }
+}
+
+/**
+ * 按反向顺序调用 onAfterDestroy
+ */
+export async function callOnAfterDestroy(instances: unknown[]): Promise<void> {
+  for (let i = instances.length - 1; i >= 0; i--) {
+    const instance = instances[i];
+    if (hasOnAfterDestroy(instance)) {
+      await instance.onAfterDestroy();
+    }
+  }
+}

package/src/di/module-registry.ts

@@ -11,6 +11,8 @@ import {
   callOnModuleDestroy,
   callOnApplicationBootstrap,
   callOnApplicationShutdown,
+  callOnBeforeDestroy,
+  callOnAfterDestroy,
 } from './lifecycle';
 
 interface ModuleRef {
@@ -225,63 +227,125 @@ export class ModuleRegistry {
   }
 
   /**
-   * 解析所有模块中的 provider 实例，用于生命周期钩子调用
+   * 解析所有模块中的组件实例（providers + controllers），用于生命周期钩子调用
    */
-  public resolveAllProviderInstances(): unknown[] {
+  public resolveAllComponentInstances(): unknown[] {
     const instances: unknown[] = [];
+    const seen = new Set<unknown>();
     for (const [, ref] of this.moduleRefs) {
       for (const provider of ref.metadata.providers) {
         try {
           if (typeof provider === 'function') {
-            instances.push(ref.container.resolve(provider));
+            const instance = ref.container.resolve(provider);
+            if (!seen.has(instance)) {
+              seen.add(instance);
+              instances.push(instance);
+            }
           } else if ('useClass' in provider) {
             const token = provider.provide ?? provider.useClass;
-            instances.push(ref.container.resolve(token as Constructor<unknown>));
+            const instance = ref.container.resolve(token as Constructor<unknown>);
+            if (!seen.has(instance)) {
+              seen.add(instance);
+              instances.push(instance);
+            }
           } else if ('useValue' in provider) {
-            instances.push(provider.useValue);
+            if (!seen.has(provider.useValue)) {
+              seen.add(provider.useValue);
+              instances.push(provider.useValue);
+            }
           } else if ('useFactory' in provider) {
-            instances.push(ref.container.resolve(provider.provide as Constructor<unknown>));
+            const instance = ref.container.resolve(provider.provide as Constructor<unknown>);
+            if (!seen.has(instance)) {
+              seen.add(instance);
+              instances.push(instance);
+            }
           }
         } catch (_error) {
           // skip providers that can't be resolved (e.g. pending async providers)
         }
       }
+      for (const controller of ref.metadata.controllers) {
+        try {
+          const instance = ref.container.resolve(controller);
+          if (!seen.has(instance)) {
+            seen.add(instance);
+            instances.push(instance);
+          }
+        } catch (_error) {
+          // skip controllers that can't be resolved
+        }
+      }
     }
     return instances;
   }
 
   /**
-   * 调用所有 provider 的 onModuleInit 钩子
+   * 调用所有组件（providers + controllers）的 onModuleInit 钩子
    */
   public async callModuleInitHooks(): Promise<void> {
-    const instances = this.resolveAllProviderInstances();
+    const instances = this.resolveAllComponentInstances();
     await callOnModuleInit(instances);
   }
 
   /**
-   * 调用所有 provider 的 onApplicationBootstrap 钩子
+   * 调用所有组件（providers + controllers）的 onApplicationBootstrap 钩子
    */
   public async callBootstrapHooks(): Promise<void> {
-    const instances = this.resolveAllProviderInstances();
+    const instances = this.resolveAllComponentInstances();
     await callOnApplicationBootstrap(instances);
   }
 
   /**
-   * 调用所有 provider 的 onModuleDestroy 钩子
+   * 调用所有组件（providers + controllers）的 onModuleDestroy 钩子
    */
   public async callModuleDestroyHooks(): Promise<void> {
-    const instances = this.resolveAllProviderInstances();
+    const instances = this.resolveAllComponentInstances();
+    await callOnBeforeDestroy(instances);
     await callOnModuleDestroy(instances);
+    await callOnAfterDestroy(instances);
   }
 
   /**
-   * 调用所有 provider 的 onApplicationShutdown 钩子
+   * 调用所有组件（providers + controllers）的 onApplicationShutdown 钩子
    */
   public async callShutdownHooks(signal?: string): Promise<void> {
-    const instances = this.resolveAllProviderInstances();
+    const instances = this.resolveAllComponentInstances();
     await callOnApplicationShutdown(instances, signal);
   }
 
+  /**
+   * 调用当前请求上下文下 scoped 组件的销毁钩子并清理缓存
+   */
+  public async disposeScopedInstances(context: object): Promise<void> {
+    const containers: Container[] = [];
+    if (this.rootContainer) {
+      containers.push(this.rootContainer);
+    }
+    containers.push(...this.getAllModuleContainers());
+
+    const instances: unknown[] = [];
+    const seen = new Set<unknown>();
+    for (const container of containers) {
+      const scopedInstances = container.getScopedInstances(context);
+      for (const instance of scopedInstances) {
+        if (!seen.has(instance)) {
+          seen.add(instance);
+          instances.push(instance);
+        }
+      }
+    }
+
+    if (instances.length > 0) {
+      await callOnBeforeDestroy(instances);
+      await callOnModuleDestroy(instances);
+      await callOnAfterDestroy(instances);
+    }
+
+    for (const container of containers) {
+      container.clearScopedInstances(context);
+    }
+  }
+
   private registerExport(parentContainer: Container, moduleRef: ModuleRef, token: ProviderToken): void {
     if (!moduleRef.container.isRegistered(token)) {
       throw new Error(

package/src/index.ts

@@ -4,7 +4,7 @@ export { BunServer, type ServerOptions } from './core/server';
 export { ClusterManager, type ClusterOptions, type ClusterMode } from './core/cluster';
 export { Context } from './core/context';
 export { ContextService, CONTEXT_SERVICE_TOKEN, contextStore } from './core/context-service';
-export { Route, Router, RouteRegistry } from './router';
+export { Route, Router, RouteRegistry, IdleTimeout } from './router';
 export { GET, POST, PUT, DELETE, PATCH } from './router/decorators';
 export type { HttpMethod, RouteHandler, RouteMatch } from './router/types';
 export { BodyParser, RequestWrapper, ResponseBuilder } from './request';
@@ -42,6 +42,10 @@ export type {
   OnModuleDestroy,
   OnApplicationBootstrap,
   OnApplicationShutdown,
+  ComponentClassBeforeCreate,
+  OnAfterCreate,
+  OnBeforeDestroy,
+  OnAfterDestroy,
 } from './di/lifecycle';
 export {
   InterceptorRegistry,
@@ -307,16 +311,41 @@ export {
   ConnectionPool,
   DatabaseHealthIndicator,
   DatabaseExtension,
+  BunSQLManager,
+  SqliteAdapter,
+  SqliteManager,
+  Semaphore,
+  db,
+  initDbProxy,
+  DbStrategy,
+  DbSession,
+  DB_STRATEGY_KEY,
+  getDbStrategy,
+  databaseSessionStore,
+  getCurrentSession,
+  runWithSession,
   DATABASE_SERVICE_TOKEN,
   DATABASE_OPTIONS_TOKEN,
+  BUN_SQL_MANAGER_TOKEN,
+  SQLITE_MANAGER_TOKEN,
+  DB_TOKEN,
   type DatabaseModuleOptions,
   type DatabaseConfig,
   type DatabaseType,
   type ConnectionInfo,
   type ConnectionPoolOptions,
+  type BunSQLConfig,
+  type BunSQLPoolOptions,
   type SqliteConfig,
+  type SqliteV2Config,
   type PostgresConfig,
   type MysqlConfig,
+  type TenantConfig,
+  type DbStrategyType,
+  type DbProxy,
+  type DatabaseSession,
+  type TransactionState as DatabaseTransactionState,
+  type ReservedSqlSession,
   // ORM exports
   Entity,
   Column,
@@ -472,6 +501,7 @@ export {
 } from './microservice';
 export {
   ServiceRegistryModule,
+  ServiceRegistryDecorator,
   NacosServiceRegistry,
   SERVICE_REGISTRY_TOKEN,
   type ServiceRegistryModuleOptions,

package/src/microservice/service-registry/service-registry-module.ts

@@ -2,7 +2,11 @@ import { Module, MODULE_METADATA_KEY, type ModuleProvider } from '../../di/modul
 import { NacosClient } from '@dangao/nacos-client';
 import type { NacosClientOptions } from '@dangao/nacos-client';
 import { NacosServiceRegistry } from './nacos-service-registry';
-import { SERVICE_REGISTRY_TOKEN, type ServiceRegistry } from './types';
+import {
+  SERVICE_REGISTRY_TOKEN,
+  type ServiceRegistry,
+  type ServiceInstance,
+} from './types';
 
 /**
  * 服务注册中心 Provider 类型
@@ -45,6 +49,21 @@ export interface ServiceRegistryModuleOptions {
    */
   nacos?: NacosServiceRegistryOptions;
 
+  /**
+   * 是否自动在 Application.listen 时注册带 @ServiceRegistry 的服务
+   * @default true
+   */
+  autoRegister?: boolean;
+
+  /**
+   * 通过模块配置自动注册服务（无需 @ServiceRegistry 装饰器）
+   * 当 autoRegister=true 时在 Application.listen 阶段自动注册
+   */
+  autoRegisterService?: Omit<ServiceInstance, 'ip' | 'port'> & {
+    ip?: string;
+    port?: number;
+  };
+
   // 未来可以添加其他 provider 的配置
   // consul?: ConsulServiceRegistryOptions;
   // eureka?: EurekaServiceRegistryOptions;
@@ -57,11 +76,16 @@ export interface ServiceRegistryModuleOptions {
   providers: [],
 })
 export class ServiceRegistryModule {
+  public static autoRegister = true;
+  public static autoRegisterService: ServiceRegistryModuleOptions['autoRegisterService'];
+
   /**
    * 创建服务注册中心模块
    * @param options - 模块配置
    */
   public static forRoot(options: ServiceRegistryModuleOptions): typeof ServiceRegistryModule {
+    ServiceRegistryModule.autoRegister = options.autoRegister ?? true;
+    ServiceRegistryModule.autoRegisterService = options.autoRegisterService;
     const providers: ModuleProvider[] = [];
 
     let serviceRegistry: ServiceRegistry;

package/src/router/index.ts

@@ -2,5 +2,6 @@ export { Route } from './route';
 export { Router } from './router';
 export { RouteRegistry } from './registry';
 export { GET, POST, PUT, DELETE, PATCH } from './decorators';
+export { IdleTimeout, IDLE_TIMEOUT_KEY, getIdleTimeout } from './timeout-decorator';
 export type { HttpMethod, RouteHandler, RouteMatch } from './types';
 

package/src/router/registry.ts

@@ -42,8 +42,17 @@ export class RouteRegistry {
     middlewares: Middleware[] = [],
     controllerClass?: Constructor<unknown>,
     methodName?: string,
+    timeout?: number,
   ): void {
-    this.router.register(method, path, handler, middlewares, controllerClass, methodName);
+    this.router.register(
+      method,
+      path,
+      handler,
+      middlewares,
+      controllerClass,
+      methodName,
+      timeout,
+    );
   }
 
   /**