@dangao/bun-server 0.3.0 → 1.0.0

package/dist/index.js

@@ -1,5 +1,20 @@
 // @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
@@ -25,6 +40,7 @@ var __legacyMetadataTS = (k, v) => {
     return Reflect.metadata(k, v);
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
 
 // src/validation/decorators.ts
 import"reflect-metadata";
@@ -175,38 +191,98 @@ var init_error_codes = __esm(() => {
     ["INVALID_REQUEST" /* INVALID_REQUEST */]: 400,
     ["RESOURCE_NOT_FOUND" /* RESOURCE_NOT_FOUND */]: 404,
     ["METHOD_NOT_ALLOWED" /* METHOD_NOT_ALLOWED */]: 405,
+    ["RATE_LIMIT_EXCEEDED" /* RATE_LIMIT_EXCEEDED */]: 429,
+    ["SERVICE_UNAVAILABLE" /* SERVICE_UNAVAILABLE */]: 503,
+    ["TIMEOUT" /* TIMEOUT */]: 408,
     ["AUTH_REQUIRED" /* AUTH_REQUIRED */]: 401,
     ["AUTH_INVALID_TOKEN" /* AUTH_INVALID_TOKEN */]: 401,
     ["AUTH_TOKEN_EXPIRED" /* AUTH_TOKEN_EXPIRED */]: 401,
     ["AUTH_INSUFFICIENT_PERMISSIONS" /* AUTH_INSUFFICIENT_PERMISSIONS */]: 403,
+    ["AUTH_INVALID_CREDENTIALS" /* AUTH_INVALID_CREDENTIALS */]: 401,
+    ["AUTH_ACCOUNT_LOCKED" /* AUTH_ACCOUNT_LOCKED */]: 423,
+    ["AUTH_ACCOUNT_DISABLED" /* AUTH_ACCOUNT_DISABLED */]: 403,
     ["VALIDATION_FAILED" /* VALIDATION_FAILED */]: 400,
     ["VALIDATION_REQUIRED_FIELD" /* VALIDATION_REQUIRED_FIELD */]: 400,
     ["VALIDATION_INVALID_FORMAT" /* VALIDATION_INVALID_FORMAT */]: 400,
     ["VALIDATION_OUT_OF_RANGE" /* VALIDATION_OUT_OF_RANGE */]: 400,
+    ["VALIDATION_TYPE_MISMATCH" /* VALIDATION_TYPE_MISMATCH */]: 400,
+    ["VALIDATION_CONSTRAINT_VIOLATION" /* VALIDATION_CONSTRAINT_VIOLATION */]: 400,
     ["OAUTH2_INVALID_CLIENT" /* OAUTH2_INVALID_CLIENT */]: 400,
     ["OAUTH2_INVALID_GRANT" /* OAUTH2_INVALID_GRANT */]: 400,
     ["OAUTH2_INVALID_SCOPE" /* OAUTH2_INVALID_SCOPE */]: 400,
     ["OAUTH2_INVALID_REDIRECT_URI" /* OAUTH2_INVALID_REDIRECT_URI */]: 400,
-    ["OAUTH2_UNSUPPORTED_GRANT_TYPE" /* OAUTH2_UNSUPPORTED_GRANT_TYPE */]: 400
+    ["OAUTH2_UNSUPPORTED_GRANT_TYPE" /* OAUTH2_UNSUPPORTED_GRANT_TYPE */]: 400,
+    ["OAUTH2_ACCESS_DENIED" /* OAUTH2_ACCESS_DENIED */]: 403,
+    ["OAUTH2_SERVER_ERROR" /* OAUTH2_SERVER_ERROR */]: 500,
+    ["DATABASE_CONNECTION_FAILED" /* DATABASE_CONNECTION_FAILED */]: 503,
+    ["DATABASE_QUERY_FAILED" /* DATABASE_QUERY_FAILED */]: 500,
+    ["DATABASE_TRANSACTION_FAILED" /* DATABASE_TRANSACTION_FAILED */]: 500,
+    ["DATABASE_CONSTRAINT_VIOLATION" /* DATABASE_CONSTRAINT_VIOLATION */]: 409,
+    ["DATABASE_TIMEOUT" /* DATABASE_TIMEOUT */]: 504,
+    ["DATABASE_POOL_EXHAUSTED" /* DATABASE_POOL_EXHAUSTED */]: 503,
+    ["DATABASE_MIGRATION_FAILED" /* DATABASE_MIGRATION_FAILED */]: 500,
+    ["FILE_NOT_FOUND" /* FILE_NOT_FOUND */]: 404,
+    ["FILE_UPLOAD_FAILED" /* FILE_UPLOAD_FAILED */]: 500,
+    ["FILE_DOWNLOAD_FAILED" /* FILE_DOWNLOAD_FAILED */]: 500,
+    ["FILE_SIZE_EXCEEDED" /* FILE_SIZE_EXCEEDED */]: 413,
+    ["FILE_TYPE_NOT_ALLOWED" /* FILE_TYPE_NOT_ALLOWED */]: 415,
+    ["FILE_ACCESS_DENIED" /* FILE_ACCESS_DENIED */]: 403,
+    ["FILE_PATH_TRAVERSAL" /* FILE_PATH_TRAVERSAL */]: 400,
+    ["MIDDLEWARE_EXECUTION_FAILED" /* MIDDLEWARE_EXECUTION_FAILED */]: 500,
+    ["MIDDLEWARE_TIMEOUT" /* MIDDLEWARE_TIMEOUT */]: 504,
+    ["CORS_NOT_ALLOWED" /* CORS_NOT_ALLOWED */]: 403,
+    ["CONFIG_INVALID" /* CONFIG_INVALID */]: 500,
+    ["CONFIG_MISSING" /* CONFIG_MISSING */]: 500,
+    ["CONFIG_VALIDATION_FAILED" /* CONFIG_VALIDATION_FAILED */]: 500
   };
   ERROR_CODE_MESSAGES = {
     ["INTERNAL_ERROR" /* INTERNAL_ERROR */]: "Internal Server Error",
     ["INVALID_REQUEST" /* INVALID_REQUEST */]: "Invalid Request",
     ["RESOURCE_NOT_FOUND" /* RESOURCE_NOT_FOUND */]: "Resource Not Found",
     ["METHOD_NOT_ALLOWED" /* METHOD_NOT_ALLOWED */]: "Method Not Allowed",
+    ["RATE_LIMIT_EXCEEDED" /* RATE_LIMIT_EXCEEDED */]: "Rate Limit Exceeded",
+    ["SERVICE_UNAVAILABLE" /* SERVICE_UNAVAILABLE */]: "Service Unavailable",
+    ["TIMEOUT" /* TIMEOUT */]: "Request Timeout",
     ["AUTH_REQUIRED" /* AUTH_REQUIRED */]: "Authentication Required",
     ["AUTH_INVALID_TOKEN" /* AUTH_INVALID_TOKEN */]: "Invalid Authentication Token",
     ["AUTH_TOKEN_EXPIRED" /* AUTH_TOKEN_EXPIRED */]: "Authentication Token Expired",
     ["AUTH_INSUFFICIENT_PERMISSIONS" /* AUTH_INSUFFICIENT_PERMISSIONS */]: "Insufficient Permissions",
+    ["AUTH_INVALID_CREDENTIALS" /* AUTH_INVALID_CREDENTIALS */]: "Invalid Credentials",
+    ["AUTH_ACCOUNT_LOCKED" /* AUTH_ACCOUNT_LOCKED */]: "Account Locked",
+    ["AUTH_ACCOUNT_DISABLED" /* AUTH_ACCOUNT_DISABLED */]: "Account Disabled",
     ["VALIDATION_FAILED" /* VALIDATION_FAILED */]: "Validation Failed",
     ["VALIDATION_REQUIRED_FIELD" /* VALIDATION_REQUIRED_FIELD */]: "Required Field Missing",
     ["VALIDATION_INVALID_FORMAT" /* VALIDATION_INVALID_FORMAT */]: "Invalid Format",
     ["VALIDATION_OUT_OF_RANGE" /* VALIDATION_OUT_OF_RANGE */]: "Value Out of Range",
+    ["VALIDATION_TYPE_MISMATCH" /* VALIDATION_TYPE_MISMATCH */]: "Type Mismatch",
+    ["VALIDATION_CONSTRAINT_VIOLATION" /* VALIDATION_CONSTRAINT_VIOLATION */]: "Constraint Violation",
     ["OAUTH2_INVALID_CLIENT" /* OAUTH2_INVALID_CLIENT */]: "Invalid Client",
     ["OAUTH2_INVALID_GRANT" /* OAUTH2_INVALID_GRANT */]: "Invalid Grant",
     ["OAUTH2_INVALID_SCOPE" /* OAUTH2_INVALID_SCOPE */]: "Invalid Scope",
     ["OAUTH2_INVALID_REDIRECT_URI" /* OAUTH2_INVALID_REDIRECT_URI */]: "Invalid Redirect URI",
-    ["OAUTH2_UNSUPPORTED_GRANT_TYPE" /* OAUTH2_UNSUPPORTED_GRANT_TYPE */]: "Unsupported Grant Type"
+    ["OAUTH2_UNSUPPORTED_GRANT_TYPE" /* OAUTH2_UNSUPPORTED_GRANT_TYPE */]: "Unsupported Grant Type",
+    ["OAUTH2_ACCESS_DENIED" /* OAUTH2_ACCESS_DENIED */]: "Access Denied",
+    ["OAUTH2_SERVER_ERROR" /* OAUTH2_SERVER_ERROR */]: "OAuth2 Server Error",
+    ["DATABASE_CONNECTION_FAILED" /* DATABASE_CONNECTION_FAILED */]: "Database Connection Failed",
+    ["DATABASE_QUERY_FAILED" /* DATABASE_QUERY_FAILED */]: "Database Query Failed",
+    ["DATABASE_TRANSACTION_FAILED" /* DATABASE_TRANSACTION_FAILED */]: "Database Transaction Failed",
+    ["DATABASE_CONSTRAINT_VIOLATION" /* DATABASE_CONSTRAINT_VIOLATION */]: "Database Constraint Violation",
+    ["DATABASE_TIMEOUT" /* DATABASE_TIMEOUT */]: "Database Timeout",
+    ["DATABASE_POOL_EXHAUSTED" /* DATABASE_POOL_EXHAUSTED */]: "Database Connection Pool Exhausted",
+    ["DATABASE_MIGRATION_FAILED" /* DATABASE_MIGRATION_FAILED */]: "Database Migration Failed",
+    ["FILE_NOT_FOUND" /* FILE_NOT_FOUND */]: "File Not Found",
+    ["FILE_UPLOAD_FAILED" /* FILE_UPLOAD_FAILED */]: "File Upload Failed",
+    ["FILE_DOWNLOAD_FAILED" /* FILE_DOWNLOAD_FAILED */]: "File Download Failed",
+    ["FILE_SIZE_EXCEEDED" /* FILE_SIZE_EXCEEDED */]: "File Size Exceeded",
+    ["FILE_TYPE_NOT_ALLOWED" /* FILE_TYPE_NOT_ALLOWED */]: "File Type Not Allowed",
+    ["FILE_ACCESS_DENIED" /* FILE_ACCESS_DENIED */]: "File Access Denied",
+    ["FILE_PATH_TRAVERSAL" /* FILE_PATH_TRAVERSAL */]: "Path Traversal Detected",
+    ["MIDDLEWARE_EXECUTION_FAILED" /* MIDDLEWARE_EXECUTION_FAILED */]: "Middleware Execution Failed",
+    ["MIDDLEWARE_TIMEOUT" /* MIDDLEWARE_TIMEOUT */]: "Middleware Timeout",
+    ["CORS_NOT_ALLOWED" /* CORS_NOT_ALLOWED */]: "CORS Not Allowed",
+    ["CONFIG_INVALID" /* CONFIG_INVALID */]: "Invalid Configuration",
+    ["CONFIG_MISSING" /* CONFIG_MISSING */]: "Missing Configuration",
+    ["CONFIG_VALIDATION_FAILED" /* CONFIG_VALIDATION_FAILED */]: "Configuration Validation Failed"
   };
 });
 
@@ -218,42 +294,44 @@ var init_http_exception = __esm(() => {
     status;
     code;
     details;
-    constructor(status, message, details, code) {
+    messageParams;
+    constructor(status, message, details, code, messageParams) {
       super(message);
       this.name = this.constructor.name;
       this.status = status;
       this.code = code;
       this.details = details;
+      this.messageParams = messageParams;
     }
-    static withCode(code, message, details) {
+    static withCode(code, message, details, messageParams) {
       const status = ERROR_CODE_TO_STATUS[code] || 500;
       const finalMessage = message || ERROR_CODE_MESSAGES[code] || "Internal Server Error";
-      return new HttpException(status, finalMessage, details, code);
+      return new HttpException(status, finalMessage, details, code, messageParams);
     }
   };
   BadRequestException = class BadRequestException extends HttpException {
-    constructor(message = "Bad Request", details, code) {
-      super(400, message, details, code);
+    constructor(message = "Bad Request", details, code, messageParams) {
+      super(400, message, details, code, messageParams);
     }
   };
   UnauthorizedException = class UnauthorizedException extends HttpException {
-    constructor(message = "Unauthorized", details, code) {
-      super(401, message, details, code);
+    constructor(message = "Unauthorized", details, code, messageParams) {
+      super(401, message, details, code, messageParams);
     }
   };
   ForbiddenException = class ForbiddenException extends HttpException {
-    constructor(message = "Forbidden", details, code) {
-      super(403, message, details, code);
+    constructor(message = "Forbidden", details, code, messageParams) {
+      super(403, message, details, code, messageParams);
     }
   };
   NotFoundException = class NotFoundException extends HttpException {
-    constructor(message = "Not Found", details, code) {
-      super(404, message, details, code);
+    constructor(message = "Not Found", details, code, messageParams) {
+      super(404, message, details, code, messageParams);
     }
   };
   InternalServerErrorException = class InternalServerErrorException extends HttpException {
-    constructor(message = "Internal Server Error", details, code) {
-      super(500, message, details, code);
+    constructor(message = "Internal Server Error", details, code, messageParams) {
+      super(500, message, details, code, messageParams);
     }
   };
 });
@@ -295,18 +373,35 @@ class ErrorMessageI18n {
   static getLanguage() {
     return this.currentLanguage;
   }
-  static getMessage(code, language) {
+  static getMessage(code, language, params) {
     const lang = language || this.currentLanguage;
     const messages = ERROR_MESSAGES_I18N[lang];
-    return messages?.[code] || ERROR_CODE_MESSAGES[code] || "Internal Server Error";
+    let message = messages?.[code] || ERROR_CODE_MESSAGES[code] || "Internal Server Error";
+    if (params) {
+      message = this.replaceTemplate(message, params);
+    }
+    return message;
+  }
+  static replaceTemplate(template, params) {
+    return template.replace(/\{(\w+)\}/g, (match, key) => {
+      const value = params[key];
+      return value !== undefined ? String(value) : match;
+    });
   }
   static parseLanguageFromHeader(acceptLanguage) {
     if (!acceptLanguage) {
       return "en";
     }
-    if (acceptLanguage.includes("zh-CN") || acceptLanguage.includes("zh")) {
+    const lowerAcceptLanguage = acceptLanguage.toLowerCase();
+    if (lowerAcceptLanguage.includes("zh-cn") || lowerAcceptLanguage.includes("zh")) {
       return "zh-CN";
     }
+    if (lowerAcceptLanguage.includes("ja")) {
+      return "ja";
+    }
+    if (lowerAcceptLanguage.includes("ko")) {
+      return "ko";
+    }
     return "en";
   }
 }
@@ -322,19 +417,65 @@ var init_i18n = __esm(() => {
       ["INVALID_REQUEST" /* INVALID_REQUEST */]: "\u65E0\u6548\u7684\u8BF7\u6C42",
       ["RESOURCE_NOT_FOUND" /* RESOURCE_NOT_FOUND */]: "\u8D44\u6E90\u672A\u627E\u5230",
       ["METHOD_NOT_ALLOWED" /* METHOD_NOT_ALLOWED */]: "\u65B9\u6CD5\u4E0D\u5141\u8BB8",
+      ["RATE_LIMIT_EXCEEDED" /* RATE_LIMIT_EXCEEDED */]: "\u8BF7\u6C42\u9891\u7387\u8D85\u9650",
+      ["SERVICE_UNAVAILABLE" /* SERVICE_UNAVAILABLE */]: "\u670D\u52A1\u4E0D\u53EF\u7528",
+      ["TIMEOUT" /* TIMEOUT */]: "\u8BF7\u6C42\u8D85\u65F6",
       ["AUTH_REQUIRED" /* AUTH_REQUIRED */]: "\u9700\u8981\u8BA4\u8BC1",
       ["AUTH_INVALID_TOKEN" /* AUTH_INVALID_TOKEN */]: "\u65E0\u6548\u7684\u8BA4\u8BC1\u4EE4\u724C",
       ["AUTH_TOKEN_EXPIRED" /* AUTH_TOKEN_EXPIRED */]: "\u8BA4\u8BC1\u4EE4\u724C\u5DF2\u8FC7\u671F",
       ["AUTH_INSUFFICIENT_PERMISSIONS" /* AUTH_INSUFFICIENT_PERMISSIONS */]: "\u6743\u9650\u4E0D\u8DB3",
+      ["AUTH_INVALID_CREDENTIALS" /* AUTH_INVALID_CREDENTIALS */]: "\u65E0\u6548\u7684\u51ED\u636E",
+      ["AUTH_ACCOUNT_LOCKED" /* AUTH_ACCOUNT_LOCKED */]: "\u8D26\u6237\u5DF2\u9501\u5B9A",
+      ["AUTH_ACCOUNT_DISABLED" /* AUTH_ACCOUNT_DISABLED */]: "\u8D26\u6237\u5DF2\u7981\u7528",
       ["VALIDATION_FAILED" /* VALIDATION_FAILED */]: "\u9A8C\u8BC1\u5931\u8D25",
       ["VALIDATION_REQUIRED_FIELD" /* VALIDATION_REQUIRED_FIELD */]: "\u5FC5\u586B\u5B57\u6BB5\u7F3A\u5931",
       ["VALIDATION_INVALID_FORMAT" /* VALIDATION_INVALID_FORMAT */]: "\u683C\u5F0F\u65E0\u6548",
       ["VALIDATION_OUT_OF_RANGE" /* VALIDATION_OUT_OF_RANGE */]: "\u503C\u8D85\u51FA\u8303\u56F4",
+      ["VALIDATION_TYPE_MISMATCH" /* VALIDATION_TYPE_MISMATCH */]: "\u7C7B\u578B\u4E0D\u5339\u914D",
+      ["VALIDATION_CONSTRAINT_VIOLATION" /* VALIDATION_CONSTRAINT_VIOLATION */]: "\u7EA6\u675F\u8FDD\u53CD",
       ["OAUTH2_INVALID_CLIENT" /* OAUTH2_INVALID_CLIENT */]: "\u65E0\u6548\u7684\u5BA2\u6237\u7AEF",
       ["OAUTH2_INVALID_GRANT" /* OAUTH2_INVALID_GRANT */]: "\u65E0\u6548\u7684\u6388\u6743",
       ["OAUTH2_INVALID_SCOPE" /* OAUTH2_INVALID_SCOPE */]: "\u65E0\u6548\u7684\u4F5C\u7528\u57DF",
       ["OAUTH2_INVALID_REDIRECT_URI" /* OAUTH2_INVALID_REDIRECT_URI */]: "\u65E0\u6548\u7684\u91CD\u5B9A\u5411 URI",
-      ["OAUTH2_UNSUPPORTED_GRANT_TYPE" /* OAUTH2_UNSUPPORTED_GRANT_TYPE */]: "\u4E0D\u652F\u6301\u7684\u6388\u6743\u7C7B\u578B"
+      ["OAUTH2_UNSUPPORTED_GRANT_TYPE" /* OAUTH2_UNSUPPORTED_GRANT_TYPE */]: "\u4E0D\u652F\u6301\u7684\u6388\u6743\u7C7B\u578B",
+      ["OAUTH2_ACCESS_DENIED" /* OAUTH2_ACCESS_DENIED */]: "\u8BBF\u95EE\u88AB\u62D2\u7EDD",
+      ["OAUTH2_SERVER_ERROR" /* OAUTH2_SERVER_ERROR */]: "OAuth2 \u670D\u52A1\u5668\u9519\u8BEF",
+      ["DATABASE_CONNECTION_FAILED" /* DATABASE_CONNECTION_FAILED */]: "\u6570\u636E\u5E93\u8FDE\u63A5\u5931\u8D25",
+      ["DATABASE_QUERY_FAILED" /* DATABASE_QUERY_FAILED */]: "\u6570\u636E\u5E93\u67E5\u8BE2\u5931\u8D25",
+      ["DATABASE_TRANSACTION_FAILED" /* DATABASE_TRANSACTION_FAILED */]: "\u6570\u636E\u5E93\u4E8B\u52A1\u5931\u8D25",
+      ["DATABASE_CONSTRAINT_VIOLATION" /* DATABASE_CONSTRAINT_VIOLATION */]: "\u6570\u636E\u5E93\u7EA6\u675F\u8FDD\u53CD",
+      ["DATABASE_TIMEOUT" /* DATABASE_TIMEOUT */]: "\u6570\u636E\u5E93\u8D85\u65F6",
+      ["DATABASE_POOL_EXHAUSTED" /* DATABASE_POOL_EXHAUSTED */]: "\u6570\u636E\u5E93\u8FDE\u63A5\u6C60\u8017\u5C3D",
+      ["DATABASE_MIGRATION_FAILED" /* DATABASE_MIGRATION_FAILED */]: "\u6570\u636E\u5E93\u8FC1\u79FB\u5931\u8D25",
+      ["FILE_NOT_FOUND" /* FILE_NOT_FOUND */]: "\u6587\u4EF6\u672A\u627E\u5230",
+      ["FILE_UPLOAD_FAILED" /* FILE_UPLOAD_FAILED */]: "\u6587\u4EF6\u4E0A\u4F20\u5931\u8D25",
+      ["FILE_DOWNLOAD_FAILED" /* FILE_DOWNLOAD_FAILED */]: "\u6587\u4EF6\u4E0B\u8F7D\u5931\u8D25",
+      ["FILE_SIZE_EXCEEDED" /* FILE_SIZE_EXCEEDED */]: "\u6587\u4EF6\u5927\u5C0F\u8D85\u9650",
+      ["FILE_TYPE_NOT_ALLOWED" /* FILE_TYPE_NOT_ALLOWED */]: "\u4E0D\u5141\u8BB8\u7684\u6587\u4EF6\u7C7B\u578B",
+      ["FILE_ACCESS_DENIED" /* FILE_ACCESS_DENIED */]: "\u6587\u4EF6\u8BBF\u95EE\u88AB\u62D2\u7EDD",
+      ["FILE_PATH_TRAVERSAL" /* FILE_PATH_TRAVERSAL */]: "\u68C0\u6D4B\u5230\u8DEF\u5F84\u904D\u5386\u653B\u51FB",
+      ["MIDDLEWARE_EXECUTION_FAILED" /* MIDDLEWARE_EXECUTION_FAILED */]: "\u4E2D\u95F4\u4EF6\u6267\u884C\u5931\u8D25",
+      ["MIDDLEWARE_TIMEOUT" /* MIDDLEWARE_TIMEOUT */]: "\u4E2D\u95F4\u4EF6\u8D85\u65F6",
+      ["CORS_NOT_ALLOWED" /* CORS_NOT_ALLOWED */]: "CORS \u4E0D\u5141\u8BB8",
+      ["CONFIG_INVALID" /* CONFIG_INVALID */]: "\u65E0\u6548\u7684\u914D\u7F6E",
+      ["CONFIG_MISSING" /* CONFIG_MISSING */]: "\u7F3A\u5C11\u914D\u7F6E",
+      ["CONFIG_VALIDATION_FAILED" /* CONFIG_VALIDATION_FAILED */]: "\u914D\u7F6E\u9A8C\u8BC1\u5931\u8D25"
+    },
+    ja: {
+      ["INTERNAL_ERROR" /* INTERNAL_ERROR */]: "\u30B5\u30FC\u30D0\u30FC\u5185\u90E8\u30A8\u30E9\u30FC",
+      ["INVALID_REQUEST" /* INVALID_REQUEST */]: "\u7121\u52B9\u306A\u30EA\u30AF\u30A8\u30B9\u30C8",
+      ["RESOURCE_NOT_FOUND" /* RESOURCE_NOT_FOUND */]: "\u30EA\u30BD\u30FC\u30B9\u304C\u898B\u3064\u304B\u308A\u307E\u305B\u3093",
+      ["AUTH_REQUIRED" /* AUTH_REQUIRED */]: "\u8A8D\u8A3C\u304C\u5FC5\u8981\u3067\u3059",
+      ["AUTH_INVALID_TOKEN" /* AUTH_INVALID_TOKEN */]: "\u7121\u52B9\u306A\u8A8D\u8A3C\u30C8\u30FC\u30AF\u30F3",
+      ["VALIDATION_FAILED" /* VALIDATION_FAILED */]: "\u691C\u8A3C\u306B\u5931\u6557\u3057\u307E\u3057\u305F"
+    },
+    ko: {
+      ["INTERNAL_ERROR" /* INTERNAL_ERROR */]: "\uC11C\uBC84 \uB0B4\uBD80 \uC624\uB958",
+      ["INVALID_REQUEST" /* INVALID_REQUEST */]: "\uC798\uBABB\uB41C \uC694\uCCAD",
+      ["RESOURCE_NOT_FOUND" /* RESOURCE_NOT_FOUND */]: "\uB9AC\uC18C\uC2A4\uB97C \uCC3E\uC744 \uC218 \uC5C6\uC2B5\uB2C8\uB2E4",
+      ["AUTH_REQUIRED" /* AUTH_REQUIRED */]: "\uC778\uC99D\uC774 \uD544\uC694\uD569\uB2C8\uB2E4",
+      ["AUTH_INVALID_TOKEN" /* AUTH_INVALID_TOKEN */]: "\uC798\uBABB\uB41C \uC778\uC99D \uD1A0\uD070",
+      ["VALIDATION_FAILED" /* VALIDATION_FAILED */]: "\uC720\uD6A8\uC131 \uAC80\uC0AC \uC2E4\uD328"
     }
   };
 });
@@ -356,7 +497,7 @@ async function handleError(error, context) {
     if (error.code) {
       const acceptLanguage = context.getHeader("accept-language");
       const language = ErrorMessageI18n.parseLanguageFromHeader(acceptLanguage);
-      errorMessage = ErrorMessageI18n.getMessage(error.code, language);
+      errorMessage = ErrorMessageI18n.getMessage(error.code, language, error.messageParams);
     }
     const responseBody = {
       error: errorMessage
@@ -390,6 +531,181 @@ var init_handler = __esm(() => {
   init_i18n();
 });
 
+// src/database/orm/transaction-types.ts
+var Propagation, IsolationLevel, TransactionStatus, TRANSACTION_SERVICE_TOKEN;
+var init_transaction_types = __esm(() => {
+  ((Propagation2) => {
+    Propagation2["REQUIRED"] = "REQUIRED";
+    Propagation2["REQUIRES_NEW"] = "REQUIRES_NEW";
+    Propagation2["SUPPORTS"] = "SUPPORTS";
+    Propagation2["NOT_SUPPORTED"] = "NOT_SUPPORTED";
+    Propagation2["NEVER"] = "NEVER";
+    Propagation2["NESTED"] = "NESTED";
+  })(Propagation ||= {});
+  ((IsolationLevel2) => {
+    IsolationLevel2["READ_UNCOMMITTED"] = "READ_UNCOMMITTED";
+    IsolationLevel2["READ_COMMITTED"] = "READ_COMMITTED";
+    IsolationLevel2["REPEATABLE_READ"] = "REPEATABLE_READ";
+    IsolationLevel2["SERIALIZABLE"] = "SERIALIZABLE";
+  })(IsolationLevel ||= {});
+  ((TransactionStatus2) => {
+    TransactionStatus2["ACTIVE"] = "ACTIVE";
+    TransactionStatus2["COMMITTED"] = "COMMITTED";
+    TransactionStatus2["ROLLED_BACK"] = "ROLLED_BACK";
+    TransactionStatus2["SUSPENDED"] = "SUSPENDED";
+  })(TransactionStatus ||= {});
+  TRANSACTION_SERVICE_TOKEN = Symbol("@dangao/bun-server:orm:transaction:service");
+});
+
+// src/database/orm/transaction-decorator.ts
+var exports_transaction_decorator = {};
+__export(exports_transaction_decorator, {
+  getTransactionMetadata: () => getTransactionMetadata,
+  Transactional: () => Transactional,
+  TRANSACTION_METADATA_KEY: () => TRANSACTION_METADATA_KEY
+});
+import"reflect-metadata";
+function Transactional(options) {
+  return (target, propertyKey, descriptor) => {
+    if (!descriptor || typeof descriptor.value !== "function") {
+      throw new Error("@Transactional() can only be applied to methods");
+    }
+    const metadata = {
+      propagation: options?.propagation ?? "REQUIRED" /* REQUIRED */,
+      isolationLevel: options?.isolationLevel,
+      timeout: options?.timeout,
+      readOnly: options?.readOnly ?? false,
+      rollbackFor: options?.rollbackFor ?? [],
+      noRollbackFor: options?.noRollbackFor ?? []
+    };
+    Reflect.defineMetadata(TRANSACTION_METADATA_KEY, metadata, target, propertyKey);
+  };
+}
+function getTransactionMetadata(target, propertyKey) {
+  if (typeof target === "object" && target !== null) {
+    return Reflect.getMetadata(TRANSACTION_METADATA_KEY, target, propertyKey);
+  }
+  return;
+}
+var TRANSACTION_METADATA_KEY;
+var init_transaction_decorator = __esm(() => {
+  init_transaction_types();
+  TRANSACTION_METADATA_KEY = Symbol("@dangao/bun-server:orm:transaction");
+});
+
+// src/database/orm/transaction-interceptor.ts
+var exports_transaction_interceptor = {};
+__export(exports_transaction_interceptor, {
+  TransactionInterceptor: () => TransactionInterceptor
+});
+
+class TransactionInterceptor {
+  static async executeWithTransaction(target, propertyKey, originalMethod, args, container) {
+    const transactionMetadata = getTransactionMetadata(target, propertyKey);
+    if (!transactionMetadata) {
+      return await Promise.resolve(originalMethod.apply(target, args));
+    }
+    let transactionManager;
+    try {
+      transactionManager = container.resolve(TRANSACTION_SERVICE_TOKEN);
+    } catch (error) {
+      console.warn("TransactionManager not found, executing without transaction");
+      return await Promise.resolve(originalMethod.apply(target, args));
+    }
+    const propagation = transactionMetadata.propagation ?? "REQUIRED" /* REQUIRED */;
+    const currentTransaction = transactionManager.getCurrentTransaction();
+    switch (propagation) {
+      case "REQUIRED" /* REQUIRED */:
+        if (currentTransaction) {
+          return await this.executeInExistingTransaction(originalMethod, target, args, currentTransaction.id, transactionManager);
+        } else {
+          return await this.executeInNewTransaction(originalMethod, target, args, transactionMetadata, transactionManager);
+        }
+      case "REQUIRES_NEW" /* REQUIRES_NEW */:
+        return await this.executeInNewTransaction(originalMethod, target, args, transactionMetadata, transactionManager);
+      case "SUPPORTS" /* SUPPORTS */:
+        if (currentTransaction) {
+          return await this.executeInExistingTransaction(originalMethod, target, args, currentTransaction.id, transactionManager);
+        } else {
+          return await Promise.resolve(originalMethod.apply(target, args));
+        }
+      case "NOT_SUPPORTED" /* NOT_SUPPORTED */:
+        return await Promise.resolve(originalMethod.apply(target, args));
+      case "NEVER" /* NEVER */:
+        if (currentTransaction) {
+          throw new Error("Transaction propagation NEVER requires no existing transaction");
+        }
+        return await Promise.resolve(originalMethod.apply(target, args));
+      case "NESTED" /* NESTED */:
+        if (currentTransaction) {
+          return await this.executeInNestedTransaction(originalMethod, target, args, currentTransaction.id, transactionMetadata, transactionManager);
+        } else {
+          return await this.executeInNewTransaction(originalMethod, target, args, transactionMetadata, transactionManager);
+        }
+      default:
+        return await Promise.resolve(originalMethod.apply(target, args));
+    }
+  }
+  static async executeInNewTransaction(method, target, args, options, transactionManager) {
+    const context = await transactionManager.beginTransaction({
+      timeout: options.timeout
+    });
+    try {
+      const result = await Promise.resolve(method.apply(target, args));
+      await transactionManager.commitTransaction(context.id);
+      return result;
+    } catch (error) {
+      if (this.shouldRollback(error, options.rollbackFor, options.noRollbackFor)) {
+        await transactionManager.rollbackTransaction(context.id);
+      } else {
+        await transactionManager.commitTransaction(context.id);
+      }
+      throw error;
+    }
+  }
+  static async executeInExistingTransaction(method, target, args, transactionId, transactionManager) {
+    return await Promise.resolve(method.apply(target, args));
+  }
+  static async executeInNestedTransaction(method, target, args, parentTransactionId, options, transactionManager) {
+    const savepointName = await transactionManager.createSavepoint(parentTransactionId);
+    try {
+      const result = await Promise.resolve(method.apply(target, args));
+      return result;
+    } catch (error) {
+      if (this.shouldRollback(error, options.rollbackFor, options.noRollbackFor)) {
+        await transactionManager.rollbackToSavepoint(parentTransactionId, savepointName);
+      }
+      throw error;
+    }
+  }
+  static shouldRollback(error, rollbackFor, noRollbackFor) {
+    if (!error) {
+      return false;
+    }
+    if (noRollbackFor && noRollbackFor.length > 0) {
+      for (const ErrorClass of noRollbackFor) {
+        if (error instanceof ErrorClass) {
+          return false;
+        }
+      }
+    }
+    if (rollbackFor && rollbackFor.length > 0) {
+      for (const ErrorClass of rollbackFor) {
+        if (error instanceof ErrorClass) {
+          return true;
+        }
+      }
+      return false;
+    }
+    return true;
+  }
+}
+var init_transaction_interceptor = __esm(() => {
+  init_transaction_types();
+  init_transaction_decorator();
+  init_transaction_types();
+});
+
 // src/request/body-parser.ts
 class BodyParser {
   static async parse(request) {
@@ -653,21 +969,23 @@ class MiddlewarePipeline {
     if (length === 0) {
       return await finalHandler();
     }
+    let currentIndex = 0;
     const called = new Array(length).fill(false);
-    const chain = new Array(length + 1);
-    chain[length] = finalHandler;
-    for (let i = length - 1;i >= 0; i--) {
-      const middleware = this.middlewares[i];
-      const downstream = chain[i + 1];
-      chain[i] = async () => {
-        if (called[i]) {
+    const createNext = (index) => {
+      if (index >= length) {
+        return finalHandler;
+      }
+      return async () => {
+        if (called[index]) {
           throw new Error("next() called multiple times");
         }
-        called[i] = true;
-        return await middleware(context, downstream);
+        called[index] = true;
+        currentIndex = index + 1;
+        const middleware = this.middlewares[index];
+        return await middleware(context, createNext(index + 1));
       };
-    }
-    return await chain[0]();
+    };
+    return await createNext(0)();
   }
 }
 
@@ -737,6 +1055,7 @@ class Router {
   routes = [];
   staticRoutes = new Map;
   dynamicRoutes = [];
+  matchCache = new Map;
   normalizePath(path) {
     if (path.length > 1 && path.endsWith("/")) {
       return path.slice(0, -1);
@@ -753,6 +1072,7 @@ class Router {
     } else {
       this.dynamicRoutes.push(route);
     }
+    this.matchCache.clear();
   }
   get(path, handler, middlewares = []) {
     this.register("GET", path, handler, middlewares);
@@ -770,14 +1090,29 @@ class Router {
     this.register("PATCH", path, handler, middlewares);
   }
   findRoute(method, path) {
-    const staticRoute = this.staticRoutes.get(`${method}:${path}`);
+    const result = this.findRouteWithMatch(method, path);
+    return result?.route;
+  }
+  findRouteWithMatch(method, path) {
+    const normalizedPath = this.normalizePath(path);
+    const cacheKey = `${method}:${normalizedPath}`;
+    const cached = this.matchCache.get(cacheKey);
+    if (cached && cached.match.matched) {
+      return cached;
+    }
+    const staticRoute = this.staticRoutes.get(cacheKey);
     if (staticRoute) {
-      return staticRoute;
+      const match = { matched: true, params: {} };
+      const result = { route: staticRoute, match };
+      this.matchCache.set(cacheKey, result);
+      return result;
     }
     for (const route of this.dynamicRoutes) {
-      const match = route.match(method, path);
+      const match = route.match(method, normalizedPath);
       if (match.matched) {
-        return route;
+        const result = { route, match };
+        this.matchCache.set(cacheKey, result);
+        return result;
       }
     }
     return;
@@ -785,11 +1120,11 @@ class Router {
   async preHandle(context) {
     const method = context.method;
     const path = this.normalizePath(context.path);
-    const route = this.findRoute(method, path);
-    if (!route) {
+    const result = this.findRouteWithMatch(method, path);
+    if (!result) {
       return;
     }
-    const match = route.match(method, path);
+    const { route, match } = result;
     if (match.matched) {
       context.params = match.params;
     }
@@ -801,13 +1136,22 @@ class Router {
     }
   }
   async handle(context) {
-    await this.preHandle(context);
     const method = context.method;
     const path = this.normalizePath(context.path);
-    const route = this.findRoute(method, path);
-    if (!route) {
+    const result = this.findRouteWithMatch(method, path);
+    if (!result) {
       return;
     }
+    const { route, match } = result;
+    if (match.matched) {
+      context.params = match.params;
+    }
+    if (route.controllerClass && route.methodName) {
+      context.routeHandler = {
+        controller: route.controllerClass,
+        method: route.methodName
+      };
+    }
     return await route.execute(context);
   }
   getRoutes() {
@@ -817,6 +1161,7 @@ class Router {
     this.routes.length = 0;
     this.dynamicRoutes.length = 0;
     this.staticRoutes.clear();
+    this.matchCache.clear();
   }
 }
 
@@ -1205,14 +1550,162 @@ function getParamMetadata(target, propertyKey) {
   return Reflect.getMetadata(PARAM_METADATA_KEY, target, propertyKey) || [];
 }
 
+// src/session/types.ts
+class MemorySessionStore {
+  store = new Map;
+  cleanupInterval;
+  constructor(options) {
+    if (options?.cleanupInterval !== undefined) {
+      this.cleanupInterval = setInterval(() => {
+        this.cleanup();
+      }, options.cleanupInterval);
+    }
+  }
+  async get(sessionId) {
+    const session = this.store.get(sessionId);
+    if (!session) {
+      return;
+    }
+    if (Date.now() > session.expiresAt) {
+      this.store.delete(sessionId);
+      return;
+    }
+    return session;
+  }
+  async set(session, maxAge) {
+    const now = Date.now();
+    session.expiresAt = now + maxAge;
+    session.lastAccessedAt = now;
+    this.store.set(session.id, session);
+    return true;
+  }
+  async delete(sessionId) {
+    return this.store.delete(sessionId);
+  }
+  async has(sessionId) {
+    const session = this.store.get(sessionId);
+    if (!session) {
+      return false;
+    }
+    if (Date.now() > session.expiresAt) {
+      this.store.delete(sessionId);
+      return false;
+    }
+    return true;
+  }
+  async touch(sessionId) {
+    const session = this.store.get(sessionId);
+    if (!session) {
+      return false;
+    }
+    if (Date.now() > session.expiresAt) {
+      this.store.delete(sessionId);
+      return false;
+    }
+    session.lastAccessedAt = Date.now();
+    return true;
+  }
+  async clear() {
+    this.store.clear();
+    return true;
+  }
+  cleanup() {
+    const now = Date.now();
+    for (const [sessionId, session] of this.store.entries()) {
+      if (now > session.expiresAt) {
+        this.store.delete(sessionId);
+      }
+    }
+  }
+  destroy() {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = undefined;
+    }
+    this.store.clear();
+  }
+}
+
+class RedisSessionStore {
+  client;
+  keyPrefix;
+  constructor(options) {
+    this.client = options.client;
+    this.keyPrefix = options.keyPrefix ?? "session:";
+  }
+  getKey(sessionId) {
+    return `${this.keyPrefix}${sessionId}`;
+  }
+  async get(sessionId) {
+    try {
+      const value = await this.client.get(this.getKey(sessionId));
+      if (value === null) {
+        return;
+      }
+      return JSON.parse(value);
+    } catch {
+      return;
+    }
+  }
+  async set(session, maxAge) {
+    try {
+      const serialized = JSON.stringify(session);
+      await this.client.set(this.getKey(session.id), serialized, {
+        PX: maxAge
+      });
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async delete(sessionId) {
+    try {
+      await this.client.del(this.getKey(sessionId));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async has(sessionId) {
+    try {
+      const result = await this.client.exists(this.getKey(sessionId));
+      return result === 1;
+    } catch {
+      return false;
+    }
+  }
+  async touch(sessionId) {
+    try {
+      const session = await this.get(sessionId);
+      if (!session) {
+        return false;
+      }
+      session.lastAccessedAt = Date.now();
+      const remainingTime = session.expiresAt - Date.now();
+      if (remainingTime > 0) {
+        await this.client.expire(this.getKey(sessionId), Math.floor(remainingTime / 1000));
+        return true;
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+  async clear() {
+    return false;
+  }
+}
+var SESSION_SERVICE_TOKEN = Symbol("@dangao/bun-server:session:service");
+var SESSION_OPTIONS_TOKEN = Symbol("@dangao/bun-server:session:options");
+
 // src/controller/param-binder.ts
 class ParamBinder {
-  static async bind(target, propertyKey, context) {
+  static async bind(target, propertyKey, context, container) {
     const metadata = getParamMetadata(target, propertyKey);
     const params = [];
     metadata.sort((a, b) => a.index - b.index);
     for (const meta of metadata) {
-      const value = await this.getValue(meta, context);
+      const value = await this.getValue(meta, context, container);
       params[meta.index] = value;
     }
     const maxIndex = metadata.length > 0 ? Math.max(...metadata.map((m) => m.index)) : -1;
@@ -1223,7 +1716,7 @@ class ParamBinder {
     }
     return params;
   }
-  static async getValue(meta, context) {
+  static async getValue(meta, context, container) {
     switch (meta.type) {
       case "body" /* BODY */:
         return await this.getBodyValue(meta.key, context);
@@ -1242,6 +1735,24 @@ class ParamBinder {
           throw new Error("@Header() decorator requires a key parameter");
         }
         return this.getHeaderValue(meta.key, context);
+      case "session" /* SESSION */:
+        if (!container) {
+          throw new Error("@Session() decorator requires a Container instance");
+        }
+        const session = context.session;
+        if (session) {
+          return session;
+        }
+        try {
+          const sessionService = container.resolve(SESSION_SERVICE_TOKEN);
+          if (sessionService) {
+            const newSession = await sessionService.create();
+            context.session = newSession;
+            context.sessionId = newSession.id;
+            return newSession;
+          }
+        } catch {}
+        return;
       default:
         return;
     }
@@ -1800,7 +2311,7 @@ class ControllerRegistry {
           const controllerContainer = this.controllerContainers.get(controllerClass) ?? this.container;
           const controllerInstance = controllerContainer.resolve(controllerClass);
           const prototype2 = controllerClass.prototype;
-          const params = await ParamBinder.bind(prototype2, propertyKey, context);
+          const params = await ParamBinder.bind(prototype2, propertyKey, context, controllerContainer);
           const validationMetadata = getValidationMetadata(prototype2, propertyKey);
           if (validationMetadata.length > 0) {
             validateParameters(params, validationMetadata);
@@ -1813,7 +2324,19 @@ class ControllerRegistry {
           if (!method || typeof method !== "function") {
             throw new Error(`Method ${propertyKey} not found on controller ${controllerClass.name}`);
           }
-          const result = method.apply(controllerInstance, params);
+          let result;
+          try {
+            const { TransactionInterceptor: TransactionInterceptor2 } = await Promise.resolve().then(() => (init_transaction_interceptor(), exports_transaction_interceptor));
+            const { getTransactionMetadata: getTransactionMetadata2 } = await Promise.resolve().then(() => (init_transaction_decorator(), exports_transaction_decorator));
+            const hasTransaction = getTransactionMetadata2(prototype2, propertyKey);
+            if (hasTransaction) {
+              result = TransactionInterceptor2.executeWithTransaction(prototype2, propertyKey, method, params, controllerContainer);
+            } else {
+              result = method.apply(controllerInstance, params);
+            }
+          } catch (error) {
+            result = method.apply(controllerInstance, params);
+          }
           const responseData = await Promise.resolve(result);
           if (responseData instanceof Response) {
             return responseData;
@@ -2174,10 +2697,11 @@ class Application {
   use(middleware) {
     this.middlewarePipeline.use(middleware);
   }
-  listen(port, hostname) {
+  async listen(port, hostname) {
     if (this.server?.isRunning()) {
       throw new Error("Application is already running");
     }
+    await this.initializeExtensions();
     const serverOptions = {
       port: port ?? this.options.port ?? 3000,
       hostname: hostname ?? this.options.hostname,
@@ -2187,9 +2711,27 @@ class Application {
     this.server = new BunServer(serverOptions);
     this.server.start();
   }
-  stop() {
+  async initializeExtensions() {
+    const container = this.getContainer();
+    for (const extension of this.extensions) {
+      if (extension && typeof extension === "object" && "initialize" in extension && typeof extension.initialize === "function") {
+        await extension.initialize(container);
+      }
+    }
+  }
+  async stop() {
+    await this.closeExtensions();
     this.server?.stop();
   }
+  async closeExtensions() {
+    const container = this.getContainer();
+    for (let i = this.extensions.length - 1;i >= 0; i--) {
+      const extension = this.extensions[i];
+      if (extension && typeof extension === "object" && "close" in extension && typeof extension.close === "function") {
+        await extension.close(container);
+      }
+    }
+  }
   async handleRequest(context) {
     if (["POST", "PUT", "PATCH"].includes(context.method)) {
       await context.getBody();
@@ -3245,19 +3787,19 @@ class OAuth2Controller {
   constructor(oauth2Service) {
     this.oauth2Service = oauth2Service;
   }
-  authorize(clientId, redirectUri, state, scope) {
-    const query = {
-      client_id: clientId,
-      redirect_uri: redirectUri,
-      ...state && { state },
-      ...scope && { scope }
-    };
+  authorize(clientId, redirectUri, responseType, state, scope) {
+    if (!clientId || !redirectUri) {
+      throw new Error("Missing required parameters: client_id and redirect_uri are required");
+    }
+    if (responseType !== "code") {
+      throw new Error(`Unsupported response_type: ${responseType}. Only 'code' is supported.`);
+    }
     const request = {
-      clientId: query.client_id || "",
-      redirectUri: query.redirect_uri || "",
+      clientId,
+      redirectUri,
       responseType: "code",
-      scope: query.scope,
-      state: query.state
+      scope: scope || undefined,
+      state: state || undefined
     };
     const validation = this.oauth2Service.validateAuthorizationRequest(request);
     if (!validation.valid) {
@@ -3318,13 +3860,15 @@ __legacyDecorateClassTS([
   GET("/authorize"),
   __legacyDecorateParamTS(0, Query("client_id")),
   __legacyDecorateParamTS(1, Query("redirect_uri")),
-  __legacyDecorateParamTS(2, Query("state")),
-  __legacyDecorateParamTS(3, Query("scope")),
+  __legacyDecorateParamTS(2, Query("response_type")),
+  __legacyDecorateParamTS(3, Query("state")),
+  __legacyDecorateParamTS(4, Query("scope")),
   __legacyMetadataTS("design:type", Function),
   __legacyMetadataTS("design:paramtypes", [
     String,
     String,
     String,
+    String,
     String
   ]),
   __legacyMetadataTS("design:returntype", undefined)
@@ -3903,73 +4447,1826 @@ function createHttpMetricsMiddleware(collector) {
     return response;
   };
 }
-// src/testing/harness.ts
-import { performance as performance2 } from "perf_hooks";
+// src/database/types.ts
+var DATABASE_SERVICE_TOKEN = Symbol("@dangao/bun-server:database:service");
+var DATABASE_OPTIONS_TOKEN = Symbol("@dangao/bun-server:database:options");
 
-class PerformanceHarness {
-  static async benchmark(name, iterations, runner) {
-    if (iterations <= 0) {
-      throw new Error("iterations must be greater than 0");
+// src/database/database-extension.ts
+class DatabaseExtension {
+  register(container) {}
+  async initialize(container) {
+    try {
+      const databaseService = container.resolve(DATABASE_SERVICE_TOKEN);
+      await databaseService.initialize();
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("Provider not found")) {
+        return;
+      }
+      throw error;
     }
-    const start = performance2.now();
-    for (let i = 0;i < iterations; i++) {
-      await runner(i);
+  }
+  async close(container) {
+    try {
+      const databaseService = container.resolve(DATABASE_SERVICE_TOKEN);
+      await databaseService.closePool();
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("Provider not found")) {
+        return;
+      }
+      throw error;
     }
-    const durationMs = performance2.now() - start;
-    const opsPerSecond = iterations / Math.max(durationMs / 1000, 0.0001);
-    return {
-      name,
-      iterations,
-      durationMs,
-      opsPerSecond
-    };
   }
 }
 
-class StressTester {
-  static async run(name, iterations, concurrency, task) {
-    if (iterations <= 0) {
-      throw new Error("iterations must be greater than 0");
-    }
-    if (concurrency <= 0) {
-      throw new Error("concurrency must be greater than 0");
-    }
-    let next = 0;
-    let errors = 0;
-    const start = performance2.now();
-    const worker = async () => {
-      while (true) {
-        const current = next;
-        next += 1;
-        if (current >= iterations) {
-          break;
+// src/database/health-indicator.ts
+class DatabaseHealthIndicator {
+  databaseService;
+  name = "database";
+  constructor(databaseService) {
+    this.databaseService = databaseService;
+  }
+  async check() {
+    try {
+      const isHealthy = await this.databaseService.healthCheck();
+      const connectionInfo = this.databaseService.getConnectionInfo();
+      if (isHealthy) {
+        return {
+          status: "up",
+          details: {
+            type: connectionInfo.type,
+            status: connectionInfo.status
+          }
+        };
+      }
+      return {
+        status: "down",
+        details: {
+          type: connectionInfo.type,
+          status: connectionInfo.status,
+          error: connectionInfo.error
         }
-        try {
-          await task(current);
-        } catch (error) {
-          errors += 1;
+      };
+    } catch (error) {
+      return {
+        status: "down",
+        details: {
+          error: error instanceof Error ? error.message : String(error)
         }
-      }
-    };
-    const workers = Array.from({ length: Math.min(concurrency, iterations) }, () => worker());
-    await Promise.all(workers);
-    const durationMs = performance2.now() - start;
-    return {
-      name,
-      iterations,
-      concurrency: Math.min(concurrency, iterations),
-      durationMs,
-      errors
-    };
+      };
+    }
+  }
+}
+
+// src/database/orm/service.ts
+class OrmService {
+  databaseService;
+  options;
+  drizzleInstance = null;
+  constructor(databaseService, options = {}) {
+    this.databaseService = databaseService;
+    this.options = options;
   }
+  getDrizzle() {
+    if (this.options.drizzle) {
+      return this.options.drizzle;
+    }
+    if (this.drizzleInstance) {
+      return this.drizzleInstance;
+    }
+    return null;
+  }
+  setDrizzle(drizzle) {
+    this.drizzleInstance = drizzle;
+  }
+  getDatabaseService() {
+    return this.databaseService;
+  }
+}
+OrmService = __legacyDecorateClassTS([
+  Injectable(),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof DatabaseService === "undefined" ? Object : DatabaseService,
+    typeof OrmModuleOptions === "undefined" ? Object : OrmModuleOptions
+  ])
+], OrmService);
+
+// src/database/orm/transaction-manager.ts
+init_transaction_types();
+class TransactionManager {
+  databaseService;
+  transactions = new Map;
+  connectionTransactions = new Map;
+  constructor(databaseService) {
+    this.databaseService = databaseService;
+  }
+  async beginTransaction(options = {}) {
+    const transactionId = this.generateTransactionId();
+    const context2 = {
+      id: transactionId,
+      status: "ACTIVE" /* ACTIVE */,
+      startTime: Date.now(),
+      level: 0,
+      savepoints: []
+    };
+    const connection = await this.databaseService.getConnection();
+    this.connectionTransactions.set(connection, transactionId);
+    this.transactions.set(transactionId, context2);
+    await this.executeBegin(connection, options);
+    return context2;
+  }
+  async commitTransaction(transactionId) {
+    const context2 = this.transactions.get(transactionId);
+    if (!context2) {
+      throw new Error(`Transaction ${transactionId} not found`);
+    }
+    if (context2.status !== "ACTIVE" /* ACTIVE */) {
+      throw new Error(`Transaction ${transactionId} is not active`);
+    }
+    const connection = this.findConnectionByTransactionId(transactionId);
+    if (!connection) {
+      throw new Error(`Connection not found for transaction ${transactionId}`);
+    }
+    await this.executeCommit(connection);
+    context2.status = "COMMITTED" /* COMMITTED */;
+    this.cleanupTransaction(transactionId);
+  }
+  async rollbackTransaction(transactionId) {
+    const context2 = this.transactions.get(transactionId);
+    if (!context2) {
+      throw new Error(`Transaction ${transactionId} not found`);
+    }
+    const connection = this.findConnectionByTransactionId(transactionId);
+    if (!connection) {
+      throw new Error(`Connection not found for transaction ${transactionId}`);
+    }
+    await this.executeRollback(connection);
+    context2.status = "ROLLED_BACK" /* ROLLED_BACK */;
+    this.cleanupTransaction(transactionId);
+  }
+  async createSavepoint(transactionId) {
+    const context2 = this.transactions.get(transactionId);
+    if (!context2) {
+      throw new Error(`Transaction ${transactionId} not found`);
+    }
+    const savepointName = `sp_${context2.level}_${Date.now()}`;
+    context2.savepoints = context2.savepoints || [];
+    context2.savepoints.push(savepointName);
+    context2.level += 1;
+    const connection = this.findConnectionByTransactionId(transactionId);
+    if (connection) {
+      await this.executeSavepoint(connection, savepointName);
+    }
+    return savepointName;
+  }
+  async rollbackToSavepoint(transactionId, savepointName) {
+    const context2 = this.transactions.get(transactionId);
+    if (!context2) {
+      throw new Error(`Transaction ${transactionId} not found`);
+    }
+    const connection = this.findConnectionByTransactionId(transactionId);
+    if (connection) {
+      await this.executeRollbackToSavepoint(connection, savepointName);
+    }
+    const index = context2.savepoints?.indexOf(savepointName) ?? -1;
+    if (index >= 0 && context2.savepoints) {
+      context2.savepoints = context2.savepoints.slice(0, index);
+      context2.level = index;
+    }
+  }
+  getCurrentTransaction() {
+    for (const context2 of this.transactions.values()) {
+      if (context2.status === "ACTIVE" /* ACTIVE */) {
+        return context2;
+      }
+    }
+    return null;
+  }
+  hasActiveTransaction() {
+    return this.getCurrentTransaction() !== null;
+  }
+  generateTransactionId() {
+    return `tx_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+  }
+  findConnectionByTransactionId(transactionId) {
+    for (const [connection, txId] of this.connectionTransactions.entries()) {
+      if (txId === transactionId) {
+        return connection;
+      }
+    }
+    return null;
+  }
+  cleanupTransaction(transactionId) {
+    this.transactions.delete(transactionId);
+    for (const [connection, txId] of this.connectionTransactions.entries()) {
+      if (txId === transactionId) {
+        this.connectionTransactions.delete(connection);
+        break;
+      }
+    }
+  }
+  async executeBegin(connection, options) {
+    const dbType = this.databaseService["config"].database.type;
+    if (dbType === "sqlite") {
+      await this.databaseService.query("BEGIN TRANSACTION");
+    } else if (dbType === "postgres" || dbType === "mysql") {
+      let sql = "START TRANSACTION";
+      if (options.isolationLevel) {
+        const isolation = this.getIsolationLevelSQL(options.isolationLevel);
+        sql += ` ${isolation}`;
+      }
+      if (options.readOnly) {
+        sql += " READ ONLY";
+      }
+      await this.databaseService.query(sql);
+    }
+  }
+  async executeCommit(connection) {
+    await this.databaseService.query("COMMIT");
+  }
+  async executeRollback(connection) {
+    await this.databaseService.query("ROLLBACK");
+  }
+  async executeSavepoint(connection, savepointName) {
+    await this.databaseService.query(`SAVEPOINT ${savepointName}`);
+  }
+  async executeRollbackToSavepoint(connection, savepointName) {
+    await this.databaseService.query(`ROLLBACK TO SAVEPOINT ${savepointName}`);
+  }
+  getIsolationLevelSQL(level) {
+    const dbType = this.databaseService["config"].database.type;
+    const levelMap = {
+      ["READ_UNCOMMITTED" /* READ_UNCOMMITTED */]: "READ UNCOMMITTED",
+      ["READ_COMMITTED" /* READ_COMMITTED */]: "READ COMMITTED",
+      ["REPEATABLE_READ" /* REPEATABLE_READ */]: "REPEATABLE READ",
+      ["SERIALIZABLE" /* SERIALIZABLE */]: "SERIALIZABLE"
+    };
+    if (dbType === "postgres") {
+      return `SET TRANSACTION ISOLATION LEVEL ${levelMap[level]}`;
+    } else if (dbType === "mysql") {
+      return `SET TRANSACTION ISOLATION LEVEL ${levelMap[level]}`;
+    }
+    return "";
+  }
+}
+TransactionManager = __legacyDecorateClassTS([
+  Injectable(),
+  __legacyDecorateParamTS(0, Inject(DATABASE_SERVICE_TOKEN)),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof DatabaseService === "undefined" ? Object : DatabaseService
+  ])
+], TransactionManager);
+
+// src/database/connection-pool.ts
+class ConnectionPool {
+  config;
+  options;
+  connections = [];
+  pendingConnections = new Set;
+  isClosing = false;
+  constructor(config, options = {}) {
+    this.config = config;
+    this.options = {
+      maxConnections: options.maxConnections ?? 10,
+      connectionTimeout: options.connectionTimeout ?? 30000,
+      retryCount: options.retryCount ?? 3,
+      retryDelay: options.retryDelay ?? 1000
+    };
+  }
+  async acquire() {
+    if (this.isClosing) {
+      throw new Error("Connection pool is closing");
+    }
+    const idleConnection = this.connections.find((conn) => !conn.inUse);
+    if (idleConnection) {
+      idleConnection.inUse = true;
+      idleConnection.lastUsedAt = Date.now();
+      return idleConnection.connection;
+    }
+    if (this.connections.length < this.options.maxConnections) {
+      const connection = await this.createConnection();
+      const poolConnection = {
+        connection,
+        inUse: true,
+        createdAt: Date.now(),
+        lastUsedAt: Date.now()
+      };
+      this.connections.push(poolConnection);
+      return connection;
+    }
+    return await this.waitForConnection();
+  }
+  release(connection) {
+    const poolConnection = this.connections.find((conn) => conn.connection === connection);
+    if (poolConnection) {
+      poolConnection.inUse = false;
+      poolConnection.lastUsedAt = Date.now();
+    }
+  }
+  async close() {
+    this.isClosing = true;
+    await Promise.all(Array.from(this.pendingConnections));
+    const closePromises = this.connections.map((poolConnection) => this.closeConnection(poolConnection.connection));
+    await Promise.all(closePromises);
+    this.connections = [];
+    this.isClosing = false;
+  }
+  getPoolStats() {
+    const inUse = this.connections.filter((conn) => conn.inUse).length;
+    return {
+      total: this.connections.length,
+      inUse,
+      idle: this.connections.length - inUse,
+      maxConnections: this.options.maxConnections
+    };
+  }
+  async createConnection() {
+    const createPromise = this.createConnectionWithRetry();
+    this.pendingConnections.add(createPromise);
+    try {
+      const connection = await createPromise;
+      return connection;
+    } finally {
+      this.pendingConnections.delete(createPromise);
+    }
+  }
+  async createConnectionWithRetry() {
+    let lastError;
+    for (let i = 0;i <= this.options.retryCount; i++) {
+      try {
+        if (this.config.type === "sqlite") {
+          return await this.createSqliteConnection(this.config.config);
+        } else if (this.config.type === "postgres") {
+          return await this.createPostgresConnection(this.config.config);
+        } else if (this.config.type === "mysql") {
+          return await this.createMysqlConnection(this.config.config);
+        }
+      } catch (error) {
+        lastError = error instanceof Error ? error : new Error(String(error));
+        if (i < this.options.retryCount) {
+          await this.sleep(this.options.retryDelay);
+        }
+      }
+    }
+    throw lastError ?? new Error("Failed to create database connection");
+  }
+  async createSqliteConnection(config) {
+    const { Database } = await import("bun:sqlite");
+    const db = new Database(config.path);
+    return db;
+  }
+  async createPostgresConnection(config) {
+    const url = `postgres://${config.user}:${config.password}@${config.host}:${config.port}/${config.database}`;
+    const { SQL } = await Promise.resolve(globalThis.Bun);
+    return new SQL(url, {
+      max: 1,
+      tls: config.ssl ?? false
+    });
+  }
+  async createMysqlConnection(config) {
+    const url = `mysql://${config.user}:${config.password}@${config.host}:${config.port}/${config.database}`;
+    const { SQL } = await Promise.resolve(globalThis.Bun);
+    return new SQL(url, {
+      max: 1
+    });
+  }
+  async closeConnection(connection) {
+    const dbType = this.config.type;
+    if (dbType === "sqlite") {
+      await this.closeSqliteConnection(connection);
+    } else if (dbType === "postgres") {
+      await this.closePostgresConnection(connection);
+    } else if (dbType === "mysql") {
+      await this.closeMysqlConnection(connection);
+    }
+  }
+  async closeSqliteConnection(connection) {
+    if (connection && typeof connection === "object" && "close" in connection && typeof connection.close === "function") {
+      connection.close();
+    }
+  }
+  async closePostgresConnection(_connection) {
+    if (_connection && typeof _connection === "object" && "close" in _connection && typeof _connection.close === "function") {
+      _connection.close();
+    }
+  }
+  async closeMysqlConnection(_connection) {
+    if (_connection && typeof _connection === "object" && "close" in _connection && typeof _connection.close === "function") {
+      _connection.close();
+    }
+  }
+  async waitForConnection() {
+    const startTime = Date.now();
+    const timeout = this.options.connectionTimeout;
+    while (Date.now() - startTime < timeout) {
+      const idleConnection = this.connections.find((conn) => !conn.inUse);
+      if (idleConnection) {
+        idleConnection.inUse = true;
+        idleConnection.lastUsedAt = Date.now();
+        return idleConnection.connection;
+      }
+      await this.sleep(100);
+    }
+    throw new Error(`Connection timeout: No available connection within ${timeout}ms`);
+  }
+  sleep(ms) {
+    return new Promise((resolve2) => setTimeout(resolve2, ms));
+  }
+}
+
+// src/database/connection-manager.ts
+class DatabaseConnectionManager {
+  config;
+  poolOptions;
+  pool;
+  currentConnection = null;
+  status = "disconnected";
+  error;
+  constructor(config, poolOptions = {}) {
+    this.config = config;
+    this.poolOptions = {
+      maxConnections: poolOptions.maxConnections ?? 10,
+      connectionTimeout: poolOptions.connectionTimeout ?? 30000,
+      retryCount: poolOptions.retryCount ?? 3,
+      retryDelay: poolOptions.retryDelay ?? 1000
+    };
+    this.pool = new ConnectionPool(config, this.poolOptions);
+  }
+  async connect() {
+    if (this.status === "connected") {
+      return;
+    }
+    this.status = "connecting";
+    try {
+      this.currentConnection = await this.pool.acquire();
+      this.status = "connected";
+      this.error = undefined;
+    } catch (error) {
+      this.status = "error";
+      this.error = error instanceof Error ? error.message : String(error);
+      throw error;
+    }
+  }
+  async disconnect() {
+    if (this.status === "disconnected" || !this.currentConnection) {
+      return;
+    }
+    try {
+      this.pool.release(this.currentConnection);
+      this.currentConnection = null;
+      this.status = "disconnected";
+      this.error = undefined;
+    } catch (error) {
+      this.status = "error";
+      this.error = error instanceof Error ? error.message : String(error);
+      throw error;
+    }
+  }
+  async closePool() {
+    await this.pool.close();
+    this.currentConnection = null;
+    this.status = "disconnected";
+    this.error = undefined;
+  }
+  async healthCheck() {
+    if (this.status !== "connected" || !this.currentConnection) {
+      return false;
+    }
+    try {
+      if (this.config.type === "sqlite") {
+        return await this.healthCheckSqlite(this.currentConnection);
+      } else if (this.config.type === "postgres") {
+        return await this.healthCheckPostgres(this.currentConnection);
+      } else if (this.config.type === "mysql") {
+        return await this.healthCheckMysql(this.currentConnection);
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+  getPoolStats() {
+    return this.pool.getPoolStats();
+  }
+  getConnectionInfo() {
+    return {
+      status: this.status,
+      type: this.config.type,
+      error: this.error
+    };
+  }
+  getConnection() {
+    return this.currentConnection;
+  }
+  async acquireConnection() {
+    return await this.pool.acquire();
+  }
+  releaseConnection(connection) {
+    this.pool.release(connection);
+  }
+  getDatabaseType() {
+    return this.config.type;
+  }
+  async healthCheckSqlite(connection) {
+    try {
+      if (connection && typeof connection === "object" && "query" in connection && typeof connection.query === "function") {
+        const db = connection;
+        db.query("SELECT 1").all();
+        return true;
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+  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 {
+      return false;
+    }
+  }
+  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 {
+      return false;
+    }
+  }
+}
+
+// src/database/service.ts
+class DatabaseService2 {
+  connectionManager;
+  options;
+  constructor(options) {
+    this.options = options;
+    this.connectionManager = new DatabaseConnectionManager(options.database, options.pool);
+  }
+  async initialize() {
+    await this.connectionManager.connect();
+  }
+  async close() {
+    await this.connectionManager.disconnect();
+  }
+  async closePool() {
+    await this.connectionManager.closePool();
+  }
+  getPoolStats() {
+    return this.connectionManager.getPoolStats();
+  }
+  getConnection() {
+    return this.connectionManager.getConnection();
+  }
+  get config() {
+    return this.options;
+  }
+  getDatabaseType() {
+    return this.connectionManager.getDatabaseType();
+  }
+  async healthCheck() {
+    if (!this.options.enableHealthCheck) {
+      return true;
+    }
+    return await this.connectionManager.healthCheck();
+  }
+  getConnectionInfo() {
+    return this.connectionManager.getConnectionInfo();
+  }
+  query(sql, params) {
+    const connection = this.getConnection();
+    if (!connection) {
+      throw new Error("Database connection is not established");
+    }
+    const dbType = this.getDatabaseType();
+    if (dbType === "sqlite") {
+      return this.querySqlite(connection, sql, params);
+    } else if (dbType === "postgres" || dbType === "mysql") {
+      return this.queryBunSQL(connection, sql, params);
+    }
+    throw new Error(`Query not supported for database type: ${dbType}`);
+  }
+  querySqlite(connection, sql, params) {
+    if (connection && typeof connection === "object" && "query" in connection && typeof connection.query === "function") {
+      const db = connection;
+      const statement = db.query(sql);
+      const result = params && params.length > 0 ? statement.all(...params) : statement.all();
+      return result;
+    }
+    throw new Error("Invalid SQLite connection");
+  }
+  async queryBunSQL(connection, sql, params) {
+    if (connection && typeof connection === "function") {
+      try {
+        const sqlWithParams = this.interpolateParams(sql, params);
+        const result = await connection`${sqlWithParams}`;
+        return result;
+      } catch {
+        throw new Error("Bun.SQL parameterized queries are not fully supported. Consider using template string queries.");
+      }
+    }
+    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");
+  }
+  interpolateParams(sql, params) {
+    if (!params || params.length === 0) {
+      return sql;
+    }
+    let result = sql;
+    for (let i = 0;i < params.length; i++) {
+      const param = params[i];
+      const value = typeof param === "string" ? `'${param.replace(/'/g, "''")}'` : String(param);
+      result = result.replace("?", value);
+    }
+    return result;
+  }
+}
+DatabaseService2 = __legacyDecorateClassTS([
+  Injectable(),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof DatabaseModuleOptions === "undefined" ? Object : DatabaseModuleOptions
+  ])
+], DatabaseService2);
+
+// src/database/orm/types.ts
+var ORM_SERVICE_TOKEN = Symbol("@dangao/bun-server:orm:service");
+
+// src/database/database-module.ts
+init_transaction_types();
+class DatabaseModule {
+  static forRoot(options) {
+    const providers2 = [];
+    const service = new DatabaseService2(options);
+    providers2.push({
+      provide: DATABASE_SERVICE_TOKEN,
+      useValue: service
+    }, {
+      provide: DATABASE_OPTIONS_TOKEN,
+      useValue: options
+    }, DatabaseService2);
+    if (options.orm?.enabled) {
+      const ormService = new OrmService(service, {
+        enabled: true,
+        drizzle: options.orm.drizzle,
+        databaseService: service
+      });
+      providers2.push({
+        provide: ORM_SERVICE_TOKEN,
+        useValue: ormService
+      }, OrmService);
+    }
+    const transactionManager = new TransactionManager(service);
+    providers2.push({
+      provide: TRANSACTION_SERVICE_TOKEN,
+      useValue: transactionManager
+    }, TransactionManager);
+    const existingMetadata = Reflect.getMetadata(MODULE_METADATA_KEY, DatabaseModule) || {};
+    const databaseExtension = new DatabaseExtension;
+    const metadata = {
+      ...existingMetadata,
+      providers: [...existingMetadata.providers || [], ...providers2],
+      exports: [
+        ...existingMetadata.exports || [],
+        DATABASE_SERVICE_TOKEN,
+        DATABASE_OPTIONS_TOKEN,
+        DatabaseService2,
+        TRANSACTION_SERVICE_TOKEN,
+        TransactionManager,
+        ...options.orm?.enabled ? [ORM_SERVICE_TOKEN, OrmService] : []
+      ],
+      extensions: [
+        ...existingMetadata.extensions || [],
+        databaseExtension
+      ]
+    };
+    Reflect.defineMetadata(MODULE_METADATA_KEY, metadata, DatabaseModule);
+    return DatabaseModule;
+  }
+  static createHealthIndicator(databaseService) {
+    return new DatabaseHealthIndicator(databaseService);
+  }
+}
+DatabaseModule = __legacyDecorateClassTS([
+  Module({
+    providers: []
+  })
+], DatabaseModule);
+// src/database/orm/decorators.ts
+import"reflect-metadata";
+var ENTITY_METADATA_KEY = Symbol("@dangao/bun-server:orm:entity");
+var COLUMN_METADATA_KEY = Symbol("@dangao/bun-server:orm:column");
+function Entity(tableName) {
+  return (target) => {
+    Reflect.defineMetadata(ENTITY_METADATA_KEY, { tableName }, target);
+  };
+}
+function Column(options) {
+  return (target, propertyKey) => {
+    const existingColumns = Reflect.getMetadata(COLUMN_METADATA_KEY, target.constructor) || [];
+    const existingIndex = existingColumns.findIndex((col) => col.propertyKey === String(propertyKey));
+    const columnDef = {
+      name: options?.name ?? String(propertyKey),
+      type: options?.type ?? "TEXT",
+      primaryKey: options?.primaryKey ?? false,
+      autoIncrement: options?.autoIncrement ?? false,
+      nullable: options?.nullable !== undefined ? options.nullable : true,
+      defaultValue: options?.defaultValue,
+      propertyKey: String(propertyKey)
+    };
+    if (existingIndex >= 0) {
+      const existing = existingColumns[existingIndex];
+      existingColumns[existingIndex] = {
+        ...existing,
+        name: options?.name ?? existing.name,
+        type: options?.type ?? existing.type,
+        primaryKey: options?.primaryKey !== undefined ? options.primaryKey : existing.primaryKey,
+        nullable: options?.nullable !== undefined ? options.nullable : existing.nullable,
+        autoIncrement: options?.autoIncrement !== undefined ? options.autoIncrement : existing.autoIncrement,
+        defaultValue: options?.defaultValue !== undefined ? options.defaultValue : existing.defaultValue,
+        propertyKey: String(propertyKey)
+      };
+    } else {
+      existingColumns.push(columnDef);
+    }
+    Reflect.defineMetadata(COLUMN_METADATA_KEY, existingColumns, target.constructor);
+  };
+}
+function PrimaryKey() {
+  return Column({ primaryKey: true, nullable: false });
+}
+function getEntityMetadata(target) {
+  if (typeof target === "function" || typeof target === "object" && target !== null) {
+    return Reflect.getMetadata(ENTITY_METADATA_KEY, target);
+  }
+  return;
+}
+function getColumnMetadata(target) {
+  if (typeof target === "function" || typeof target === "object" && target !== null) {
+    return Reflect.getMetadata(COLUMN_METADATA_KEY, target) || [];
+  }
+  return [];
+}
+// src/database/orm/repository-decorator.ts
+import"reflect-metadata";
+var REPOSITORY_METADATA_KEY = Symbol("@dangao/bun-server:orm:repository");
+function Repository(tableName, primaryKey = "id") {
+  return function(target) {
+    Injectable()(target);
+    Reflect.defineMetadata(REPOSITORY_METADATA_KEY, { tableName, primaryKey }, target);
+    return target;
+  };
+}
+function getRepositoryMetadata(target) {
+  if (typeof target === "function" || typeof target === "object" && target !== null) {
+    return Reflect.getMetadata(REPOSITORY_METADATA_KEY, target);
+  }
+  return;
+}
+
+// src/database/orm/index.ts
+init_transaction_decorator();
+
+// src/database/orm/repository.ts
+class BaseRepository {
+  databaseService;
+  constructor(databaseService) {
+    this.databaseService = databaseService;
+  }
+  async findAll() {
+    const sql = `SELECT * FROM ${this.tableName}`;
+    const result = await this.executeQuery(sql);
+    return Array.isArray(result) ? result : [];
+  }
+  async findById(id) {
+    const sql = `SELECT * FROM ${this.tableName} WHERE ${this.primaryKey} = ?`;
+    const result = await this.executeQuery(sql, [id]);
+    if (Array.isArray(result) && result.length > 0) {
+      return result[0];
+    }
+    return null;
+  }
+  async create(data) {
+    const keys = Object.keys(data);
+    const values = Object.values(data);
+    const placeholders = keys.map(() => "?").join(", ");
+    const sql = `INSERT INTO ${this.tableName} (${keys.join(", ")}) VALUES (${placeholders})`;
+    await this.executeQuery(sql, values);
+    const lastIdResult = await this.executeQuery("SELECT last_insert_rowid() as id");
+    const lastId = Array.isArray(lastIdResult) && lastIdResult[0] ? lastIdResult[0].id : null;
+    if (lastId !== null) {
+      return await this.findById(lastId);
+    }
+    return data;
+  }
+  async update(id, data) {
+    const keys = Object.keys(data);
+    const values = Object.values(data);
+    const setClause = keys.map((key) => `${key} = ?`).join(", ");
+    const sql = `UPDATE ${this.tableName} SET ${setClause} WHERE ${this.primaryKey} = ?`;
+    await this.executeQuery(sql, [...values, id]);
+    return await this.findById(id);
+  }
+  async delete(id) {
+    const sql = `DELETE FROM ${this.tableName} WHERE ${this.primaryKey} = ?`;
+    await this.executeQuery(sql, [id]);
+    return true;
+  }
+  async executeQuery(sql, params) {
+    const result = this.databaseService.query(sql, params);
+    if (result instanceof Promise) {
+      const resolved = await result;
+      return Array.isArray(resolved) ? resolved : [resolved];
+    }
+    return Array.isArray(result) ? result : [result];
+  }
+}
+BaseRepository = __legacyDecorateClassTS([
+  __legacyDecorateParamTS(0, Inject(DATABASE_SERVICE_TOKEN)),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof DatabaseService === "undefined" ? Object : DatabaseService
+  ])
+], BaseRepository);
+// src/database/orm/drizzle-repository.ts
+class DrizzleBaseRepository {
+  databaseService;
+  constructor(databaseService) {
+    this.databaseService = databaseService;
+  }
+}
+
+// src/database/orm/index.ts
+init_transaction_interceptor();
+init_transaction_types();
+// src/testing/harness.ts
+import { performance as performance2 } from "perf_hooks";
+
+class PerformanceHarness {
+  static async benchmark(name, iterations, runner) {
+    if (iterations <= 0) {
+      throw new Error("iterations must be greater than 0");
+    }
+    const start = performance2.now();
+    for (let i = 0;i < iterations; i++) {
+      await runner(i);
+    }
+    const durationMs = performance2.now() - start;
+    const opsPerSecond = iterations / Math.max(durationMs / 1000, 0.0001);
+    return {
+      name,
+      iterations,
+      durationMs,
+      opsPerSecond
+    };
+  }
+}
+
+class StressTester {
+  static async run(name, iterations, concurrency, task) {
+    if (iterations <= 0) {
+      throw new Error("iterations must be greater than 0");
+    }
+    if (concurrency <= 0) {
+      throw new Error("concurrency must be greater than 0");
+    }
+    let next = 0;
+    let errors = 0;
+    const start = performance2.now();
+    const worker = async () => {
+      while (true) {
+        const current = next;
+        next += 1;
+        if (current >= iterations) {
+          break;
+        }
+        try {
+          await task(current);
+        } catch (error) {
+          errors += 1;
+        }
+      }
+    };
+    const workers = Array.from({ length: Math.min(concurrency, iterations) }, () => worker());
+    await Promise.all(workers);
+    const durationMs = performance2.now() - start;
+    return {
+      name,
+      iterations,
+      concurrency: Math.min(concurrency, iterations),
+      durationMs,
+      errors
+    };
+  }
+}
+// src/cache/types.ts
+class MemoryCacheStore {
+  store = new Map;
+  cleanupInterval;
+  constructor(options) {
+    if (options?.cleanupInterval !== undefined) {
+      this.cleanupInterval = setInterval(() => {
+        this.cleanup();
+      }, options.cleanupInterval);
+    }
+  }
+  async get(key) {
+    const entry = this.store.get(key);
+    if (!entry) {
+      return;
+    }
+    if (entry.expiresAt && Date.now() > entry.expiresAt) {
+      this.store.delete(key);
+      return;
+    }
+    return entry.value;
+  }
+  async set(key, value, ttl) {
+    const expiresAt = ttl && ttl > 0 ? Date.now() + ttl : undefined;
+    this.store.set(key, { value, expiresAt });
+    return true;
+  }
+  async delete(key) {
+    return this.store.delete(key);
+  }
+  async has(key) {
+    const entry = this.store.get(key);
+    if (!entry) {
+      return false;
+    }
+    if (entry.expiresAt && Date.now() > entry.expiresAt) {
+      this.store.delete(key);
+      return false;
+    }
+    return true;
+  }
+  async clear() {
+    this.store.clear();
+    return true;
+  }
+  async getMany(keys) {
+    const result = new Map;
+    const now = Date.now();
+    for (const key of keys) {
+      const entry = this.store.get(key);
+      if (entry) {
+        if (entry.expiresAt && now > entry.expiresAt) {
+          this.store.delete(key);
+          continue;
+        }
+        result.set(key, entry.value);
+      }
+    }
+    return result;
+  }
+  async setMany(entries, ttl) {
+    const expiresAt = ttl && ttl > 0 ? Date.now() + ttl : undefined;
+    for (const { key, value } of entries) {
+      this.store.set(key, { value, expiresAt });
+    }
+    return true;
+  }
+  async deleteMany(keys) {
+    const deleted = [];
+    for (const key of keys) {
+      if (this.store.delete(key)) {
+        deleted.push(key);
+      }
+    }
+    return deleted;
+  }
+  cleanup() {
+    const now = Date.now();
+    for (const [key, entry] of this.store.entries()) {
+      if (entry.expiresAt && now > entry.expiresAt) {
+        this.store.delete(key);
+      }
+    }
+  }
+  destroy() {
+    if (this.cleanupInterval) {
+      clearInterval(this.cleanupInterval);
+      this.cleanupInterval = undefined;
+    }
+    this.store.clear();
+  }
+}
+
+class RedisCacheStore {
+  client;
+  keyPrefix;
+  constructor(options) {
+    this.client = options.client;
+    this.keyPrefix = options.keyPrefix ?? "cache:";
+  }
+  getKey(key) {
+    return `${this.keyPrefix}${key}`;
+  }
+  async get(key) {
+    const value = await this.client.get(this.getKey(key));
+    if (value === null) {
+      return;
+    }
+    try {
+      return JSON.parse(value);
+    } catch {
+      return;
+    }
+  }
+  async set(key, value, ttl) {
+    try {
+      const serialized = JSON.stringify(value);
+      if (ttl && ttl > 0) {
+        await this.client.set(this.getKey(key), serialized, { PX: ttl });
+      } else {
+        await this.client.set(this.getKey(key), serialized);
+      }
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async delete(key) {
+    try {
+      await this.client.del(this.getKey(key));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async has(key) {
+    try {
+      const result = await this.client.exists(this.getKey(key));
+      return result === 1;
+    } catch {
+      return false;
+    }
+  }
+  async clear() {
+    try {
+      await this.client.flushdb();
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async getMany(keys) {
+    const result = new Map;
+    if (keys.length === 0) {
+      return result;
+    }
+    try {
+      const prefixedKeys = keys.map((k) => this.getKey(k));
+      const values = await this.client.mget(prefixedKeys);
+      for (let i = 0;i < keys.length; i++) {
+        const value = values[i];
+        if (value !== null) {
+          try {
+            result.set(keys[i], JSON.parse(value));
+          } catch {}
+        }
+      }
+    } catch {}
+    return result;
+  }
+  async setMany(entries, ttl) {
+    if (entries.length === 0) {
+      return true;
+    }
+    try {
+      const redisEntries = entries.map(({ key, value }) => ({
+        key: this.getKey(key),
+        value: JSON.stringify(value)
+      }));
+      await this.client.mset(redisEntries);
+      if (ttl && ttl > 0) {
+        for (const entry of redisEntries) {
+          await this.client.set(entry.key, entry.value, { PX: ttl });
+        }
+      }
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  async deleteMany(keys) {
+    if (keys.length === 0) {
+      return [];
+    }
+    try {
+      const prefixedKeys = keys.map((k) => this.getKey(k));
+      const deleted = [];
+      for (const key of prefixedKeys) {
+        try {
+          await this.client.del(key);
+          deleted.push(key.replace(this.keyPrefix, ""));
+        } catch {}
+      }
+      return deleted;
+    } catch {
+      return [];
+    }
+  }
+}
+var CACHE_SERVICE_TOKEN = Symbol("@dangao/bun-server:cache:service");
+var CACHE_OPTIONS_TOKEN = Symbol("@dangao/bun-server:cache:options");
+
+// src/cache/service.ts
+class CacheService {
+  store;
+  defaultTtl;
+  keyPrefix;
+  constructor(options) {
+    this.store = options.store;
+    this.defaultTtl = options.defaultTtl ?? 3600000;
+    this.keyPrefix = options.keyPrefix ?? "";
+  }
+  async get(key) {
+    return this.store.get(this.getKey(key));
+  }
+  async set(key, value, ttl) {
+    const finalTtl = ttl !== undefined ? ttl : this.defaultTtl;
+    return this.store.set(this.getKey(key), value, finalTtl);
+  }
+  async delete(key) {
+    return this.store.delete(this.getKey(key));
+  }
+  async has(key) {
+    return this.store.has(this.getKey(key));
+  }
+  async clear() {
+    return this.store.clear();
+  }
+  async getMany(keys) {
+    const prefixedKeys = keys.map((k) => this.getKey(k));
+    const result = await this.store.getMany(prefixedKeys);
+    const map = new Map;
+    for (const [key, value] of result.entries()) {
+      map.set(key.replace(this.keyPrefix, ""), value);
+    }
+    return map;
+  }
+  async setMany(entries, ttl) {
+    const finalTtl = ttl !== undefined ? ttl : this.defaultTtl;
+    const prefixedEntries = entries.map(({ key, value }) => ({
+      key: this.getKey(key),
+      value
+    }));
+    return this.store.setMany(prefixedEntries, finalTtl);
+  }
+  async deleteMany(keys) {
+    const prefixedKeys = keys.map((k) => this.getKey(k));
+    const deleted = await this.store.deleteMany(prefixedKeys);
+    return deleted.map((k) => k.replace(this.keyPrefix, ""));
+  }
+  async getOrSet(key, factory, ttl) {
+    const cached = await this.get(key);
+    if (cached !== undefined) {
+      return cached;
+    }
+    const value = await factory();
+    await this.set(key, value, ttl);
+    return value;
+  }
+  getKey(key) {
+    return this.keyPrefix ? `${this.keyPrefix}${key}` : key;
+  }
+}
+CacheService = __legacyDecorateClassTS([
+  Injectable(),
+  __legacyDecorateParamTS(0, Inject(CACHE_OPTIONS_TOKEN)),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof CacheModuleOptions === "undefined" ? Object : CacheModuleOptions
+  ])
+], CacheService);
+
+// src/cache/cache-module.ts
+class CacheModule {
+  static forRoot(options = {}) {
+    const providers2 = [];
+    const store = options.store ?? new MemoryCacheStore({
+      cleanupInterval: 60000
+    });
+    const service = new CacheService({
+      store,
+      defaultTtl: options.defaultTtl,
+      keyPrefix: options.keyPrefix
+    });
+    providers2.push({
+      provide: CACHE_SERVICE_TOKEN,
+      useValue: service
+    }, {
+      provide: CACHE_OPTIONS_TOKEN,
+      useValue: options
+    }, CacheService);
+    const existingMetadata = Reflect.getMetadata(MODULE_METADATA_KEY, CacheModule) || {};
+    const metadata = {
+      ...existingMetadata,
+      providers: [...existingMetadata.providers || [], ...providers2],
+      exports: [
+        ...existingMetadata.exports || [],
+        CACHE_SERVICE_TOKEN,
+        CACHE_OPTIONS_TOKEN,
+        CacheService
+      ]
+    };
+    Reflect.defineMetadata(MODULE_METADATA_KEY, metadata, CacheModule);
+    return CacheModule;
+  }
+}
+CacheModule = __legacyDecorateClassTS([
+  Module({
+    providers: []
+  })
+], CacheModule);
+// src/cache/decorators.ts
+import"reflect-metadata";
+var CACHEABLE_METADATA_KEY = Symbol("@dangao/bun-server:cache:cacheable");
+var CACHE_EVICT_METADATA_KEY = Symbol("@dangao/bun-server:cache:cache-evict");
+var CACHE_PUT_METADATA_KEY = Symbol("@dangao/bun-server:cache:cache-put");
+function Cacheable(options = {}) {
+  return function(target, propertyKey, descriptor) {
+    const metadata = {
+      key: options.key,
+      keyPrefix: options.keyPrefix,
+      ttl: options.ttl,
+      condition: options.condition
+    };
+    Reflect.defineMetadata(CACHEABLE_METADATA_KEY, metadata, descriptor.value);
+  };
+}
+function CacheEvict(options = {}) {
+  return function(target, propertyKey, descriptor) {
+    const metadata = {
+      key: options.key,
+      keyPrefix: options.keyPrefix,
+      beforeInvocation: options.beforeInvocation ?? false,
+      allEntries: options.allEntries ?? false
+    };
+    Reflect.defineMetadata(CACHE_EVICT_METADATA_KEY, metadata, descriptor.value);
+  };
+}
+function CachePut(options = {}) {
+  return function(target, propertyKey, descriptor) {
+    const metadata = {
+      key: options.key,
+      keyPrefix: options.keyPrefix,
+      ttl: options.ttl,
+      condition: options.condition
+    };
+    Reflect.defineMetadata(CACHE_PUT_METADATA_KEY, metadata, descriptor.value);
+  };
+}
+// src/queue/types.ts
+class MemoryQueueStore {
+  queues = new Map;
+  jobCounter = 0;
+  async add(queueName, job) {
+    const queue = this.getQueue(queueName);
+    const jobId = job.options?.jobId ?? `job_${++this.jobCounter}_${Date.now()}`;
+    const now = Date.now();
+    const fullJob = {
+      id: jobId,
+      name: job.name,
+      data: job.data,
+      options: job.options,
+      status: job.options?.delay ? "delayed" : "waiting",
+      createdAt: now,
+      updatedAt: now
+    };
+    queue.set(jobId, fullJob);
+    return jobId;
+  }
+  async get(queueName, jobId) {
+    const queue = this.getQueue(queueName);
+    return queue.get(jobId);
+  }
+  async getNext(queueName) {
+    const queue = this.getQueue(queueName);
+    const now = Date.now();
+    let nextJob;
+    let highestPriority = -Infinity;
+    for (const job of queue.values()) {
+      if (job.status === "delayed" && job.options?.delay) {
+        const delayEndTime = job.createdAt + job.options.delay;
+        if (now >= delayEndTime) {
+          if ((job.options.priority ?? 0) > highestPriority || !nextJob) {
+            nextJob = job;
+            highestPriority = job.options?.priority ?? 0;
+          }
+        }
+      } else if (job.status === "waiting") {
+        if ((job.options?.priority ?? 0) > highestPriority || !nextJob) {
+          nextJob = job;
+          highestPriority = job.options?.priority ?? 0;
+        }
+      }
+    }
+    return nextJob;
+  }
+  async updateStatus(queueName, jobId, status) {
+    const queue = this.getQueue(queueName);
+    const job = queue.get(jobId);
+    if (!job) {
+      return false;
+    }
+    job.status = status;
+    job.updatedAt = Date.now();
+    return true;
+  }
+  async delete(queueName, jobId) {
+    const queue = this.getQueue(queueName);
+    return queue.delete(jobId);
+  }
+  async clear(queueName) {
+    const queue = this.getQueue(queueName);
+    queue.clear();
+    return true;
+  }
+  async count(queueName) {
+    const queue = this.getQueue(queueName);
+    return queue.size;
+  }
+  getQueue(queueName) {
+    if (!this.queues.has(queueName)) {
+      this.queues.set(queueName, new Map);
+    }
+    return this.queues.get(queueName);
+  }
+}
+var QUEUE_SERVICE_TOKEN = Symbol("@dangao/bun-server:queue:service");
+var QUEUE_OPTIONS_TOKEN = Symbol("@dangao/bun-server:queue:options");
+
+// src/queue/service.ts
+class QueueService {
+  store;
+  defaultQueue;
+  enableWorker;
+  concurrency;
+  workers = new Map;
+  cronJobs = new Map;
+  cronTimers = new Map;
+  constructor(options) {
+    this.store = options.store;
+    this.defaultQueue = options.defaultQueue ?? "default";
+    this.enableWorker = options.enableWorker ?? true;
+    this.concurrency = options.concurrency ?? 1;
+    if (this.enableWorker) {
+      this.startWorker(this.defaultQueue);
+    }
+  }
+  async add(jobName, data, options, queueName) {
+    const queue = queueName ?? this.defaultQueue;
+    const jobId = await this.store.add(queue, {
+      name: jobName,
+      data,
+      options
+    });
+    if (this.enableWorker && !this.workers.has(queue)) {
+      this.startWorker(queue);
+    }
+    return jobId;
+  }
+  async get(jobId, queueName) {
+    const queue = queueName ?? this.defaultQueue;
+    return this.store.get(queue, jobId);
+  }
+  async delete(jobId, queueName) {
+    const queue = queueName ?? this.defaultQueue;
+    return this.store.delete(queue, jobId);
+  }
+  async clear(queueName) {
+    const queue = queueName ?? this.defaultQueue;
+    return this.store.clear(queue);
+  }
+  async count(queueName) {
+    const queue = queueName ?? this.defaultQueue;
+    return this.store.count(queue);
+  }
+  async registerHandler(jobName, handler, queueName) {
+    const queue = queueName ?? this.defaultQueue;
+    const key = `${queue}:${jobName}`;
+    this.handlers = this.handlers ?? new Map;
+    this.handlers.set(key, handler);
+  }
+  async registerCron(jobName, handler, options, queueName) {
+    const queue = queueName ?? this.defaultQueue;
+    const key = `${queue}:${jobName}`;
+    this.cronJobs.set(key, { handler, options });
+    if (options.runOnInit) {
+      await this.add(jobName, {}, undefined, queue);
+    }
+    const interval = this.parseCronInterval(options.pattern);
+    if (interval > 0) {
+      const timer = setInterval(async () => {
+        await this.add(jobName, {}, undefined, queue);
+      }, interval);
+      this.cronTimers.set(key, timer);
+    }
+  }
+  startWorker(queueName) {
+    if (this.workers.has(queueName)) {
+      return;
+    }
+    const workerSet = new Set;
+    this.workers.set(queueName, workerSet);
+    for (let i = 0;i < this.concurrency; i++) {
+      const worker = this.processQueue(queueName);
+      workerSet.add(worker);
+    }
+  }
+  async processQueue(queueName) {
+    while (true) {
+      try {
+        const job = await this.store.getNext(queueName);
+        if (!job) {
+          await new Promise((resolve2) => setTimeout(resolve2, 1000));
+          continue;
+        }
+        await this.store.updateStatus(queueName, job.id, "active");
+        try {
+          const handler = this.getHandler(job.name, queueName);
+          if (handler) {
+            await handler(job);
+            await this.store.updateStatus(queueName, job.id, "completed");
+          } else {
+            await this.store.updateStatus(queueName, job.id, "failed");
+          }
+        } catch (error) {
+          await this.store.updateStatus(queueName, job.id, "failed");
+          console.error(`Job ${job.id} failed:`, error);
+        }
+      } catch (error) {
+        console.error(`Error processing queue ${queueName}:`, error);
+        await new Promise((resolve2) => setTimeout(resolve2, 1000));
+      }
+    }
+  }
+  getHandler(jobName, queueName) {
+    const key = `${queueName}:${jobName}`;
+    return this.handlers?.get(key);
+  }
+  parseCronInterval(pattern) {
+    const parts = pattern.trim().split(/\s+/);
+    if (parts.length !== 5) {
+      return -1;
+    }
+    const [minute, hour, day, month, weekday] = parts;
+    if (minute === "*" && hour === "*" && day === "*" && month === "*" && weekday === "*") {
+      return 60000;
+    }
+    if (/^\d+$/.test(minute) && hour === "*" && day === "*" && month === "*" && weekday === "*") {
+      return parseInt(minute, 10) * 60000;
+    }
+    return -1;
+  }
+  destroy() {
+    for (const timer of this.cronTimers.values()) {
+      clearInterval(timer);
+    }
+    this.cronTimers.clear();
+    this.cronJobs.clear();
+    this.workers.clear();
+  }
+}
+QueueService = __legacyDecorateClassTS([
+  Injectable(),
+  __legacyDecorateParamTS(0, Inject(QUEUE_OPTIONS_TOKEN)),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof QueueModuleOptions === "undefined" ? Object : QueueModuleOptions
+  ])
+], QueueService);
+
+// src/queue/queue-module.ts
+class QueueModule {
+  static forRoot(options = {}) {
+    const providers2 = [];
+    const store = options.store ?? new MemoryQueueStore;
+    const service = new QueueService({
+      store,
+      defaultQueue: options.defaultQueue,
+      enableWorker: options.enableWorker,
+      concurrency: options.concurrency
+    });
+    providers2.push({
+      provide: QUEUE_SERVICE_TOKEN,
+      useValue: service
+    }, {
+      provide: QUEUE_OPTIONS_TOKEN,
+      useValue: options
+    }, QueueService);
+    const existingMetadata = Reflect.getMetadata(MODULE_METADATA_KEY, QueueModule) || {};
+    const metadata = {
+      ...existingMetadata,
+      providers: [...existingMetadata.providers || [], ...providers2],
+      exports: [
+        ...existingMetadata.exports || [],
+        QUEUE_SERVICE_TOKEN,
+        QUEUE_OPTIONS_TOKEN,
+        QueueService
+      ]
+    };
+    Reflect.defineMetadata(MODULE_METADATA_KEY, metadata, QueueModule);
+    return QueueModule;
+  }
+}
+QueueModule = __legacyDecorateClassTS([
+  Module({
+    providers: []
+  })
+], QueueModule);
+// src/queue/decorators.ts
+import"reflect-metadata";
+var QUEUE_METADATA_KEY = Symbol("@dangao/bun-server:queue:queue");
+var CRON_METADATA_KEY = Symbol("@dangao/bun-server:queue:cron");
+function Queue(options = {}) {
+  return function(target, propertyKey, descriptor) {
+    const metadata = {
+      name: options.name
+    };
+    Reflect.defineMetadata(QUEUE_METADATA_KEY, metadata, descriptor.value);
+  };
+}
+function Cron(options) {
+  return function(target, propertyKey, descriptor) {
+    const metadata = {
+      pattern: options.pattern,
+      timezone: options.timezone,
+      runOnInit: options.runOnInit ?? false,
+      queueName: options.queueName
+    };
+    Reflect.defineMetadata(CRON_METADATA_KEY, metadata, descriptor.value);
+  };
+}
+// src/session/service.ts
+import { randomBytes } from "crypto";
+class SessionService {
+  store;
+  name;
+  maxAge;
+  rolling;
+  cookieOptions;
+  constructor(options) {
+    this.store = options.store;
+    this.name = options.name ?? "sessionId";
+    this.maxAge = options.maxAge ?? 86400000;
+    this.rolling = options.rolling ?? true;
+    this.cookieOptions = {
+      secure: options.cookie?.secure ?? false,
+      httpOnly: options.cookie?.httpOnly ?? true,
+      path: options.cookie?.path ?? "/",
+      domain: options.cookie?.domain,
+      sameSite: options.cookie?.sameSite ?? "lax"
+    };
+  }
+  generateSessionId() {
+    return randomBytes(32).toString("hex");
+  }
+  async create(initialData = {}) {
+    const now = Date.now();
+    const session = {
+      id: this.generateSessionId(),
+      data: initialData,
+      createdAt: now,
+      lastAccessedAt: now,
+      expiresAt: now + this.maxAge
+    };
+    await this.store.set(session, this.maxAge);
+    return session;
+  }
+  async get(sessionId) {
+    const session = await this.store.get(sessionId);
+    if (!session) {
+      return;
+    }
+    if (this.rolling) {
+      await this.touch(sessionId);
+    }
+    return session;
+  }
+  async set(sessionId, data) {
+    const session = await this.store.get(sessionId);
+    if (!session) {
+      return false;
+    }
+    session.data = { ...session.data, ...data };
+    session.lastAccessedAt = Date.now();
+    if (this.rolling) {
+      session.expiresAt = Date.now() + this.maxAge;
+    }
+    return this.store.set(session, this.maxAge);
+  }
+  async getValue(sessionId, key) {
+    const session = await this.store.get(sessionId);
+    if (!session) {
+      return;
+    }
+    return session.data[key];
+  }
+  async setValue(sessionId, key, value) {
+    const session = await this.store.get(sessionId);
+    if (!session) {
+      return false;
+    }
+    session.data[key] = value;
+    session.lastAccessedAt = Date.now();
+    if (this.rolling) {
+      session.expiresAt = Date.now() + this.maxAge;
+    }
+    return this.store.set(session, this.maxAge);
+  }
+  async deleteValue(sessionId, key) {
+    const session = await this.store.get(sessionId);
+    if (!session) {
+      return false;
+    }
+    delete session.data[key];
+    session.lastAccessedAt = Date.now();
+    if (this.rolling) {
+      session.expiresAt = Date.now() + this.maxAge;
+    }
+    return this.store.set(session, this.maxAge);
+  }
+  async delete(sessionId) {
+    return this.store.delete(sessionId);
+  }
+  async touch(sessionId) {
+    return this.store.touch(sessionId);
+  }
+  getCookieName() {
+    return this.name;
+  }
+  getCookieOptions() {
+    return this.cookieOptions;
+  }
+  getMaxAge() {
+    return this.maxAge;
+  }
+}
+SessionService = __legacyDecorateClassTS([
+  Injectable(),
+  __legacyDecorateParamTS(0, Inject(SESSION_OPTIONS_TOKEN)),
+  __legacyMetadataTS("design:paramtypes", [
+    typeof SessionModuleOptions === "undefined" ? Object : SessionModuleOptions
+  ])
+], SessionService);
+
+// src/session/session-module.ts
+class SessionModule {
+  static forRoot(options = {}) {
+    const providers2 = [];
+    const store = options.store ?? new MemorySessionStore({
+      cleanupInterval: 60000
+    });
+    const service = new SessionService({
+      store,
+      name: options.name,
+      maxAge: options.maxAge,
+      rolling: options.rolling,
+      cookie: options.cookie
+    });
+    providers2.push({
+      provide: SESSION_SERVICE_TOKEN,
+      useValue: service
+    }, {
+      provide: SESSION_OPTIONS_TOKEN,
+      useValue: options
+    }, SessionService);
+    const existingMetadata = Reflect.getMetadata(MODULE_METADATA_KEY, SessionModule) || {};
+    const metadata = {
+      ...existingMetadata,
+      providers: [...existingMetadata.providers || [], ...providers2],
+      exports: [
+        ...existingMetadata.exports || [],
+        SESSION_SERVICE_TOKEN,
+        SESSION_OPTIONS_TOKEN,
+        SessionService
+      ]
+    };
+    Reflect.defineMetadata(MODULE_METADATA_KEY, metadata, SessionModule);
+    return SessionModule;
+  }
+}
+SessionModule = __legacyDecorateClassTS([
+  Module({
+    providers: []
+  })
+], SessionModule);
+// src/session/middleware.ts
+function createSessionMiddleware(container) {
+  return async (context2, next) => {
+    let sessionService;
+    try {
+      sessionService = container.resolve(SESSION_SERVICE_TOKEN);
+    } catch {
+      return await next();
+    }
+    if (!sessionService) {
+      return await next();
+    }
+    const cookieName = sessionService.getCookieName();
+    const cookieHeader = context2.request.headers.get("cookie");
+    let sessionId;
+    if (cookieHeader) {
+      const cookies = cookieHeader.split(";").map((c) => c.trim());
+      for (const cookie of cookies) {
+        if (cookie.startsWith(`${cookieName}=`)) {
+          sessionId = cookie.substring(cookieName.length + 1).trim();
+          break;
+        }
+      }
+    }
+    if (sessionId) {
+      const session = await sessionService.get(sessionId);
+      if (session) {
+        context2.session = session;
+        context2.sessionId = sessionId;
+      } else {
+        sessionId = undefined;
+      }
+    }
+    if (!sessionId) {
+      const newSession = await sessionService.create();
+      context2.session = newSession;
+      context2.sessionId = newSession.id;
+      sessionId = newSession.id;
+    }
+    const response = await next();
+    const currentSessionId = context2.sessionId;
+    if (currentSessionId) {
+      const cookieOptions = sessionService.getCookieOptions();
+      const maxAge = sessionService.getMaxAge();
+      const cookieValue = buildCookie(cookieName, currentSessionId, {
+        ...cookieOptions,
+        maxAge
+      });
+      const newHeaders = new Headers(response.headers);
+      newHeaders.set("Set-Cookie", cookieValue);
+      return new Response(response.body, {
+        status: response.status,
+        statusText: response.statusText,
+        headers: newHeaders
+      });
+    }
+    return response;
+  };
+}
+function buildCookie(name, value, options) {
+  let cookie = `${name}=${value}`;
+  if (options.path) {
+    cookie += `; Path=${options.path}`;
+  }
+  if (options.domain) {
+    cookie += `; Domain=${options.domain}`;
+  }
+  if (options.maxAge) {
+    cookie += `; Max-Age=${Math.floor(options.maxAge / 1000)}`;
+  }
+  if (options.secure) {
+    cookie += "; Secure";
+  }
+  if (options.httpOnly) {
+    cookie += "; HttpOnly";
+  }
+  if (options.sameSite) {
+    cookie += `; SameSite=${options.sameSite}`;
+  }
+  return cookie;
+}
+// src/session/decorators.ts
+import"reflect-metadata";
+function Session() {
+  return createParamDecorator("session" /* SESSION */);
 }
 export {
   requiresAuth,
+  getTransactionMetadata,
+  getRepositoryMetadata,
+  getEntityMetadata,
+  getColumnMetadata,
   getAuthMetadata,
   createUserKeyGenerator,
   createTokenKeyGenerator,
   createSwaggerUIMiddleware,
   createStaticFileMiddleware,
+  createSessionMiddleware,
   createSecurityFilter,
   createRequestLoggingMiddleware,
   createRateLimitMiddleware,
@@ -3985,30 +6282,52 @@ export {
   Validate,
   UseMiddleware,
   UnauthorizedException,
+  Transactional,
+  TransactionStatus,
+  TransactionManager,
+  TransactionInterceptor,
+  TRANSACTION_SERVICE_TOKEN,
   SwaggerModule,
   SwaggerGenerator,
   SwaggerExtension,
   StressTester,
+  SessionService,
+  SessionModule,
+  Session,
   SecurityModule,
   SecurityContextHolder,
+  SESSION_SERVICE_TOKEN,
+  SESSION_OPTIONS_TOKEN,
   Router,
   RouteRegistry,
   Route,
   RoleBasedAccessDecisionManager,
   ResponseBuilder,
   RequestWrapper,
+  Repository,
+  RedisSessionStore,
+  RedisCacheStore,
   RateLimit,
+  QueueService,
+  QueueModule,
+  Queue,
   Query,
+  QUEUE_SERVICE_TOKEN,
+  QUEUE_OPTIONS_TOKEN,
+  Propagation,
   PrometheusFormatter,
+  PrimaryKey,
   PerformanceHarness,
   ParamBinder,
   Param,
   PUT,
   POST,
   PATCH,
+  OrmService,
   OnOpen,
   OnMessage,
   OnClose,
+  ORM_SERVICE_TOKEN,
   OAuth2Service,
   OAuth2Controller,
   OAuth2AuthenticationProvider,
@@ -4020,6 +6339,9 @@ export {
   MiddlewarePipeline,
   MetricsModule,
   MetricsCollector,
+  MemorySessionStore,
+  MemoryQueueStore,
+  MemoryCacheStore,
   METRICS_SERVICE_TOKEN,
   METRICS_OPTIONS_TOKEN,
   LoggerModule,
@@ -4030,6 +6352,7 @@ export {
   JwtAuthenticationProvider,
   JWT_UTIL_TOKEN,
   JWTUtil,
+  IsolationLevel,
   IsString,
   IsOptional,
   IsNumber,
@@ -4045,17 +6368,37 @@ export {
   GET,
   ForbiddenException,
   ExceptionFilterRegistry,
+  Entity,
+  DrizzleBaseRepository,
+  DatabaseService2 as DatabaseService,
+  DatabaseModule,
+  DatabaseHealthIndicator,
+  DatabaseExtension,
+  DatabaseConnectionManager,
   DELETE,
+  DATABASE_SERVICE_TOKEN,
+  DATABASE_OPTIONS_TOKEN,
+  Cron,
   ControllerRegistry,
   Controller,
   Context,
   Container,
+  ConnectionPool,
   ConfigService,
   ConfigModule,
+  Column,
+  Cacheable,
+  CacheService,
+  CachePut,
+  CacheModule,
+  CacheEvict,
   CONFIG_SERVICE_TOKEN,
+  CACHE_SERVICE_TOKEN,
+  CACHE_OPTIONS_TOKEN,
   BunServer,
   BodyParser,
   Body,
+  BaseRepository,
   BadRequestException,
   AuthenticationManager,
   Auth,