@dangao/bun-server 1.0.3 → 1.1.3

package/dist/index.js

@@ -531,181 +531,6 @@ 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) {
@@ -1786,40 +1611,35 @@ import"reflect-metadata";
 var ROUTE_METADATA_KEY = Symbol("route");
 function createRouteDecorator(method, path) {
   return function(target, propertyKey, descriptor) {
-    const controllerMetadata = Reflect.getMetadata(CONTROLLER_METADATA_KEY, target.constructor);
-    if (controllerMetadata) {
-      const existingRoutes = Reflect.getMetadata(ROUTE_METADATA_KEY, target) || [];
-      let propertyKeyStr;
-      if (propertyKey && propertyKey !== "") {
-        propertyKeyStr = typeof propertyKey === "string" ? propertyKey : String(propertyKey);
-      } else {
-        propertyKeyStr = descriptor.value.name || "";
-      }
-      if (!propertyKeyStr) {
-        const propertyNames = Object.getOwnPropertyNames(target);
-        for (const key of propertyNames) {
-          const targetDescriptor = Object.getOwnPropertyDescriptor(target, key);
-          if (targetDescriptor?.value === descriptor.value) {
-            propertyKeyStr = key;
-            break;
-          }
+    const constructor = target.constructor;
+    if (constructor && typeof constructor === "function") {
+      const hasController = Reflect.getMetadata(CONTROLLER_METADATA_KEY, constructor);
+      if (hasController === undefined) {}
+    }
+    const existingRoutes = Reflect.getMetadata(ROUTE_METADATA_KEY, target) || [];
+    let propertyKeyStr;
+    if (propertyKey && propertyKey !== "") {
+      propertyKeyStr = typeof propertyKey === "string" ? propertyKey : String(propertyKey);
+    } else {
+      propertyKeyStr = descriptor.value.name || "";
+    }
+    if (!propertyKeyStr) {
+      const propertyNames = Object.getOwnPropertyNames(target);
+      for (const key of propertyNames) {
+        const targetDescriptor = Object.getOwnPropertyDescriptor(target, key);
+        if (targetDescriptor?.value === descriptor.value) {
+          propertyKeyStr = key;
+          break;
         }
       }
-      existingRoutes.push({
-        method,
-        path,
-        handler: descriptor.value,
-        propertyKey: propertyKeyStr || undefined
-      });
-      Reflect.defineMetadata(ROUTE_METADATA_KEY, existingRoutes, target);
-    } else {
-      const handler = descriptor.value;
-      const registry = RouteRegistry.getInstance();
-      registry.register(method, path, handler);
-      const existingRoutes = Reflect.getMetadata(ROUTE_METADATA_KEY, target) || [];
-      existingRoutes.push({ method, path, handler });
-      Reflect.defineMetadata(ROUTE_METADATA_KEY, existingRoutes, target);
     }
+    existingRoutes.push({
+      method,
+      path,
+      handler: descriptor.value,
+      propertyKey: propertyKeyStr || undefined
+    });
+    Reflect.defineMetadata(ROUTE_METADATA_KEY, existingRoutes, target);
   };
 }
 function GET(path) {
@@ -2237,17 +2057,446 @@ function createStaticFileMiddleware(options) {
     if (enableCache) {
       headers.set("Cache-Control", "public, max-age=31536000, immutable");
     }
-    if (!headers.has("Content-Type") && file.type) {
-      headers.set("Content-Type", file.type);
+    if (!headers.has("Content-Type") && file.type) {
+      headers.set("Content-Type", file.type);
+    }
+    return new Response(file, {
+      status: 200,
+      headers
+    });
+  };
+}
+// src/controller/controller.ts
+init_validation();
+
+// src/interceptor/types.ts
+var INTERCEPTOR_REGISTRY_TOKEN = Symbol("@dangao/bun-server:interceptor-registry");
+// src/interceptor/interceptor-registry.ts
+class InterceptorRegistry {
+  interceptors = new Map;
+  register(metadataKey, interceptor, priority = 100) {
+    if (!this.interceptors.has(metadataKey)) {
+      this.interceptors.set(metadataKey, []);
+    }
+    const metadataList = this.interceptors.get(metadataKey);
+    const exists = metadataList.some((meta) => meta.interceptor === interceptor);
+    if (!exists) {
+      metadataList.push({
+        metadataKey,
+        interceptor,
+        priority
+      });
+      metadataList.sort((a, b) => a.priority - b.priority);
+    }
+  }
+  getInterceptorMetadata(metadataKey) {
+    const metadataList = this.interceptors.get(metadataKey);
+    if (!metadataList || metadataList.length === 0) {
+      return [];
+    }
+    return [...metadataList];
+  }
+  getInterceptors(metadataKey) {
+    const metadataList = this.interceptors.get(metadataKey);
+    if (!metadataList || metadataList.length === 0) {
+      return [];
+    }
+    return metadataList.map((meta) => meta.interceptor);
+  }
+  hasInterceptor(metadataKey) {
+    const metadataList = this.interceptors.get(metadataKey);
+    return metadataList !== undefined && metadataList.length > 0;
+  }
+  getAllMetadataKeys() {
+    return this.interceptors.keys();
+  }
+  clear() {
+    this.interceptors.clear();
+  }
+  remove(metadataKey) {
+    this.interceptors.delete(metadataKey);
+  }
+  count(metadataKey) {
+    if (metadataKey) {
+      const metadataList = this.interceptors.get(metadataKey);
+      return metadataList ? metadataList.length : 0;
+    }
+    let total = 0;
+    for (const metadataList of this.interceptors.values()) {
+      total += metadataList.length;
+    }
+    return total;
+  }
+}
+// src/interceptor/interceptor-chain.ts
+class InterceptorChain {
+  static async execute(interceptors, target, propertyKey, originalMethod, args, container, context) {
+    if (interceptors.length === 0) {
+      return await Promise.resolve(originalMethod.apply(target, args));
+    }
+    let index = 0;
+    let currentArgs = args;
+    const next = async (modifiedArgs) => {
+      if (modifiedArgs && modifiedArgs.length > 0) {
+        currentArgs = modifiedArgs;
+      }
+      if (index >= interceptors.length) {
+        return await Promise.resolve(originalMethod.apply(target, currentArgs));
+      }
+      const interceptor = interceptors[index++];
+      const wrappedNext = (...nextArgs) => {
+        const result = next(nextArgs.length > 0 ? nextArgs : undefined);
+        return result;
+      };
+      return await interceptor.execute(target, propertyKey, wrappedNext, currentArgs, container, context);
+    };
+    return await next();
+  }
+}
+// src/interceptor/metadata.ts
+import"reflect-metadata";
+function scanInterceptorMetadata(target, propertyKey, registry) {
+  const interceptorMetadataList = [];
+  for (const metadataKey of registry.getAllMetadataKeys()) {
+    const metadata = Reflect.getMetadata(metadataKey, target, propertyKey);
+    if (metadata !== undefined && metadata !== null) {
+      const metadataList = registry.getInterceptorMetadata(metadataKey);
+      if (metadataList.length > 0) {
+        interceptorMetadataList.push(...metadataList);
+      }
+    }
+  }
+  interceptorMetadataList.sort((a, b) => a.priority - b.priority);
+  return interceptorMetadataList.map((meta) => meta.interceptor);
+}
+// src/interceptor/base-interceptor.ts
+import"reflect-metadata";
+
+class BaseInterceptor {
+  async before(target, propertyKey, args, container, context) {}
+  async after(target, propertyKey, result, container, context) {
+    return result;
+  }
+  async onError(target, propertyKey, error, container, context) {
+    throw error;
+  }
+  getMetadata(target, propertyKey, metadataKey) {
+    if (typeof target !== "object" || target === null) {
+      return;
+    }
+    let metadata = Reflect.getMetadata(metadataKey, target, propertyKey);
+    if (metadata !== undefined) {
+      return metadata;
+    }
+    const prototype = Object.getPrototypeOf(target);
+    if (prototype && prototype !== Object.prototype) {
+      metadata = Reflect.getMetadata(metadataKey, prototype, propertyKey);
+      if (metadata !== undefined) {
+        return metadata;
+      }
+    }
+    const constructor = target.constructor;
+    if (constructor && typeof constructor === "function") {
+      if (target !== constructor.prototype) {
+        metadata = Reflect.getMetadata(metadataKey, constructor.prototype, propertyKey);
+        if (metadata !== undefined) {
+          return metadata;
+        }
+      }
+    }
+    return;
+  }
+  resolveService(container, token) {
+    return container.resolve(token);
+  }
+  getContextValue(context, key) {
+    if (!context) {
+      return;
+    }
+    return;
+  }
+  getHeader(context, headerName) {
+    if (!context) {
+      return null;
+    }
+    return context.getHeader(headerName);
+  }
+  getQuery(context, paramName) {
+    if (!context) {
+      return null;
+    }
+    return context.getQuery(paramName);
+  }
+  getParam(context, paramName) {
+    if (!context) {
+      return;
+    }
+    return context.getParam(paramName);
+  }
+}
+// src/interceptor/builtin/cache-interceptor.ts
+import"reflect-metadata";
+var CACHE_METADATA_KEY = Symbol("@dangao/bun-server:interceptor:cache");
+function Cache(options = {}) {
+  return (target, propertyKey, descriptor) => {
+    const metadata = {
+      ttl: options.ttl ?? 60000,
+      key: options.key
+    };
+    Reflect.defineMetadata(CACHE_METADATA_KEY, metadata, target, propertyKey);
+  };
+}
+class CacheInterceptor extends BaseInterceptor {
+  static cache = new Map;
+  async execute(target, propertyKey, originalMethod, args, container, context) {
+    const metadata = this.getMetadata(target, propertyKey, CACHE_METADATA_KEY);
+    if (!metadata) {
+      return await Promise.resolve(originalMethod.apply(target, args));
+    }
+    const cacheKey = this.generateCacheKey(target, propertyKey, args, metadata.key);
+    const cached = CacheInterceptor.cache.get(cacheKey);
+    if (cached && cached.expires > Date.now()) {
+      return cached.data;
+    }
+    const result = await Promise.resolve(originalMethod.apply(target, args));
+    CacheInterceptor.cache.set(cacheKey, {
+      data: result,
+      expires: Date.now() + metadata.ttl
+    });
+    return result;
+  }
+  generateCacheKey(target, propertyKey, args, customKey) {
+    if (customKey) {
+      return customKey;
+    }
+    const className = typeof target === "object" && target !== null ? target.constructor?.name || "Unknown" : "Unknown";
+    const methodName = String(propertyKey);
+    const argsKey = JSON.stringify(args);
+    return `${className}:${methodName}:${argsKey}`;
+  }
+  static clearCache() {
+    CacheInterceptor.cache.clear();
+  }
+  static clearCacheKey(key) {
+    CacheInterceptor.cache.delete(key);
+  }
+  static getCacheStats() {
+    return {
+      size: CacheInterceptor.cache.size,
+      keys: Array.from(CacheInterceptor.cache.keys())
+    };
+  }
+}
+// src/interceptor/builtin/permission-interceptor.ts
+import"reflect-metadata";
+var PERMISSION_METADATA_KEY = Symbol("@dangao/bun-server:interceptor:permission");
+function Permission(options) {
+  return (target, propertyKey, descriptor) => {
+    const metadata = {
+      resource: options.resource,
+      action: options.action,
+      allowAnonymous: options.allowAnonymous ?? false
+    };
+    Reflect.defineMetadata(PERMISSION_METADATA_KEY, metadata, target, propertyKey);
+  };
+}
+class PermissionInterceptor extends BaseInterceptor {
+  static PERMISSION_SERVICE_TOKEN = Symbol("@dangao/bun-server:interceptor:permission:service");
+  async execute(target, propertyKey, originalMethod, args, container, context) {
+    const metadata = this.getMetadata(target, propertyKey, PERMISSION_METADATA_KEY);
+    if (!metadata) {
+      return await Promise.resolve(originalMethod.apply(target, args));
+    }
+    if (metadata.allowAnonymous) {
+      return await Promise.resolve(originalMethod.apply(target, args));
+    }
+    const userId = this.getUserId(context);
+    let permissionService;
+    try {
+      permissionService = this.resolveService(container, PermissionInterceptor.PERMISSION_SERVICE_TOKEN);
+    } catch (error) {
+      throw new Error("PermissionService not found. Please register PermissionService in DI container.");
+    }
+    const hasPermission = await permissionService.check(userId, metadata.resource, metadata.action);
+    if (!hasPermission) {
+      throw new ForbiddenException(`Permission denied: ${metadata.action} on ${metadata.resource}`);
+    }
+    return await Promise.resolve(originalMethod.apply(target, args));
+  }
+  getUserId(context) {
+    if (!context) {
+      return null;
+    }
+    const authHeader = this.getHeader(context, "Authorization");
+    if (authHeader && authHeader.startsWith("Bearer ")) {}
+    const userId = this.getHeader(context, "X-User-Id");
+    if (userId) {
+      return userId;
+    }
+    return null;
+  }
+}
+// src/interceptor/builtin/log-interceptor.ts
+import"reflect-metadata";
+
+// src/extensions/logger-extension.ts
+import {
+  LoggerManager as LoggerManager6,
+  LogLevel,
+  SimpleLogger
+} from "@dangao/logsmith";
+var LOGGER_TOKEN = Symbol("@dangao/bun-server:logger");
+
+class LoggerExtension {
+  options;
+  constructor(options = {}) {
+    this.options = {
+      level: LogLevel.INFO,
+      ...options
+    };
+  }
+  register(container) {
+    const logger = new SimpleLogger(this.options);
+    LoggerManager6.setLogger(logger);
+    container.registerInstance(SimpleLogger, logger);
+    container.registerInstance(LOGGER_TOKEN, logger);
+  }
+}
+// src/di/module.ts
+import"reflect-metadata";
+var MODULE_METADATA_KEY = Symbol("@dangao/bun-server:module");
+function Module(metadata) {
+  return (target) => {
+    Reflect.defineMetadata(MODULE_METADATA_KEY, metadata, target);
+  };
+}
+function getModuleMetadata(moduleClass) {
+  const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, moduleClass) ?? {};
+  return {
+    imports: metadata.imports ?? [],
+    controllers: metadata.controllers ?? [],
+    providers: metadata.providers ?? [],
+    exports: metadata.exports ?? [],
+    extensions: metadata.extensions ?? [],
+    middlewares: metadata.middlewares ?? []
+  };
+}
+
+// src/extensions/logger-module.ts
+class LoggerModule {
+  static forRoot(options = {}) {
+    const extensions = [];
+    const middlewares = [];
+    const loggerExtension = new LoggerExtension(options.logger);
+    extensions.push(loggerExtension);
+    if (options.enableRequestLogging !== false) {
+      const requestLoggingMiddleware = createLoggerMiddleware({
+        prefix: options.requestLoggingPrefix
+      });
+      middlewares.push(requestLoggingMiddleware);
+    }
+    const existingMetadata = Reflect.getMetadata(MODULE_METADATA_KEY, LoggerModule) || {};
+    const metadata = {
+      ...existingMetadata,
+      extensions,
+      middlewares
+    };
+    Reflect.defineMetadata(MODULE_METADATA_KEY, metadata, LoggerModule);
+    return LoggerModule;
+  }
+}
+LoggerModule = __legacyDecorateClassTS([
+  Module({
+    extensions: [],
+    middlewares: []
+  })
+], LoggerModule);
+
+// src/extensions/index.ts
+import { LoggerManager as LoggerManager7, LogLevel as LogLevel2, SimpleLogger as SimpleLogger2 } from "@dangao/logsmith";
+
+// src/interceptor/builtin/log-interceptor.ts
+var LOG_METADATA_KEY = Symbol("@dangao/bun-server:interceptor:log");
+function Log(options = {}) {
+  return (target, propertyKey, descriptor) => {
+    const metadata = {
+      level: options.level || "info",
+      message: options.message,
+      logArgs: options.logArgs ?? false,
+      logResult: options.logResult ?? false,
+      logDuration: options.logDuration ?? true
+    };
+    Reflect.defineMetadata(LOG_METADATA_KEY, metadata, target, propertyKey);
+  };
+}
+class LogInterceptor extends BaseInterceptor {
+  async execute(target, propertyKey, originalMethod, args, container, context) {
+    const options = this.getMetadata(target, propertyKey, LOG_METADATA_KEY) || {};
+    const level = options.level || "info";
+    const methodName = String(propertyKey);
+    const logMessage = options.message || `Executing ${methodName}`;
+    const logArgs = options.logArgs ?? false;
+    const logResult = options.logResult ?? false;
+    const logDuration = options.logDuration ?? true;
+    let logger;
+    try {
+      logger = container.resolve(LOGGER_TOKEN);
+    } catch {}
+    const log = (msg, data) => {
+      if (logger) {
+        switch (level) {
+          case "debug":
+            logger.debug(msg, data);
+            break;
+          case "info":
+            logger.info(msg, data);
+            break;
+          case "warn":
+            logger.warn(msg, data);
+            break;
+          case "error":
+            logger.error(msg, data);
+            break;
+        }
+      } else {
+        console.log(`[${level.toUpperCase()}] ${msg}`, data || "");
+      }
+    };
+    const startTime = logDuration ? performance.now() : undefined;
+    if (logArgs && args.length > 0) {
+      log(`${logMessage} - Start`, { args });
+    } else {
+      log(`${logMessage} - Start`);
+    }
+    try {
+      const result = await Promise.resolve(originalMethod.apply(target, args));
+      const duration = startTime ? performance.now() - startTime : undefined;
+      const logData = {};
+      if (duration !== undefined) {
+        logData.duration = `${duration.toFixed(2)}ms`;
+      }
+      if (logResult) {
+        logData.result = result;
+      }
+      if (Object.keys(logData).length > 0) {
+        log(`${logMessage} - Completed`, logData);
+      } else {
+        log(`${logMessage} - Completed`);
+      }
+      return result;
+    } catch (error) {
+      const duration = startTime ? performance.now() - startTime : undefined;
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const logData = { error: errorMessage };
+      if (duration !== undefined) {
+        logData.duration = `${duration.toFixed(2)}ms`;
+      }
+      log(`${logMessage} - Failed`, logData);
+      throw error;
     }
-    return new Response(file, {
-      status: 200,
-      headers
-    });
-  };
+  }
 }
 // src/controller/controller.ts
-init_validation();
 var CONTROLLER_METADATA_KEY = Symbol("controller");
 function Controller(path = "") {
   return function(target) {
@@ -2318,23 +2567,26 @@ class ControllerRegistry {
           }
           let method = controllerInstance[propertyKey];
           if (!method || typeof method !== "function") {
-            const prototype3 = controllerClass.prototype;
-            method = prototype3[propertyKey];
+            method = prototype2[propertyKey];
           }
           if (!method || typeof method !== "function") {
             throw new Error(`Method ${propertyKey} not found on controller ${controllerClass.name}`);
           }
-          let result;
+          let interceptorRegistry;
           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);
+            interceptorRegistry = controllerContainer.resolve(INTERCEPTOR_REGISTRY_TOKEN);
+          } catch (error) {
+            interceptorRegistry = undefined;
+          }
+          let result;
+          if (interceptorRegistry) {
+            const interceptors = scanInterceptorMetadata(prototype2, propertyKey, interceptorRegistry);
+            if (interceptors.length > 0) {
+              result = await InterceptorChain.execute(interceptors, controllerInstance, propertyKey, method, params, controllerContainer, context);
             } else {
               result = method.apply(controllerInstance, params);
             }
-          } catch (error) {
+          } else {
             result = method.apply(controllerInstance, params);
           }
           const responseData = await Promise.resolve(result);
@@ -2489,50 +2741,6 @@ class WebSocketGatewayRegistry {
   }
 }
 
-// src/extensions/logger-extension.ts
-import {
-  LoggerManager as LoggerManager6,
-  LogLevel,
-  SimpleLogger
-} from "@dangao/logsmith";
-var LOGGER_TOKEN = Symbol("@dangao/bun-server:logger");
-
-class LoggerExtension {
-  options;
-  constructor(options = {}) {
-    this.options = {
-      level: LogLevel.INFO,
-      ...options
-    };
-  }
-  register(container) {
-    const logger = new SimpleLogger(this.options);
-    LoggerManager6.setLogger(logger);
-    container.registerInstance(SimpleLogger, logger);
-    container.registerInstance(LOGGER_TOKEN, logger);
-  }
-}
-
-// src/di/module.ts
-import"reflect-metadata";
-var MODULE_METADATA_KEY = Symbol("@dangao/bun-server:module");
-function Module(metadata) {
-  return (target) => {
-    Reflect.defineMetadata(MODULE_METADATA_KEY, metadata, target);
-  };
-}
-function getModuleMetadata(moduleClass) {
-  const metadata = Reflect.getMetadata(MODULE_METADATA_KEY, moduleClass) ?? {};
-  return {
-    imports: metadata.imports ?? [],
-    controllers: metadata.controllers ?? [],
-    providers: metadata.providers ?? [],
-    exports: metadata.exports ?? [],
-    extensions: metadata.extensions ?? [],
-    middlewares: metadata.middlewares ?? []
-  };
-}
-
 // src/di/module-registry.ts
 class ModuleRegistry {
   static instance;
@@ -2692,6 +2900,9 @@ class Application {
     RouteRegistry.getInstance().clear();
     ControllerRegistry.getInstance().clear();
     ModuleRegistry.getInstance().clear();
+    const container = ControllerRegistry.getInstance().getContainer();
+    const interceptorRegistry = new InterceptorRegistry;
+    container.registerInstance(INTERCEPTOR_REGISTRY_TOKEN, interceptorRegistry);
     this.registerExtension(new LoggerExtension);
   }
   use(middleware) {
@@ -2890,38 +3101,6 @@ class ResponseBuilder {
 }
 // src/index.ts
 init_validation();
-// src/extensions/logger-module.ts
-class LoggerModule {
-  static forRoot(options = {}) {
-    const extensions = [];
-    const middlewares = [];
-    const loggerExtension = new LoggerExtension(options.logger);
-    extensions.push(loggerExtension);
-    if (options.enableRequestLogging !== false) {
-      const requestLoggingMiddleware = createLoggerMiddleware({
-        prefix: options.requestLoggingPrefix
-      });
-      middlewares.push(requestLoggingMiddleware);
-    }
-    const existingMetadata = Reflect.getMetadata(MODULE_METADATA_KEY, LoggerModule) || {};
-    const metadata = {
-      ...existingMetadata,
-      extensions,
-      middlewares
-    };
-    Reflect.defineMetadata(MODULE_METADATA_KEY, metadata, LoggerModule);
-    return LoggerModule;
-  }
-}
-LoggerModule = __legacyDecorateClassTS([
-  Module({
-    extensions: [],
-    middlewares: []
-  })
-], LoggerModule);
-
-// src/extensions/index.ts
-import { LoggerManager as LoggerManager7, LogLevel as LogLevel2, SimpleLogger as SimpleLogger2 } from "@dangao/logsmith";
 // src/swagger/decorators.ts
 import"reflect-metadata";
 var API_TAG_METADATA_KEY = Symbol("swagger:api-tag");
@@ -4447,13 +4626,198 @@ function createHttpMetricsMiddleware(collector) {
     return response;
   };
 }
+// src/database/orm/transaction-types.ts
+var Propagation;
+((Propagation2) => {
+  Propagation2["REQUIRED"] = "REQUIRED";
+  Propagation2["REQUIRES_NEW"] = "REQUIRES_NEW";
+  Propagation2["SUPPORTS"] = "SUPPORTS";
+  Propagation2["NOT_SUPPORTED"] = "NOT_SUPPORTED";
+  Propagation2["NEVER"] = "NEVER";
+  Propagation2["NESTED"] = "NESTED";
+})(Propagation ||= {});
+var IsolationLevel;
+((IsolationLevel2) => {
+  IsolationLevel2["READ_UNCOMMITTED"] = "READ_UNCOMMITTED";
+  IsolationLevel2["READ_COMMITTED"] = "READ_COMMITTED";
+  IsolationLevel2["REPEATABLE_READ"] = "REPEATABLE_READ";
+  IsolationLevel2["SERIALIZABLE"] = "SERIALIZABLE";
+})(IsolationLevel ||= {});
+var TransactionStatus;
+((TransactionStatus2) => {
+  TransactionStatus2["ACTIVE"] = "ACTIVE";
+  TransactionStatus2["COMMITTED"] = "COMMITTED";
+  TransactionStatus2["ROLLED_BACK"] = "ROLLED_BACK";
+  TransactionStatus2["SUSPENDED"] = "SUSPENDED";
+})(TransactionStatus ||= {});
+var TRANSACTION_SERVICE_TOKEN = Symbol("@dangao/bun-server:orm:transaction:service");
+
+// src/database/orm/transaction-decorator.ts
+import"reflect-metadata";
+var TRANSACTION_METADATA_KEY = Symbol("@dangao/bun-server:orm:transaction");
+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;
+  }
+  let metadata = Reflect.getMetadata(TRANSACTION_METADATA_KEY, target, propertyKey);
+  if (metadata !== undefined) {
+    return metadata;
+  }
+  const prototype = Object.getPrototypeOf(target);
+  if (prototype && prototype !== Object.prototype) {
+    metadata = Reflect.getMetadata(TRANSACTION_METADATA_KEY, prototype, propertyKey);
+    if (metadata !== undefined) {
+      return metadata;
+    }
+  }
+  const constructor = target.constructor;
+  if (constructor && typeof constructor === "function") {
+    if (target !== constructor.prototype) {
+      metadata = Reflect.getMetadata(TRANSACTION_METADATA_KEY, constructor.prototype, propertyKey);
+      if (metadata !== undefined) {
+        return metadata;
+      }
+    }
+  }
+  return;
+}
+
+// src/database/orm/transaction-interceptor.ts
+class TransactionInterceptor {
+  async execute(target, propertyKey, originalMethod, args, container, context2) {
+    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 TransactionInterceptor.executeInExistingTransaction(originalMethod, target, args, currentTransaction.id, transactionManager);
+        } else {
+          return await TransactionInterceptor.executeInNewTransaction(originalMethod, target, args, transactionMetadata, transactionManager);
+        }
+      case "REQUIRES_NEW" /* REQUIRES_NEW */:
+        return await TransactionInterceptor.executeInNewTransaction(originalMethod, target, args, transactionMetadata, transactionManager);
+      case "SUPPORTS" /* SUPPORTS */:
+        if (currentTransaction) {
+          return await TransactionInterceptor.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 TransactionInterceptor.executeInNestedTransaction(originalMethod, target, args, currentTransaction.id, transactionMetadata, transactionManager);
+        } else {
+          return await TransactionInterceptor.executeInNewTransaction(originalMethod, target, args, transactionMetadata, transactionManager);
+        }
+      default:
+        return await Promise.resolve(originalMethod.apply(target, args));
+    }
+  }
+  static async executeWithTransaction(target, propertyKey, originalMethod, args, container) {
+    const interceptor = new TransactionInterceptor;
+    return await interceptor.execute(target, propertyKey, originalMethod, args, container);
+  }
+  static async executeInNewTransaction(method, target, args, options, transactionManager) {
+    const context2 = await transactionManager.beginTransaction({
+      timeout: options.timeout
+    });
+    try {
+      const result = await Promise.resolve(method.apply(target, args));
+      await transactionManager.commitTransaction(context2.id);
+      return result;
+    } catch (error) {
+      if (this.shouldRollback(error, options.rollbackFor, options.noRollbackFor)) {
+        await transactionManager.rollbackTransaction(context2.id);
+      } else {
+        await transactionManager.commitTransaction(context2.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;
+  }
+}
+
 // src/database/types.ts
 var DATABASE_SERVICE_TOKEN = Symbol("@dangao/bun-server:database:service");
 var DATABASE_OPTIONS_TOKEN = Symbol("@dangao/bun-server:database:options");
 
 // src/database/database-extension.ts
 class DatabaseExtension {
-  register(container) {}
+  register(container) {
+    try {
+      const interceptorRegistry = container.resolve(INTERCEPTOR_REGISTRY_TOKEN);
+      const transactionInterceptor = new TransactionInterceptor;
+      interceptorRegistry.register(TRANSACTION_METADATA_KEY, transactionInterceptor, 50);
+    } catch (error) {}
+  }
   async initialize(container) {
     try {
       const databaseService = container.resolve(DATABASE_SERVICE_TOKEN);
@@ -4551,7 +4915,6 @@ OrmService = __legacyDecorateClassTS([
 ], OrmService);
 
 // src/database/orm/transaction-manager.ts
-init_transaction_types();
 class TransactionManager {
   databaseService;
   transactions = new Map;
@@ -5111,7 +5474,6 @@ DatabaseService2 = __legacyDecorateClassTS([
 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 = [];
@@ -5241,10 +5603,6 @@ function getRepositoryMetadata(target) {
   }
   return;
 }
-
-// src/database/orm/index.ts
-init_transaction_decorator();
-
 // src/database/orm/repository.ts
 class BaseRepository {
   databaseService;
@@ -5312,10 +5670,6 @@ class DrizzleBaseRepository {
     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";
 
@@ -6256,6 +6610,7 @@ function Session() {
   return createParamDecorator("session" /* SESSION */);
 }
 export {
+  scanInterceptorMetadata,
   requiresAuth,
   getTransactionMetadata,
   getRepositoryMetadata,
@@ -6317,11 +6672,14 @@ export {
   Propagation,
   PrometheusFormatter,
   PrimaryKey,
+  PermissionInterceptor,
+  Permission,
   PerformanceHarness,
   ParamBinder,
   Param,
   PUT,
   POST,
+  PERMISSION_METADATA_KEY,
   PATCH,
   OrmService,
   OnOpen,
@@ -6347,7 +6705,10 @@ export {
   LoggerModule,
   LoggerExtension,
   LogLevel2 as LogLevel,
+  LogInterceptor,
+  Log,
   Lifecycle,
+  LOG_METADATA_KEY,
   LOGGER_TOKEN,
   JwtAuthenticationProvider,
   JWT_UTIL_TOKEN,
@@ -6358,8 +6719,11 @@ export {
   IsNumber,
   IsEmail,
   InternalServerErrorException,
+  InterceptorRegistry,
+  InterceptorChain,
   Injectable,
   Inject,
+  INTERCEPTOR_REGISTRY_TOKEN,
   HttpException,
   HealthModule,
   Header,
@@ -6391,14 +6755,18 @@ export {
   CacheService,
   CachePut,
   CacheModule,
+  CacheInterceptor,
   CacheEvict,
+  Cache,
   CONFIG_SERVICE_TOKEN,
   CACHE_SERVICE_TOKEN,
   CACHE_OPTIONS_TOKEN,
+  CACHE_METADATA_KEY,
   BunServer,
   BodyParser,
   Body,
   BaseRepository,
+  BaseInterceptor,
   BadRequestException,
   AuthenticationManager,
   Auth,