@dangao/bun-server 2.0.8 → 2.1.0

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

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/module-registry.ts

@@ -229,18 +229,34 @@ export class ModuleRegistry {
    */
   public resolveAllProviderInstances(): 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)

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';
@@ -307,16 +307,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 +497,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,
+    );
   }
 
   /**

package/src/router/route.ts

@@ -3,6 +3,7 @@ import type { Constructor } from '../core/types';
 import type { HttpMethod, RouteHandler, RouteMatch } from './types';
 import { MiddlewarePipeline } from '../middleware/pipeline';
 import type { Middleware } from '../middleware';
+import { HttpException } from '../error';
 
 /**
  * 路由类
@@ -47,6 +48,7 @@ export class Route {
   private readonly middlewarePipeline: MiddlewarePipeline | null;
   private readonly staticKey?: string;
   public readonly isStatic: boolean;
+  private readonly timeout?: number;
 
   public constructor(
     method: HttpMethod,
@@ -55,12 +57,14 @@ export class Route {
     middlewares: Middleware[] = [],
     controllerClass?: Constructor<unknown>,
     methodName?: string,
+    timeout?: number,
   ) {
     this.method = method;
     this.path = path;
     this.handler = handler;
     this.controllerClass = controllerClass;
     this.methodName = methodName;
+    this.timeout = timeout;
 
     this.isStatic = !path.includes(':') && !path.includes('*');
     if (this.isStatic) {
@@ -124,11 +128,35 @@ export class Route {
    * @returns 响应对象
    */
   public async execute(context: Context): Promise<Response> {
-    if (!this.middlewarePipeline || !this.middlewarePipeline.hasMiddlewares()) {
-      return await this.handler(context);
+    const executeHandler = async (): Promise<Response> => {
+      if (!this.middlewarePipeline || !this.middlewarePipeline.hasMiddlewares()) {
+        return await this.handler(context);
+      }
+      return await this.middlewarePipeline.run(
+        context,
+        async () => await this.handler(context),
+      );
+    };
+
+    if (!this.timeout || this.timeout <= 0) {
+      return await executeHandler();
     }
 
-    return await this.middlewarePipeline.run(context, async () => this.handler(context));
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    const timeoutPromise = new Promise<Response>((_, reject) => {
+      timer = setTimeout(
+        () => reject(new HttpException(408, 'Request Timeout')),
+        this.timeout,
+      );
+    });
+
+    try {
+      return await Promise.race([executeHandler(), timeoutPromise]);
+    } finally {
+      if (timer) {
+        clearTimeout(timer);
+      }
+    }
   }
 
   /**

package/src/router/router.ts

@@ -49,10 +49,19 @@ export class Router {
     middlewares: Middleware[] = [],
     controllerClass?: Constructor<unknown>,
     methodName?: string,
+    timeout?: number,
   ): void {
     // 规范化路径
     const normalizedPath = this.normalizePath(path);
-    const route = new Route(method, normalizedPath, handler, middlewares, controllerClass, methodName);
+    const route = new Route(
+      method,
+      normalizedPath,
+      handler,
+      middlewares,
+      controllerClass,
+      methodName,
+      timeout,
+    );
     this.routes.push(route);
     const staticKey = route.getStaticKey();
     if (staticKey) {

package/src/router/timeout-decorator.ts

@@ -0,0 +1,35 @@
+import 'reflect-metadata';
+
+import type { Constructor } from '../core/types';
+
+export const IDLE_TIMEOUT_KEY = Symbol('@dangao/bun-server:route:idle-timeout');
+
+export function IdleTimeout(ms: number): MethodDecorator & ClassDecorator {
+  return (target: object, propertyKey?: string | symbol) => {
+    if (propertyKey !== undefined) {
+      Reflect.defineMetadata(IDLE_TIMEOUT_KEY, ms, target, propertyKey);
+      return;
+    }
+    Reflect.defineMetadata(IDLE_TIMEOUT_KEY, ms, target);
+  };
+}
+
+export function getIdleTimeout(
+  controllerClass: Constructor<unknown>,
+  methodName: string,
+): number | undefined {
+  const methodTimeout = Reflect.getMetadata(
+    IDLE_TIMEOUT_KEY,
+    controllerClass.prototype,
+    methodName,
+  ) as number | undefined;
+  if (typeof methodTimeout === 'number') {
+    return methodTimeout;
+  }
+  const classTimeout = Reflect.getMetadata(
+    IDLE_TIMEOUT_KEY,
+    controllerClass,
+  ) as number | undefined;
+  return typeof classTimeout === 'number' ? classTimeout : undefined;
+}
+