@dangao/bun-server 3.1.0 → 3.3.0

package/dist/index.node.mjs

@@ -1125,8 +1125,9 @@ var init_http_exception = __esm(() => {
       this.messageParams = messageParams;
     }
     static withCode(code, message, details, messageParams) {
-      const status = ERROR_CODE_TO_STATUS[code] || 500;
-      const finalMessage = message || ERROR_CODE_MESSAGES[code] || "Internal Server Error";
+      const knownCode = code;
+      const status = ERROR_CODE_TO_STATUS[knownCode] || 500;
+      const finalMessage = message || ERROR_CODE_MESSAGES[knownCode] || "Internal Server Error";
       return new HttpException(status, finalMessage, details, code, messageParams);
     }
   };
@@ -2150,7 +2151,7 @@ async function handleError(error, context) {
       });
     }
     let errorMessage = error.message;
-    if (error.code) {
+    if (error.code && error.code in ERROR_CODE_MESSAGES) {
       const acceptLanguage = context.getHeader("accept-language");
       const language = ErrorMessageI18n.parseLanguageFromHeader(acceptLanguage);
       errorMessage = ErrorMessageI18n.getMessage(error.code, language, error.messageParams);
@@ -2192,6 +2193,7 @@ var init_handler = __esm(() => {
   init_http_exception();
   init_validation();
   init_i18n();
+  init_error_codes();
 });
 
 // src/error/index.ts
@@ -2572,7 +2574,8 @@ class Container {
   typeToToken = new Map;
   dependencyPlans = new Map;
   postProcessors = [];
-  register(token, config) {
+  register(token, configOrImplementation) {
+    const config = typeof configOrImplementation === "function" ? { implementation: configOrImplementation } : configOrImplementation;
     const tokenKey = this.getTokenKey(token);
     let lifecycle = config?.lifecycle;
     if (!lifecycle && typeof token === "function") {
@@ -3318,9 +3321,11 @@ function defaultKeyGenerator(context) {
 function createRateLimitMiddleware(options) {
   const {
     max,
+    limit,
     windowMs = 60000,
     store = new MemoryRateLimitStore,
     keyGenerator = defaultKeyGenerator,
+    skip,
     skipSuccessfulRequests = false,
     skipFailedRequests = false,
     message = "Too Many Requests",
@@ -3328,22 +3333,26 @@ function createRateLimitMiddleware(options) {
     standardHeaders = true,
     legacyHeaders = true
   } = options;
+  const requestLimit = limit ?? max ?? 100;
   return async (context, next) => {
+    if (skip && await skip(context)) {
+      return await next();
+    }
     const key = await keyGenerator(context);
     const currentCount = await store.increment(key, windowMs);
-    const remaining = Math.max(0, max - currentCount);
+    const remaining = Math.max(0, requestLimit - currentCount);
     const resetTime = Date.now() + windowMs;
     if (standardHeaders) {
-      context.setHeader("RateLimit-Limit", max.toString());
+      context.setHeader("RateLimit-Limit", requestLimit.toString());
       context.setHeader("RateLimit-Remaining", remaining.toString());
       context.setHeader("RateLimit-Reset", Math.ceil(resetTime / 1000).toString());
     }
     if (legacyHeaders) {
-      context.setHeader("X-RateLimit-Limit", max.toString());
+      context.setHeader("X-RateLimit-Limit", requestLimit.toString());
       context.setHeader("X-RateLimit-Remaining", remaining.toString());
       context.setHeader("X-RateLimit-Reset", Math.ceil(resetTime / 1000).toString());
     }
-    if (currentCount > max) {
+    if (currentCount > requestLimit) {
       context.setStatus(statusCode);
       return context.createErrorResponse({
         error: message,
@@ -3621,7 +3630,7 @@ var init_file_handler = __esm(() => {
 
 // src/middleware/builtin/file-upload.ts
 function createFileUploadMiddleware(options = {}) {
-  const maxSize = options.maxSize ?? 10 * 1024 * 1024;
+  const maxSize = options.maxSize ?? options.maxFileSize ?? 10 * 1024 * 1024;
   return async (context, next) => {
     const contentType = context.getHeader("Content-Type");
     if (!contentType || !contentType.includes("multipart/form-data")) {
@@ -3737,6 +3746,7 @@ var init_types3 = __esm(() => {
 class InterceptorRegistry {
   interceptors = new Map;
   register(metadataKey, interceptor, priority = 100) {
+    const resolvedPriority = typeof priority === "number" ? priority : priority.priority ?? 100;
     if (!this.interceptors.has(metadataKey)) {
       this.interceptors.set(metadataKey, []);
     }
@@ -3746,7 +3756,7 @@ class InterceptorRegistry {
       metadataList.push({
         metadataKey,
         interceptor,
-        priority
+        priority: resolvedPriority
       });
       metadataList.sort((a, b) => a.priority - b.priority);
     }
@@ -4044,6 +4054,13 @@ var init_logger_extension = __esm(() => {
 
 // src/di/module.ts
 import"reflect-metadata";
+function invokeFactoryProvider(provider, container) {
+  const inject = provider.inject ?? [];
+  if (inject.length > 0) {
+    return provider.useFactory(...inject.map((token) => container.resolve(token)));
+  }
+  return provider.useFactory(container);
+}
 function Module(metadata) {
   return (target) => {
     Reflect.defineMetadata(MODULE_METADATA_KEY, metadata, target);
@@ -4863,8 +4880,10 @@ class Context {
   _body;
   _bodyParsed = false;
   signal;
-  constructor(request) {
+  container;
+  constructor(request, container) {
     this.request = request;
+    this.container = container;
     this.url = new URL2(request.url);
     this.method = request.method;
     this.path = this.url.pathname;
@@ -5577,7 +5596,7 @@ class ModuleRegistry {
       if ("useFactory" in provider) {
         container.register(provider.provide, {
           lifecycle: provider.lifecycle ?? "singleton" /* Singleton */,
-          factory: () => provider.useFactory(container)
+          factory: () => invokeFactoryProvider(provider, container)
         });
         continue;
       }
@@ -5884,7 +5903,7 @@ class ConfigService {
     this.config = newConfig;
     for (const listener of this.configUpdateListeners) {
       try {
-        listener(newConfig);
+        listener(this.config);
       } catch (error) {
         console.error("[ConfigService] Error in config update listener:", error);
       }
@@ -6392,9 +6411,10 @@ class CacheService {
   defaultTtl;
   keyPrefix;
   constructor(options) {
-    this.store = options.store;
-    this.defaultTtl = options.defaultTtl ?? 3600000;
-    this.keyPrefix = options.keyPrefix ?? "";
+    const resolvedOptions = isCacheStore(options) ? { store: options } : options;
+    this.store = resolvedOptions.store;
+    this.defaultTtl = resolvedOptions.defaultTtl ?? 3600000;
+    this.keyPrefix = resolvedOptions.keyPrefix ?? "";
   }
   async get(key) {
     return this.store.get(this.getKey(key));
@@ -6451,9 +6471,12 @@ CacheService = __legacyDecorateClassTS([
   Injectable(),
   __legacyDecorateParamTS(0, Inject(CACHE_OPTIONS_TOKEN)),
   __legacyMetadataTS("design:paramtypes", [
-    typeof CacheModuleOptions === "undefined" ? Object : CacheModuleOptions
+    Object
   ])
 ], CacheService);
+function isCacheStore(value) {
+  return typeof value.get === "function" && typeof value.set === "function" && typeof value.delete === "function";
+}
 
 // src/cache/service-proxy.ts
 import"reflect-metadata";
@@ -6997,6 +7020,8 @@ class EventEmitterService {
   handleError(error, event, payload) {
     if (this.options.onError) {
       this.options.onError(error, event, payload);
+    } else if (this.options.errorHandler) {
+      this.options.errorHandler(String(event), error, payload);
     } else {
       console.error(`[EventEmitter] Error in listener for event "${String(event)}":`, error);
     }
@@ -7641,6 +7666,9 @@ class Application {
   getServer() {
     return this.server;
   }
+  getNativeServer() {
+    return this.server?.getNativeServer();
+  }
   async registerServices(port, hostname) {
     if (ServiceRegistryModule.autoRegister === false) {
       return;
@@ -8141,11 +8169,17 @@ function ApiOperation(metadata) {
   };
 }
 function ApiParam(metadata) {
-  return function(target, propertyKey, parameterIndex) {
+  const decorator = (target, propertyKey, descriptorOrParameterIndex) => {
+    const paramMetadata = {
+      in: "path",
+      ...metadata
+    };
     const existingParams = Reflect.getMetadata(API_PARAM_METADATA_KEY, target, propertyKey) || [];
-    existingParams.push({ index: parameterIndex, metadata });
+    const index = typeof descriptorOrParameterIndex === "number" ? descriptorOrParameterIndex : -1;
+    existingParams.push({ index, metadata: paramMetadata });
     Reflect.defineMetadata(API_PARAM_METADATA_KEY, existingParams, target, propertyKey);
   };
+  return decorator;
 }
 function ApiBody(metadata) {
   return function(target, propertyKey) {
@@ -8262,7 +8296,7 @@ class SwaggerGenerator {
         const pathParamMatches = fullPath.matchAll(/\{([^}]+)\}/g);
         for (const match of pathParamMatches) {
           const paramName = match[1];
-          const existingParam = params.find((p) => p.metadata.name === paramName && p.metadata.in === "path");
+          const existingParam = params.find((p) => p.metadata.name === paramName && (p.metadata.in ?? "path") === "path");
           if (!existingParam) {
             pathParams.push({
               name: paramName,
@@ -8275,7 +8309,7 @@ class SwaggerGenerator {
         for (const param of params) {
           pathParams.push({
             name: param.metadata.name,
-            in: param.metadata.in,
+            in: param.metadata.in ?? "path",
             description: param.metadata.description,
             required: param.metadata.required,
             schema: param.metadata.schema
@@ -10865,6 +10899,197 @@ init_decorators();
 // src/database/connection-pool.ts
 init_runtime();
 
+// src/database/driver.ts
+var DRIVER_TAG = Symbol.for("@dangao/bun-server:database:driver");
+function resolveDriver(dbType, option, engine) {
+  const driver = option ?? "auto";
+  switch (driver) {
+    case "auto":
+      if (engine === "bun") {
+        return "bun-sql";
+      }
+      return dbType === "mysql" ? "mysql2" : "postgres";
+    case "bun-sql":
+      if (engine !== "bun") {
+        throw new Error(`[bun-server] driver 'bun-sql' requires the Bun runtime, but the current platform engine is '${engine}'. ` + `Use driver 'auto' / 'mysql2' / 'postgres', or run on Bun.`);
+      }
+      return "bun-sql";
+    case "mysql2":
+      if (dbType !== "mysql") {
+        throw new Error(`[bun-server] driver 'mysql2' is only valid for type 'mysql', but got type '${dbType}'.`);
+      }
+      return "mysql2";
+    case "postgres":
+      if (dbType !== "postgres") {
+        throw new Error(`[bun-server] driver 'postgres' is only valid for type 'postgres', but got type '${dbType}'.`);
+      }
+      return "postgres";
+    default:
+      throw new Error(`[bun-server] unknown driver '${String(driver)}'.`);
+  }
+}
+function tagConnection(connection, driver) {
+  if (connection && (typeof connection === "object" || typeof connection === "function")) {
+    try {
+      Object.defineProperty(connection, DRIVER_TAG, {
+        value: driver,
+        enumerable: false,
+        configurable: true,
+        writable: true
+      });
+    } catch {}
+  }
+  return connection;
+}
+function getConnectionDriver(connection) {
+  if (!connection) {
+    return;
+  }
+  if (typeof connection === "object" || typeof connection === "function") {
+    const tagged = connection[DRIVER_TAG];
+    if (tagged === "bun-sql" || tagged === "mysql2" || tagged === "postgres") {
+      return tagged;
+    }
+  }
+  if (typeof connection === "function") {
+    return "bun-sql";
+  }
+  return;
+}
+async function createPostgresConnection(config, driver) {
+  const url = `postgres://${config.user}:${config.password}@${config.host}:${config.port}/${config.database}`;
+  if (driver === "bun-sql") {
+    const { SQL } = await import("bun");
+    return tagConnection(new SQL({
+      adapter: "postgres",
+      hostname: config.host,
+      port: config.port,
+      username: config.user,
+      password: config.password,
+      database: config.database,
+      max: 1,
+      tls: config.ssl ?? false
+    }), "bun-sql");
+  }
+  if (driver === "postgres") {
+    const postgres = loadPostgres();
+    return tagConnection(postgres(url, { max: 1, ssl: config.ssl ? "require" : false }), "postgres");
+  }
+  throw new Error(`[bun-server] driver '${driver}' cannot create a postgres connection.`);
+}
+async function createMysqlConnection(config, driver) {
+  if (driver === "bun-sql") {
+    const { SQL } = await import("bun");
+    return tagConnection(new SQL({
+      adapter: "mysql",
+      hostname: config.host,
+      port: config.port,
+      username: config.user,
+      password: config.password,
+      database: config.database,
+      max: 1,
+      ssl: config.ssl ?? false
+    }), "bun-sql");
+  }
+  if (driver === "mysql2") {
+    const mysql2 = loadMysql2();
+    const conn = await mysql2.createConnection({
+      host: config.host,
+      port: config.port,
+      database: config.database,
+      user: config.user,
+      password: config.password
+    });
+    return tagConnection(conn, "mysql2");
+  }
+  throw new Error(`[bun-server] driver '${driver}' cannot create a mysql connection.`);
+}
+async function queryViaDriver(connection, sql, params) {
+  const driver = getConnectionDriver(connection);
+  if (driver === "mysql2") {
+    const conn = connection;
+    const [rows] = await conn.query(sql, params ?? []);
+    return rows ?? [];
+  }
+  if (driver === "postgres") {
+    const conn = connection;
+    const rows = await conn.unsafe(sql, params ?? []);
+    return rows ?? [];
+  }
+  if (typeof connection === "function") {
+    const { strings, values } = buildTemplateFromSql(sql, params);
+    const template = Object.assign(strings.slice(), {
+      raw: strings.slice()
+    });
+    const result = await connection(template, ...values);
+    return result;
+  }
+  if (connection && typeof connection === "object" && "query" in connection && typeof connection.query === "function") {
+    const result = await connection.query(sql, params ?? []);
+    return Array.isArray(result) ? result[0] : result;
+  }
+  throw new Error("[bun-server] invalid SQL connection for query.");
+}
+async function templateQueryViaDriver(connection, strings, values) {
+  const driver = getConnectionDriver(connection);
+  if (driver === "mysql2") {
+    const sql = strings.join("?");
+    const conn = connection;
+    const [rows] = await conn.query(sql, values);
+    return rows;
+  }
+  return await connection(strings, ...values);
+}
+async function healthCheckViaDriver(connection) {
+  try {
+    const rows = await queryViaDriver(connection, "SELECT 1");
+    return Array.isArray(rows);
+  } catch {
+    return false;
+  }
+}
+async function closeViaDriver(connection) {
+  if (!connection || typeof connection !== "object" && typeof connection !== "function") {
+    return;
+  }
+  const driver = getConnectionDriver(connection);
+  const conn = connection;
+  if (driver === "mysql2" || driver === "postgres") {
+    if (typeof conn.end === "function") {
+      await conn.end();
+      return;
+    }
+  }
+  if (driver === "bun-sql") {
+    if (typeof conn.close === "function") {
+      await conn.close();
+      return;
+    }
+  }
+  if (typeof conn.close === "function") {
+    await conn.close();
+  } else if (typeof conn.end === "function") {
+    await conn.end();
+  }
+}
+function buildTemplateFromSql(sql, params) {
+  if (!params || params.length === 0) {
+    return { strings: [sql], values: [] };
+  }
+  const strings = sql.split("?");
+  if (strings.length !== params.length + 1) {
+    throw new Error("SQL placeholders count does not match parameters count");
+  }
+  return { strings, values: params };
+}
+function loadMysql2() {
+  return __require("mysql2/promise");
+}
+function loadPostgres() {
+  return __require("postgres");
+}
+
+// src/database/connection-pool.ts
 class ConnectionPool {
   config;
   options;
@@ -10979,29 +11204,12 @@ Install it with: bun add @vscode/sqlite3@5.1.12-vscode`);
     return new sqlite3.Database(config.path);
   }
   async createPostgresConnection(config) {
-    const url = `postgres://${config.user}:${config.password}@${config.host}:${config.port}/${config.database}`;
-    if (getRuntime().engine === "bun") {
-      const { SQL } = await import("bun");
-      return new SQL(url, { max: 1, tls: config.ssl ?? false });
-    }
-    const postgres = __require("postgres");
-    return postgres(url, { max: 1, ssl: config.ssl ? "require" : false });
+    const driver = resolveDriver("postgres", this.config.type === "postgres" ? this.config.driver : undefined, getRuntime().engine);
+    return await createPostgresConnection(config, driver);
   }
   async createMysqlConnection(config) {
-    if (getRuntime().engine === "bun") {
-      const url = `mysql://${config.user}:${config.password}@${config.host}:${config.port}/${config.database}`;
-      const { SQL } = await import("bun");
-      return new SQL(url, { max: 1 });
-    }
-    const mysql2 = __require("mysql2/promise");
-    const conn = await mysql2.createConnection({
-      host: config.host,
-      port: config.port,
-      database: config.database,
-      user: config.user,
-      password: config.password
-    });
-    return conn;
+    const driver = resolveDriver("mysql", this.config.type === "mysql" ? this.config.driver : undefined, getRuntime().engine);
+    return await createMysqlConnection(config, driver);
   }
   async closeConnection(connection) {
     const dbType = this.config.type;
@@ -11018,15 +11226,11 @@ Install it with: bun add @vscode/sqlite3@5.1.12-vscode`);
       connection.close();
     }
   }
-  async closePostgresConnection(_connection) {
-    if (_connection && typeof _connection === "object" && "close" in _connection && typeof _connection.close === "function") {
-      _connection.close();
-    }
+  async closePostgresConnection(connection) {
+    await closeViaDriver(connection);
   }
-  async closeMysqlConnection(_connection) {
-    if (_connection && typeof _connection === "object" && "close" in _connection && typeof _connection.close === "function") {
-      _connection.close();
-    }
+  async closeMysqlConnection(connection) {
+    await closeViaDriver(connection);
   }
   async waitForConnection() {
     const startTime = Date.now();
@@ -11167,34 +11371,10 @@ class DatabaseConnectionManager {
     }
   }
   async healthCheckPostgres(connection) {
-    try {
-      if (connection && typeof connection === "function") {
-        const result = await connection`SELECT 1`;
-        return Array.isArray(result) && result.length > 0;
-      }
-      if (connection && typeof connection === "object" && "query" in connection && typeof connection.query === "function") {
-        await connection.query("SELECT 1");
-        return true;
-      }
-      return false;
-    } catch (_error) {
-      return false;
-    }
+    return await healthCheckViaDriver(connection);
   }
   async healthCheckMysql(connection) {
-    try {
-      if (connection && typeof connection === "function") {
-        const result = await connection`SELECT 1`;
-        return Array.isArray(result) && result.length > 0;
-      }
-      if (connection && typeof connection === "object" && "query" in connection && typeof connection.query === "function") {
-        await connection.query("SELECT 1");
-        return true;
-      }
-      return false;
-    } catch (_error) {
-      return false;
-    }
+    return await healthCheckViaDriver(connection);
   }
 }
 
@@ -11265,7 +11445,7 @@ class DatabaseService2 {
     if (dbType === "sqlite") {
       return this.querySqlite(connection, sql, params);
     } else if (dbType === "postgres" || dbType === "mysql") {
-      return this.queryBunSQL(connection, sql, params);
+      return queryViaDriver(connection, sql, params);
     }
     throw new Error(`Query not supported for database type: ${dbType}`);
   }
@@ -11288,37 +11468,6 @@ class DatabaseService2 {
     }
     throw new Error("Invalid SQLite connection");
   }
-  async queryBunSQL(connection, sql, params) {
-    if (connection && typeof connection === "function") {
-      try {
-        const { strings, values } = this.buildTemplateFromSql(sql, params);
-        const template = Object.assign(strings, {
-          raw: strings
-        });
-        const result = await connection(template, ...values);
-        return result;
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        throw new Error(`Bun.SQL parameterized queries are not fully supported. Consider using template string queries. Original error: ${errorMessage}`);
-      }
-    }
-    if (connection && typeof connection === "object" && "query" in connection && typeof connection.query === "function") {
-      const db = connection;
-      const result = await db.query(sql, ...params ?? []);
-      return result;
-    }
-    throw new Error("Invalid Bun.SQL connection");
-  }
-  buildTemplateFromSql(sql, params) {
-    if (!params || params.length === 0) {
-      return { strings: [sql], values: [] };
-    }
-    const strings = sql.split("?");
-    if (strings.length !== params.length + 1) {
-      throw new Error("SQL placeholders count does not match parameters count");
-    }
-    return { strings, values: params };
-  }
 }
 DatabaseService2 = __legacyDecorateClassTS([
   Injectable(),
@@ -11332,7 +11481,6 @@ var ORM_SERVICE_TOKEN = Symbol("@dangao/bun-server:orm:service");
 
 // src/database/sql-manager.ts
 init_runtime();
-
 class BunSQLManager2 {
   instances = new Map;
   defaultTenantId = "default";
@@ -11342,34 +11490,49 @@ class BunSQLManager2 {
       return existing;
     }
     const pool = config.pool ?? {};
+    const driver = resolveDriver(config.type, config.driver, getRuntime().engine);
     let sql;
-    if (getRuntime().engine === "bun") {
+    if (driver === "bun-sql") {
       const { SQL } = __require("bun");
-      sql = new SQL(config.url, {
-        max: pool.max ?? 10,
-        idleTimeout: pool.idleTimeout ?? 30,
-        maxLifetime: pool.maxLifetime ?? 0,
-        connectionTimeout: pool.connectionTimeout ?? 30000
-      });
-    } else {
-      const url = config.url.toLowerCase();
-      if (url.startsWith("mysql://") || url.startsWith("mysql2://")) {
-        const mysql2 = __require("mysql2/promise");
-        sql = mysql2.createPool({
-          uri: config.url,
-          connectionLimit: pool.max ?? 10,
-          waitForConnections: true
+      if (config.type === "mysql") {
+        const parsed = new URL(config.url);
+        sql = new SQL({
+          adapter: "mysql",
+          hostname: parsed.hostname,
+          port: parsed.port ? Number(parsed.port) : 3306,
+          username: decodeURIComponent(parsed.username),
+          password: decodeURIComponent(parsed.password),
+          database: parsed.pathname.replace(/^\//, ""),
+          max: pool.max ?? 10,
+          idleTimeout: pool.idleTimeout ?? 30,
+          maxLifetime: pool.maxLifetime ?? 0,
+          connectionTimeout: pool.connectionTimeout ?? 30000
         });
       } else {
-        const postgres = __require("postgres");
-        sql = postgres(config.url, {
+        sql = new SQL(config.url, {
           max: pool.max ?? 10,
-          idle_timeout: pool.idleTimeout ?? 30,
-          max_lifetime: pool.maxLifetime ?? 0,
-          connect_timeout: (pool.connectionTimeout ?? 30000) / 1000
+          idleTimeout: pool.idleTimeout ?? 30,
+          maxLifetime: pool.maxLifetime ?? 0,
+          connectionTimeout: pool.connectionTimeout ?? 30000
         });
       }
+    } else if (driver === "mysql2") {
+      const mysql2 = __require("mysql2/promise");
+      sql = mysql2.createPool({
+        uri: config.url,
+        connectionLimit: pool.max ?? 10,
+        waitForConnections: true
+      });
+    } else {
+      const postgres = __require("postgres");
+      sql = postgres(config.url, {
+        max: pool.max ?? 10,
+        idle_timeout: pool.idleTimeout ?? 30,
+        max_lifetime: pool.maxLifetime ?? 0,
+        connect_timeout: (pool.connectionTimeout ?? 30000) / 1000
+      });
     }
+    tagConnection(sql, driver);
     this.instances.set(tenantId, sql);
     return sql;
   }
@@ -11580,10 +11743,10 @@ var baseDb = async (tenantId, strings, ...values) => {
   if (tenantId) {
     const tenantSql = sqlManager.get(tenantId);
     if (tenantSql) {
-      return await tenantSql(strings, ...values);
+      return await templateQueryViaDriver(tenantSql, strings, values);
     }
   }
-  return await sqlManager.getDefault()(strings, ...values);
+  return await templateQueryViaDriver(sqlManager.getDefault(), strings, values);
 };
 function createDb(tenantId) {
   const fn = async (strings, ...values) => baseDb(tenantId, strings, ...values);
@@ -11657,7 +11820,8 @@ class DatabaseModule {
           config: {
             type: db2.type,
             url,
-            pool: options.bunSqlPool
+            pool: options.bunSqlPool,
+            driver: db2.driver ?? options.driver
           }
         }
       ];
@@ -11682,7 +11846,8 @@ class DatabaseModule {
           config: {
             type: options.type,
             url: options.url,
-            pool: options.bunSqlPool
+            pool: options.bunSqlPool,
+            driver: options.driver
           }
         }
       ];
@@ -11696,7 +11861,8 @@ class DatabaseModule {
           config: {
             type: options.type,
             url,
-            pool: options.bunSqlPool
+            pool: options.bunSqlPool,
+            driver: options.driver
           }
         }
       ];
@@ -11780,7 +11946,8 @@ class DatabaseModule {
           database: options.databasePath ?? "default",
           user: options.username ?? "root",
           password: options.password ?? ""
-        }
+        },
+        driver: normalized[0]?.config?.driver ?? options.driver
       }
     };
     const service = new DatabaseService2(legacyOptions);
@@ -12770,6 +12937,7 @@ class StressTester {
 }
 // src/testing/testing-module.ts
 import"reflect-metadata";
+init_module();
 
 // src/testing/test-client.ts
 class TestHttpClient {
@@ -12933,7 +13101,7 @@ class TestingModule {
         container.registerInstance(provider.provide, provider.useValue);
       } else if ("useFactory" in provider && provider.provide) {
         container.register(provider.provide, {
-          factory: () => provider.useFactory(container)
+          factory: () => invokeFactoryProvider(provider, container)
         });
       } else if ("useClass" in provider) {
         const token = provider.provide ?? provider.useClass;
@@ -13375,7 +13543,7 @@ class SessionService {
   constructor(options) {
     this.store = options.store;
     this.name = options.name ?? "sessionId";
-    this.maxAge = options.maxAge ?? 86400000;
+    this.maxAge = options.maxAge ?? options.ttl ?? 86400000;
     this.rolling = options.rolling ?? true;
     this.cookieOptions = {
       secure: options.cookie?.secure ?? false,
@@ -14085,14 +14253,15 @@ class Tracer {
       Object.assign(span.tags, tags);
     }
   }
-  addSpanEvent(spanId, event) {
+  addSpanEvent(spanId, event, attributes) {
     const span = this.activeSpans.get(spanId);
     if (span) {
       if (!span.events) {
         span.events = [];
       }
+      const spanEvent = typeof event === "string" ? { name: event, attributes } : event;
       span.events.push({
-        ...event,
+        ...spanEvent,
         timestamp: Date.now()
       });
     }
@@ -14795,6 +14964,7 @@ class ServiceMetricsCollector {
 var AI_SERVICE_TOKEN = Symbol("@dangao/bun-server:ai:service");
 var AI_MODULE_OPTIONS_TOKEN = Symbol("@dangao/bun-server:ai:options");
 var AI_TOOL_REGISTRY_TOKEN = Symbol("@dangao/bun-server:ai:tool-registry");
+var MODULE_METADATA_KEY3 = "@dangao/bun-server:ai:module";
 var AI_TOOL_METADATA_KEY = "@dangao/bun-server:ai:tool";
 // src/ai/errors.ts
 init_http_exception();
@@ -17578,6 +17748,7 @@ export {
   Max,
   Matches,
   MarkdownChunker,
+  MODULE_METADATA_KEY3 as MODULE_METADATA_KEY,
   METRICS_SERVICE_TOKEN,
   METRICS_OPTIONS_TOKEN,
   MCP_TOOL_METADATA_KEY,