@hono-di/core 0.0.9 → 0.0.15

package/dist/index.cjs

@@ -407,14 +407,13 @@ var Container = class {
 };
 
 // src/injector/context-id.ts
-var ContextId = class _ContextId {
+var ContextId = class {
   static {
     __name(this, "ContextId");
   }
-  static idCounter = 0;
   id;
   constructor() {
-    this.id = _ContextId.idCounter++;
+    this.id = crypto.randomUUID();
   }
 };
 new ContextId();
@@ -459,6 +458,13 @@ var ModuleRefImpl = class extends ModuleRef {
     }
     return this.injector.loadInstance(wrapper, contextId || new ContextId());
   }
+  async create(type, contextId) {
+    const instance = await this.injector.resolveConstructorParams({
+      metatype: type
+    }, this.moduleRef, Reflect.getMetadata("design:paramtypes", type) || [], () => {
+    }, contextId || new ContextId());
+    return new type(...instance);
+  }
 };
 
 // src/injector/injector.ts
@@ -471,8 +477,12 @@ var Injector = class {
     this.container = container;
   }
   async resolveConstructorParams(wrapper, module, inject, callback, contextId = new ContextId(), inquire = [], parentInquire = []) {
-    if (inquire.some((item) => item === wrapper) && wrapper.scope === Scope.DEFAULT) {
-      throw new Error(`Circular dependency detected: ${wrapper.name}`);
+    if (inquire.some((item) => item === wrapper)) {
+      const chain = [
+        ...inquire,
+        wrapper
+      ].map((w) => w.name || "Unknown").join(" -> ");
+      throw new Error(`Circular dependency detected: ${chain}`);
     }
     const args = [];
     for (const [index, token] of inject.entries()) {
@@ -513,13 +523,13 @@ var Injector = class {
     return this.loadInstance(wrapper, contextId, inquire);
   }
   lookupProvider(token, module) {
-    if (module.hasProvider(token)) {
-      return module.getProvider(token);
-    }
+    let wrapper = module.getProvider(token);
+    if (wrapper) return wrapper;
     for (const importedModule of module.imports) {
       if (importedModule.exports.has(token)) {
-        if (importedModule.hasProvider(token)) {
-          return importedModule.getProvider(token);
+        wrapper = importedModule.getProvider(token);
+        if (wrapper) {
+          return wrapper;
         }
         const nestedWrapper = this.lookupProvider(token, importedModule);
         if (nestedWrapper) return nestedWrapper;
@@ -529,8 +539,9 @@ var Injector = class {
       for (const globalModule of this.container.getGlobalModules()) {
         if (globalModule === module) continue;
         if (globalModule.exports.has(token)) {
-          if (globalModule.hasProvider(token)) {
-            return globalModule.getProvider(token);
+          wrapper = globalModule.getProvider(token);
+          if (wrapper) {
+            return wrapper;
           }
           const nestedWrapper = this.lookupProvider(token, globalModule);
           if (nestedWrapper) return nestedWrapper;
@@ -585,7 +596,15 @@ var Injector = class {
     }, contextId, inquire);
     const instance = new metatype(...constructorArgs);
     if (wrapper.properties) {
+      const UNSAFE_KEYS = [
+        "__proto__",
+        "constructor",
+        "prototype"
+      ];
       for (const prop of wrapper.properties) {
+        if (typeof prop.key === "string" && UNSAFE_KEYS.includes(prop.key)) {
+          throw new Error(`Unsafe property injection detected: ${prop.key}`);
+        }
         const propInstance = await this.resolveSingleParam(prop.token, wrapper.host, contextId, inquire, prop.isOptional);
         if (propInstance !== void 0) {
           instance[prop.key] = propInstance;
@@ -637,6 +656,7 @@ var InstanceWrapper = class {
     this.useExisting = metadata.useExisting;
     this.isAlias = !!metadata.useExisting;
     this.isOptional = metadata.isOptional;
+    this.properties = metadata.properties;
     this.id = Math.random().toString(36).substring(7);
   }
   getInstanceByContextId(contextId) {
@@ -661,6 +681,13 @@ var InstanceWrapper = class {
     }
     this.inject[index] = token;
   }
+  cleanup(contextId) {
+    if (contextId) {
+      this.instancesPerContext.delete(contextId);
+    } else {
+      this.instancesPerContext.clear();
+    }
+  }
 };
 
 // src/services/logger.service.ts
@@ -714,7 +741,14 @@ var Logger = class _Logger {
     const timestamp = date.toLocaleString();
     const pid = process.pid;
     const contextMessage = context ? `[${context}] ` : "";
-    const output = message instanceof Object ? JSON.stringify(message, null, 2) : message;
+    let output;
+    if (typeof message === "symbol") {
+      output = message.toString();
+    } else if (message instanceof Object) {
+      output = JSON.stringify(message, null, 2);
+    } else {
+      output = String(message);
+    }
     const currentTimestamp = Date.now();
     const timeDiff = _Logger.updateAndGetTimestampDiff(currentTimestamp);
     const C = {
@@ -761,15 +795,15 @@ var Logger = class _Logger {
 };
 
 // src/scanner.ts
-var HonoDiScanner = class {
+var Scanner = class {
   static {
-    __name(this, "HonoDiScanner");
+    __name(this, "Scanner");
   }
   container;
   constructor(container) {
     this.container = container;
   }
-  logger = new Logger("HonoDiScanner");
+  logger = new Logger("Scanner");
   async scan(module) {
     await this.scanModule(module);
   }
@@ -858,12 +892,13 @@ var HonoDiScanner = class {
     const isPlainObject = provider && typeof provider === "object" && "provide" in provider;
     if (!isPlainObject) {
       const token2 = provider;
+      const providerScope = Reflect.getMetadata(METADATA_KEYS.SCOPE, provider) ?? Scope.DEFAULT;
       const wrapper2 = new InstanceWrapper({
         token: token2,
         name: token2.name,
         metatype: provider,
         host: moduleRef,
-        scope: Scope.DEFAULT
+        scope: providerScope
       });
       this.scanDependencies(wrapper2);
       moduleRef.addProvider(wrapper2);
@@ -892,12 +927,13 @@ var HonoDiScanner = class {
   }
   insertController(controller, moduleRef) {
     const token = controller;
+    const controllerScope = Reflect.getMetadata(METADATA_KEYS.SCOPE, controller) ?? Scope.DEFAULT;
     const wrapper = new InstanceWrapper({
       token,
       name: token.name,
       metatype: controller,
       host: moduleRef,
-      scope: Scope.DEFAULT
+      scope: controllerScope
     });
     this.scanDependencies(wrapper);
     moduleRef.addController(wrapper);
@@ -1011,6 +1047,172 @@ var MiddlewareConfigProxyImpl = class MiddlewareConfigProxyImpl2 {
   }
 };
 
+// src/application/context-manager.ts
+var ContextManager = class {
+  static {
+    __name(this, "ContextManager");
+  }
+  activeContexts = /* @__PURE__ */ new Set();
+  /**
+   * Registers a new context as active
+   */
+  addContext(contextId) {
+    this.activeContexts.add(contextId);
+  }
+  /**
+   * Removes a context and allows cleanup
+   */
+  removeContext(contextId) {
+    this.activeContexts.delete(contextId);
+  }
+  /**
+   * Gets all currently active contexts
+   */
+  getActiveContexts() {
+    return this.activeContexts;
+  }
+  /**
+   * Clears all tracked contexts
+   */
+  clearAll() {
+    this.activeContexts.clear();
+  }
+};
+
+// src/application/lifecycle-manager.ts
+var LifecycleManager = class {
+  static {
+    __name(this, "LifecycleManager");
+  }
+  logger = new Logger("LifecycleManager");
+  /**
+   * Calls a lifecycle hook on all providers/controllers in all modules
+   * 
+   * @param hookName - Name of the lifecycle method to call
+   * @param container - DI container with all modules
+   */
+  async callHook(hookName, container) {
+    const modules = container.getModules();
+    for (const module of modules.values()) {
+      for (const wrapper of module.providers.values()) {
+        const instance = wrapper.instance;
+        if (instance && typeof instance[hookName] === "function") {
+          await instance[hookName]();
+        }
+      }
+      for (const wrapper of module.controllers.values()) {
+        const instance = wrapper.instance;
+        if (instance && typeof instance[hookName] === "function") {
+          await instance[hookName]();
+        }
+      }
+    }
+  }
+  /**
+   * Calls OnModuleInit on all modules
+   */
+  async onModuleInit(container) {
+    this.logger.log("Calling OnModuleInit...");
+    await this.callHook("onModuleInit", container);
+  }
+  /**
+   * Calls OnApplicationBootstrap on all modules
+   */
+  async onApplicationBootstrap(container) {
+    this.logger.log("Calling OnApplicationBootstrap...");
+    await this.callHook("onApplicationBootstrap", container);
+  }
+  /**
+   * Calls shutdown hooks on all modules
+   */
+  async onApplicationShutdown(container) {
+    this.logger.log("Calling shutdown hooks...");
+    await this.callHook("beforeApplicationShutdown", container);
+    await this.callHook("onApplicationShutdown", container);
+  }
+};
+
+// src/application/argument-resolver.ts
+var ArgumentResolver = class {
+  static {
+    __name(this, "ArgumentResolver");
+  }
+  /**
+   * Resolves arguments from request context based on metadata
+   * 
+   * @param c - Hono context
+   * @param argsMetadata - Pre-parsed argument metadata
+   * @param pipes - Pipes to apply to arguments
+   * @param executionContext - Execution context for guards/interceptors
+   * @param moduleRef - Module reference for DI
+   * @param contextId - Request context ID
+   * @returns Array of resolved arguments
+   */
+  async resolveArgs(c, argsMetadata, pipes, executionContext, moduleRef, contextId) {
+    const args = [];
+    for (const metadata of argsMetadata) {
+      let value;
+      switch (metadata.paramtype) {
+        case RouteParamtypes.BODY:
+          value = await c.req.json().catch(() => ({}));
+          if (metadata.data) {
+            value = value[metadata.data];
+          }
+          break;
+        case RouteParamtypes.QUERY:
+          if (metadata.data) {
+            value = c.req.query(metadata.data);
+          } else {
+            value = c.req.query();
+          }
+          break;
+        case RouteParamtypes.PARAM:
+          if (metadata.data) {
+            value = c.req.param(metadata.data);
+          } else {
+            value = c.req.param();
+          }
+          break;
+        case RouteParamtypes.HEADERS:
+          if (metadata.data) {
+            value = c.req.header(metadata.data);
+          } else {
+            const headers = {};
+            c.req.raw.headers.forEach((val, key) => {
+              headers[key] = val;
+            });
+            value = headers;
+          }
+          break;
+        case RouteParamtypes.CONTEXT:
+          value = c;
+          break;
+        case RouteParamtypes.REQUEST:
+          value = c.req;
+          break;
+        case RouteParamtypes.RESPONSE:
+          value = c.res;
+          break;
+        default:
+          value = void 0;
+      }
+      const allPipes = [
+        ...metadata.pipes,
+        ...pipes
+      ];
+      for (const pipe of allPipes) {
+        value = await pipe.transform(value, {
+          type: metadata.paramtype,
+          data: metadata.data,
+          metatype: void 0
+        });
+      }
+      args[metadata.index] = value;
+    }
+    return args;
+  }
+};
+
 // src/common/exceptions/http.exception.ts
 var HttpException = class extends Error {
   static {
@@ -1173,10 +1375,191 @@ var GatewayTimeoutException = class extends HttpException {
   }
 };
 
-// src/application.ts
-var HonoDiApplication = class {
+// src/application/exception-handler.ts
+var ExceptionHandler = class {
+  static {
+    __name(this, "ExceptionHandler");
+  }
+  logger = new Logger("ExceptionHandler");
+  /**
+   * Handles an exception through the filter chain
+   * 
+   * @param exception - The exception to handle
+   * @param c - Hono context
+   * @param controllerClass - Controller class
+   * @param methodName - Handler method name
+   * @param moduleRef - Module reference
+   * @param contextId - Context ID
+   * @param globalFilters - Global exception filters
+   * @param resolveFilters - Function to resolve filters
+   * @returns Response from filter or default error response
+   */
+  async handle(exception, c, controllerClass, methodName, moduleRef, contextId, globalFilters, resolveFilters) {
+    const filters = await resolveFilters([
+      ...Reflect.getMetadata(METADATA_KEYS.USE_FILTERS, moduleRef.controllers.get(controllerClass)?.instance?.[methodName]) || [],
+      ...Reflect.getMetadata(METADATA_KEYS.USE_FILTERS, controllerClass) || [],
+      ...globalFilters
+    ], moduleRef, contextId);
+    for (const filter of filters) {
+      const catchExceptions = Reflect.getMetadata(METADATA_KEYS.FILTER_CATCH, filter.constructor) || [];
+      if (catchExceptions.length === 0 || catchExceptions.some((e) => exception instanceof e)) {
+        const host = new ExecutionContextHost([
+          c
+        ], controllerClass, moduleRef.controllers.get(controllerClass)?.instance?.[methodName]);
+        return await filter.catch(exception, host);
+      }
+    }
+    return this.handleDefault(exception, c);
+  }
+  /**
+   * Default exception handling when no filter matches
+   */
+  async handleDefault(exception, c) {
+    this.logger.error(exception);
+    if (exception instanceof HttpException) {
+      const status = exception.getStatus();
+      const response = exception.getResponse();
+      c.status(status);
+      return c.json(response);
+    }
+    if (exception instanceof Error) {
+      c.status(500);
+      return c.json({
+        statusCode: 500,
+        message: "Internal Server Error",
+        cause: exception.message
+      });
+    }
+    c.status(500);
+    return c.json({
+      statusCode: 500,
+      message: "Internal Server Error",
+      error: String(exception)
+    });
+  }
+};
+
+// src/application/middleware-handler.ts
+var MiddlewareHandler = class {
+  static {
+    __name(this, "MiddlewareHandler");
+  }
+  logger = new Logger("MiddlewareHandler");
+  /**
+   * Registers all middleware to the Hono app
+   * 
+   * @param app - Hono instance
+   * @param middlewareConfigs - Middleware configurations from modules
+   * @param container - DI container
+   * @param injector - Injector for resolving middleware instances
+   */
+  async registerMiddleware(app, middlewareConfigs, container, injector) {
+    const resolvedConfigs = [];
+    for (const config of middlewareConfigs) {
+      const instances = [];
+      for (const middleware of config.middlewares) {
+        if (typeof middleware === "function") {
+          const modules = container.getModules();
+          let wrapper;
+          for (const module of modules.values()) {
+            wrapper = module.getProvider(middleware);
+            if (wrapper) break;
+          }
+          if (!wrapper) {
+            wrapper = new InstanceWrapper({
+              token: middleware,
+              name: middleware.name,
+              metatype: middleware,
+              host: Array.from(modules.values())[0]
+            });
+          }
+          const instance = wrapper.instance || await injector.loadInstance(wrapper, new ContextId());
+          instances.push(instance);
+        } else {
+          instances.push(middleware);
+        }
+      }
+      resolvedConfigs.push({
+        ...config,
+        instances
+      });
+    }
+    app.use("*", async (c, next) => {
+      const path = c.req.path;
+      const method = c.req.method;
+      const matchingMiddleware = [];
+      for (const config of resolvedConfigs) {
+        if (this.isRouteExcluded(config.excludes, path, method)) continue;
+        if (this.isRouteMatch(config.routes, path, method)) {
+          matchingMiddleware.push(...config.instances);
+        }
+      }
+      if (matchingMiddleware.length === 0) {
+        return await next();
+      }
+      const executeChain = /* @__PURE__ */ __name(async (index, finalNext) => {
+        if (index >= matchingMiddleware.length) {
+          return await finalNext();
+        }
+        const middleware = matchingMiddleware[index];
+        return new Promise((resolve, reject) => {
+          let nextCalled = false;
+          const nextFn = /* @__PURE__ */ __name(async () => {
+            nextCalled = true;
+            try {
+              await executeChain(index + 1, finalNext);
+              resolve();
+            } catch (e) {
+              reject(e);
+            }
+          }, "nextFn");
+          try {
+            const useFn = middleware.use ? middleware.use.bind(middleware) : middleware;
+            const result = useFn(c, nextFn);
+            if (result instanceof Promise) {
+              result.then(() => {
+                if (!nextCalled) resolve();
+              }).catch(reject);
+            } else {
+              if (!nextCalled) resolve();
+            }
+          } catch (e) {
+            reject(e);
+          }
+        });
+      }, "executeChain");
+      await executeChain(0, next);
+    });
+  }
+  isRouteMatch(routes, path, method) {
+    for (const route of routes) {
+      if (typeof route === "string") {
+        const normalizedRoute = route === "*" ? "*" : route.startsWith("/") ? route : `/${route}`;
+        if (normalizedRoute === "*" || path.startsWith(normalizedRoute)) return true;
+        if (path === normalizedRoute) return true;
+      } else if (route instanceof RegExp) {
+        if (route.test(path)) return true;
+      }
+    }
+    return false;
+  }
+  isRouteExcluded(excludes, path, method) {
+    for (const exclude of excludes) {
+      if (typeof exclude === "string") {
+        const normalizedExclude = exclude.startsWith("/") ? exclude : `/${exclude}`;
+        if (path.startsWith(normalizedExclude)) return true;
+      } else if (exclude instanceof RegExp) {
+        if (exclude.test(path)) return true;
+      }
+    }
+    return false;
+  }
+};
+
+// src/application/index.ts
+var Application = class {
   static {
-    __name(this, "HonoDiApplication");
+    __name(this, "Application");
   }
   app;
   container;
@@ -1185,28 +1568,114 @@ var HonoDiApplication = class {
   globalPipes = [];
   globalGuards = [];
   globalInterceptors = [];
+  scanner;
+  // Delegate to managers
+  contextManager = new ContextManager();
+  lifecycleManager = new LifecycleManager();
+  argumentResolver = new ArgumentResolver();
+  exceptionHandler = new ExceptionHandler();
+  middlewareHandler = new MiddlewareHandler();
+  // Security: Dangerous property names that should not be injected
+  UNSAFE_PROPERTIES = /* @__PURE__ */ new Set([
+    "__proto__",
+    "constructor",
+    "prototype"
+  ]);
+  // Performance: Route metadata cache
+  routeCache = /* @__PURE__ */ new Map();
   constructor(app, container, injector) {
     this.app = app;
     this.container = container;
     this.injector = injector;
-  }
+    this.scanner = new Scanner(container);
+  }
+  /**
+   * Registers global exception filters
+   * 
+   * @param filters - Exception filter instances or classes
+   * @returns This application instance for chaining
+   * 
+   * @example
+   * ```typescript
+   * app.useGlobalFilters(new HttpExceptionFilter());
+   * ```
+   * 
+   * @public
+   */
   useGlobalFilters(...filters) {
     this.globalFilters.push(...filters);
     return this;
   }
+  /**
+   * Registers global pipes for request transformation/validation
+   * 
+   * @param pipes - Pipe instances or classes
+   * @returns This application instance for chaining
+   * 
+   * @example
+   * ```typescript
+   * app.useGlobalPipes(new ValidationPipe());
+   * ```
+   * 
+   * @public
+   */
   useGlobalPipes(...pipes) {
     this.globalPipes.push(...pipes);
     return this;
   }
+  /**
+   * Registers global interceptors for request/response manipulation
+   * 
+   * @param interceptors - Interceptor instances or classes
+   * @returns This application instance for chaining
+   * 
+   * @example
+   * ```typescript
+   * app.useGlobalInterceptors(new LoggingInterceptor());
+   * ```
+   * 
+   * @public
+   */
   useGlobalInterceptors(...interceptors) {
     this.globalInterceptors.push(...interceptors);
     return this;
   }
+  /**
+   * Registers global guards for route protection
+   * 
+   * @param guards - Guard instances or classes
+   * @returns This application instance for chaining
+   * 
+   * @example
+   * ```typescript
+   * app.useGlobalGuards(new AuthGuard());
+   * ```
+   * 
+   * @public
+   */
   useGlobalGuards(...guards) {
     this.globalGuards.push(...guards);
     return this;
   }
   globalPrefix = "";
+  /**
+   * Sets a global prefix for all routes
+   * 
+   * @param prefix - URL prefix (e.g., 'api' or 'api/v1')
+   * @returns This application instance for chaining
+   * 
+   * @remarks
+   * Must be called before init() if using autoInit: true.
+   * Use autoInit: false in HonoDiFactory.create() to set prefix before initialization.
+   * 
+   * @example
+   * ```typescript
+   * app.setGlobalPrefix('api/v1');
+   * // All routes will be prefixed with /api/v1
+   * ```
+   * 
+   * @public
+   */
   setGlobalPrefix(prefix) {
     if (this.isInitialized) {
       this.logger.warn("Setting global prefix after initialization will not affect existing routes. Use { autoInit: false } in HonoDiFactory.create() if you need to set a prefix.");
@@ -1217,8 +1686,22 @@ var HonoDiApplication = class {
   getGlobalPrefix() {
     return this.globalPrefix;
   }
-  logger = new Logger("HonoDiApplication");
+  logger = new Logger("Application");
   isInitialized = false;
+  /**
+   * Initializes the application by registering all routes and middleware
+   * 
+   * @returns Promise resolving to this application instance
+   * 
+   * @remarks
+   * Called automatically unless autoInit: false is specified in HonoDiFactory.create().
+   * Handles:
+   * - Middleware registration
+   * - Controller and route registration
+   * - Lifecycle hook execution (OnApplicationBootstrap)
+   * 
+   * @public
+   */
   async init() {
     if (this.isInitialized) return this;
     this.logger.log("Initializing middleware...");
@@ -1269,26 +1752,63 @@ var HonoDiApplication = class {
     const { prefix } = Reflect.getMetadata(METADATA_KEYS.CONTROLLER, controllerClass);
     const routes = Reflect.getMetadata(METADATA_KEYS.ROUTES, controllerClass);
     if (!routes) return;
+    const controllerGuards = Reflect.getMetadata(METADATA_KEYS.USE_GUARDS, controllerClass) || [];
+    const controllerInterceptors = Reflect.getMetadata(METADATA_KEYS.USE_INTERCEPTORS, controllerClass) || [];
+    const controllerPipes = Reflect.getMetadata(METADATA_KEYS.USE_PIPES, controllerClass) || [];
     routes.forEach((route) => {
       const globalPrefix = this.getGlobalPrefix();
       const fullPath = this.combinePaths(globalPrefix, this.combinePaths(prefix, route.path));
+      const cacheKey = `${controllerClass.name}.${route.methodName}`;
+      const handler = controllerClass.prototype[route.methodName];
+      const methodGuards = Reflect.getMetadata(METADATA_KEYS.USE_GUARDS, handler) || [];
+      const methodInterceptors = Reflect.getMetadata(METADATA_KEYS.USE_INTERCEPTORS, handler) || [];
+      const methodPipes = Reflect.getMetadata(METADATA_KEYS.USE_PIPES, handler) || [];
+      const allGuards = [
+        ...this.globalGuards,
+        ...controllerGuards,
+        ...methodGuards
+      ];
+      const allInterceptors = [
+        ...this.globalInterceptors,
+        ...controllerInterceptors,
+        ...methodInterceptors
+      ];
+      const allPipes = [
+        ...this.globalPipes,
+        ...controllerPipes,
+        ...methodPipes
+      ];
+      const argsMetadata = Reflect.getMetadata(METADATA_KEYS.ROUTE_ARGS_METADATA, controllerClass, route.methodName) || {};
+      const parsedArgs = Object.values(argsMetadata).sort((a, b) => a.index - b.index).map((arg) => ({
+        index: arg.index,
+        data: arg.data,
+        paramtype: arg.paramtype,
+        pipes: arg.pipes || []
+      }));
+      const wrapper = moduleRef.controllers.get(controllerClass);
+      this.routeCache.set(cacheKey, {
+        wrapper,
+        handler,
+        guards: allGuards,
+        interceptors: allInterceptors,
+        pipes: allPipes,
+        argsMetadata: parsedArgs,
+        httpCode: Reflect.getMetadata(METADATA_KEYS.HTTP_CODE, handler),
+        headers: Reflect.getMetadata(METADATA_KEYS.HEADERS, handler),
+        redirect: Reflect.getMetadata(METADATA_KEYS.REDIRECT, handler)
+      });
       app[route.requestMethod](fullPath, async (c) => {
         const contextId = new ContextId();
+        this.contextManager.addContext(contextId);
+        const cacheKey2 = `${controllerClass.name}.${route.methodName}`;
+        const cache = this.routeCache.get(cacheKey2);
         const executionContext = new ExecutionContextHost([
           c
-        ], controllerClass, controllerClass.prototype[route.methodName]);
+        ], controllerClass, cache.handler);
         try {
-          const wrapper = moduleRef.getProvider(controllerClass) || moduleRef.controllers.get(controllerClass);
-          if (!wrapper) {
-            throw new Error(`Controller ${controllerClass.name} not found in module ${moduleRef.metatype.name}`);
-          }
-          const controllerInstance = await this.injector.loadInstance(wrapper, contextId);
-          const handler = controllerInstance[route.methodName].bind(controllerInstance);
-          const guards = await this.resolveContextItems([
-            ...this.globalGuards,
-            ...Reflect.getMetadata(METADATA_KEYS.USE_GUARDS, controllerClass) || [],
-            ...Reflect.getMetadata(METADATA_KEYS.USE_GUARDS, controllerInstance[route.methodName]) || []
-          ], moduleRef, contextId);
+          const controllerInstance = await this.injector.loadInstance(cache.wrapper, contextId);
+          const handler2 = controllerInstance[route.methodName].bind(controllerInstance);
+          const guards = await this.resolveContextItems(cache.guards, moduleRef, contextId);
           if (!await this.runGuards(guards, executionContext)) {
             c.status(403);
             return c.json({
@@ -1296,25 +1816,16 @@ var HonoDiApplication = class {
               message: "Forbidden resource"
             });
           }
-          const interceptors = await this.resolveContextItems([
-            ...this.globalInterceptors,
-            ...Reflect.getMetadata(METADATA_KEYS.USE_INTERCEPTORS, controllerClass) || [],
-            ...Reflect.getMetadata(METADATA_KEYS.USE_INTERCEPTORS, controllerInstance[route.methodName]) || []
-          ], moduleRef, contextId);
-          const pipes = await this.resolveContextItems([
-            ...this.globalPipes,
-            ...Reflect.getMetadata(METADATA_KEYS.USE_PIPES, controllerClass) || [],
-            ...Reflect.getMetadata(METADATA_KEYS.USE_PIPES, controllerInstance[route.methodName]) || []
-          ], moduleRef, contextId);
-          const args = await this.resolveArgs(contextId, executionContext, controllerClass, route.methodName, moduleRef, pipes);
-          if (args.length === 0 && !Reflect.hasMetadata(METADATA_KEYS.ROUTE_ARGS_METADATA, controllerClass, route.methodName)) {
-            args.push(c);
-          }
+          const interceptors = await this.resolveContextItems(cache.interceptors, moduleRef, contextId);
+          const pipes = await this.resolveContextItems(cache.pipes, moduleRef, contextId);
+          const args = cache.argsMetadata.length > 0 ? await this.resolveArgsFromCache(c, cache.argsMetadata, pipes, executionContext, moduleRef, contextId) : [
+            c
+          ];
           const interceptorChain = /* @__PURE__ */ __name(async (index) => {
             if (index >= interceptors.length) {
               return new rxjs.Observable((subscriber) => {
                 try {
-                  const result2 = handler(...args);
+                  const result2 = handler2(...args);
                   if (result2 instanceof Promise) {
                     result2.then((data) => {
                       subscriber.next(data);
@@ -1335,20 +1846,17 @@ var HonoDiApplication = class {
           }, "interceptorChain");
           const obs = await interceptorChain(0);
           const result = await rxjs.lastValueFrom(obs);
-          const httpCode = Reflect.getMetadata(METADATA_KEYS.HTTP_CODE, controllerInstance[route.methodName]);
-          if (httpCode) {
-            c.status(httpCode);
+          if (cache.httpCode) {
+            c.status(cache.httpCode);
           }
-          const headers = Reflect.getMetadata(METADATA_KEYS.HEADERS, controllerInstance[route.methodName]);
-          if (headers) {
-            headers.forEach((h) => c.header(h.name, h.value));
+          if (cache.headers) {
+            cache.headers.forEach((h) => c.header(h.name, h.value));
           }
-          const redirect = Reflect.getMetadata(METADATA_KEYS.REDIRECT, controllerInstance[route.methodName]);
-          if (redirect) {
+          if (cache.redirect) {
             if (result && typeof result === "object" && result.url) {
-              return c.redirect(result.url, result.statusCode || redirect.statusCode);
+              return c.redirect(result.url, result.statusCode || cache.redirect.statusCode);
             }
-            return c.redirect(redirect.url, redirect.statusCode);
+            return c.redirect(cache.redirect.url, cache.redirect.statusCode);
           }
           if (result instanceof Response) {
             return result;
@@ -1358,46 +1866,16 @@ var HonoDiApplication = class {
           }
           return c.json(result);
         } catch (exception) {
-          return await this.handleException(exception, c, controllerClass, route.methodName, moduleRef, contextId);
+          return await this.exceptionHandler.handle(exception, c, controllerClass, route.methodName, moduleRef, contextId, this.globalFilters, this.resolveContextItems.bind(this));
+        } finally {
+          this.cleanupContext(contextId);
         }
       });
       this.logger.log(`[Route] Mapped {${fullPath}, ${route.requestMethod.toUpperCase()}}`);
     });
   }
-  async handleException(exception, c, controllerClass, methodName, moduleRef, contextId) {
-    const filters = await this.resolveContextItems([
-      ...Reflect.getMetadata(METADATA_KEYS.USE_FILTERS, moduleRef.controllers.get(controllerClass)?.instance?.[methodName]) || [],
-      ...Reflect.getMetadata(METADATA_KEYS.USE_FILTERS, controllerClass) || [],
-      ...this.globalFilters
-    ], moduleRef, contextId);
-    for (const filter of filters) {
-      const catchExceptions = Reflect.getMetadata(METADATA_KEYS.FILTER_CATCH, filter.constructor) || [];
-      if (catchExceptions.length === 0 || catchExceptions.some((e) => exception instanceof e)) {
-        const host = new ExecutionContextHost([
-          c
-        ], controllerClass, moduleRef.controllers.get(controllerClass)?.instance?.[methodName]);
-        return await filter.catch(exception, host);
-      }
-    }
-    this.logger.error(exception);
-    if (exception instanceof HttpException) {
-      const status = exception.getStatus();
-      const response = exception.getResponse();
-      c.status(status);
-      return c.json(response);
-    }
-    if (exception instanceof Error) {
-      c.status(500);
-      return c.json({
-        statusCode: 500,
-        message: "Internal Server Error",
-        cause: exception.message
-      });
-    }
-  }
   async resolveContextItems(items, moduleRef, contextId) {
     const instances = [];
-    const scanner = new HonoDiScanner(this.container);
     for (const item of items) {
       if (typeof item === "function") {
         let wrapper = moduleRef.getProvider(item);
@@ -1409,7 +1887,7 @@ var HonoDiApplication = class {
             host: moduleRef,
             scope: Scope.TRANSIENT
           });
-          scanner.scanDependencies(wrapper);
+          this.scanner.scanDependencies(wrapper);
         }
         const instance = await this.injector.loadInstance(wrapper, contextId);
         instances.push(instance);
@@ -1497,6 +1975,66 @@ var HonoDiApplication = class {
     }
     return true;
   }
+  // Performance: Optimized args resolution using pre-parsed metadata
+  async resolveArgsFromCache(c, parsedArgs, methodPipes, context, moduleRef, contextId) {
+    const args = [];
+    for (const arg of parsedArgs) {
+      let value;
+      switch (arg.paramtype) {
+        case RouteParamtypes.REQUEST:
+          value = c.req;
+          break;
+        case RouteParamtypes.RESPONSE:
+          value = c;
+          break;
+        case RouteParamtypes.CONTEXT:
+          value = c;
+          break;
+        case RouteParamtypes.BODY:
+          try {
+            const body = await c.req.json();
+            value = arg.data ? body[arg.data] : body;
+          } catch (e) {
+            value = null;
+          }
+          break;
+        case RouteParamtypes.QUERY:
+          value = arg.data ? c.req.query(arg.data) : c.req.query();
+          break;
+        case RouteParamtypes.PARAM:
+          value = arg.data ? c.req.param(arg.data) : c.req.param();
+          break;
+        case RouteParamtypes.HEADERS:
+          value = arg.data ? c.req.header(arg.data) : c.req.header();
+          break;
+        case RouteParamtypes.IP:
+          value = c.req.header("x-forwarded-for") || "127.0.0.1";
+          break;
+        case RouteParamtypes.CUSTOM:
+          const factory = arg.pipes[0];
+          if (typeof factory === "function") {
+            value = factory(arg.data, context);
+          }
+          break;
+        default:
+          value = null;
+      }
+      const paramPipes = await this.resolveContextItems(arg.pipes, moduleRef, contextId);
+      const allPipes = [
+        ...methodPipes,
+        ...paramPipes
+      ];
+      for (const pipe of allPipes) {
+        value = await pipe.transform(value, {
+          type: "custom",
+          metatype: null,
+          data: arg.data
+        });
+      }
+      args[arg.index] = value;
+    }
+    return args;
+  }
   async initializeMiddleware() {
     const configs = [];
     const modules = this.container.getModules();
@@ -1524,7 +2062,7 @@ var HonoDiApplication = class {
             metatype: m,
             scope: Scope.TRANSIENT
           });
-          const scanner = new HonoDiScanner(this.container);
+          const scanner = new Scanner(this.container);
           scanner.scanDependencies(wrapper);
           const hostModule = config.module || modules.values().next().value;
           wrapper.host = hostModule;
@@ -1627,6 +2165,41 @@ var HonoDiApplication = class {
     throw new Error(`Provider ${String(typeOrToken)} not found`);
   }
   async close() {
+    await this.callLifecycleHook("beforeApplicationShutdown");
+    for (const contextId of this.contextManager.getActiveContexts()) {
+      this.cleanupContext(contextId);
+    }
+    this.contextManager.clearAll();
+    const modules = this.container.getModules();
+    for (const module of modules.values()) {
+      for (const wrapper of module.providers.values()) {
+        if (wrapper.scope !== Scope.DEFAULT) {
+          wrapper.cleanup();
+        }
+      }
+      for (const wrapper of module.controllers.values()) {
+        if (wrapper.scope !== Scope.DEFAULT) {
+          wrapper.cleanup();
+        }
+      }
+    }
+    await this.callLifecycleHook("onApplicationShutdown");
+  }
+  cleanupContext(contextId) {
+    this.contextManager.removeContext(contextId);
+    const modules = this.container.getModules();
+    for (const module of modules.values()) {
+      for (const wrapper of module.providers.values()) {
+        if (wrapper.scope === Scope.REQUEST) {
+          wrapper.cleanup(contextId);
+        }
+      }
+      for (const wrapper of module.controllers.values()) {
+        if (wrapper.scope === Scope.REQUEST) {
+          wrapper.cleanup(contextId);
+        }
+      }
+    }
   }
   // Getters for global items (internal use)
   getGlobalFilters() {
@@ -1651,7 +2224,31 @@ var HonoDiFactory = class {
   static {
     __name(this, "HonoDiFactory");
   }
-  static logger = new Logger("HonoDiFactory");
+  static logger = new Logger("Factory");
+  /**
+   * Creates and bootstraps a Hono DI application
+   * 
+   * @param rootModule - The root module class decorated with @Module
+   * @param appOrOptions - Optional Hono instance or configuration options
+   * @param appOrOptions.app - Custom Hono instance to use
+   * @param appOrOptions.autoInit - Whether to automatically initialize the app (default: true)
+   * 
+   * @returns Promise resolving to the initialized application instance
+   * 
+   * @throws {Error} If module scanning fails
+   * @throws {Error} If circular dependencies are detected
+   * @throws {Error} If required dependencies cannot be resolved
+   * 
+   * @remarks
+   * The creation process includes:
+   * 1. Module scanning and dependency graph building
+   * 2. Scope bubbling optimization (REQUEST-scoped propagation)
+   * 3. Singleton provider instantiation
+   * 4. Lifecycle hook execution (OnModuleInit, OnApplicationBootstrap)
+   * 5. Route registration and middleware setup
+   * 
+   * @public
+   */
   static async create(rootModule, appOrOptions) {
     let app;
     let autoInit = true;
@@ -1665,12 +2262,13 @@ var HonoDiFactory = class {
       }
     }
     const container = new Container();
-    const scanner = new HonoDiScanner(container);
+    const scanner = new Scanner(container);
     const injector = new Injector(container);
     const honoApp = app || new hono.Hono();
-    const bunApp = new HonoDiApplication(honoApp, container, injector);
+    const bunApp = new Application(honoApp, container, injector);
     this.logger.log("Scanning modules...");
     await scanner.scan(rootModule);
+    this.applyScopeBubbling(container);
     this.logger.log("Instantiating providers...");
     await this.instantiateProviders(container, injector);
     this.logger.log("Calling OnModuleInit...");
@@ -1680,6 +2278,61 @@ var HonoDiFactory = class {
     }
     return bunApp;
   }
+  static applyScopeBubbling(container) {
+    const modules = container.getModules();
+    const tokenMap = /* @__PURE__ */ new Map();
+    for (const module of modules.values()) {
+      for (const wrapper of module.providers.values()) {
+        tokenMap.set(wrapper.token, wrapper);
+      }
+      for (const wrapper of module.controllers.values()) {
+        tokenMap.set(wrapper.token, wrapper);
+      }
+    }
+    const hasRequestScopedDeps = /* @__PURE__ */ __name((wrapper, visited = /* @__PURE__ */ new Set()) => {
+      if (visited.has(wrapper)) return false;
+      visited.add(wrapper);
+      if (wrapper.inject) {
+        for (const token of wrapper.inject) {
+          const depWrapper = tokenMap.get(token);
+          if (depWrapper) {
+            if (depWrapper.scope === Scope.REQUEST) {
+              return true;
+            }
+            if (hasRequestScopedDeps(depWrapper, visited)) {
+              return true;
+            }
+          }
+        }
+      }
+      if (wrapper.properties) {
+        for (const prop of wrapper.properties) {
+          const depWrapper = tokenMap.get(prop.token);
+          if (depWrapper) {
+            if (depWrapper.scope === Scope.REQUEST) {
+              return true;
+            }
+            if (hasRequestScopedDeps(depWrapper, visited)) {
+              return true;
+            }
+          }
+        }
+      }
+      return false;
+    }, "hasRequestScopedDeps");
+    for (const module of modules.values()) {
+      for (const wrapper of module.providers.values()) {
+        if (wrapper.scope === Scope.DEFAULT && hasRequestScopedDeps(wrapper)) {
+          wrapper.scope = Scope.REQUEST;
+        }
+      }
+      for (const wrapper of module.controllers.values()) {
+        if (wrapper.scope === Scope.DEFAULT && hasRequestScopedDeps(wrapper)) {
+          wrapper.scope = Scope.REQUEST;
+        }
+      }
+    }
+  }
   static async instantiateProviders(container, injector) {
     const modules = container.getModules();
     const globalContextId = new ContextId();
@@ -1940,11 +2593,31 @@ exports.BaseExceptionFilter = class BaseExceptionFilter {
       honoCtx.status(status);
       return honoCtx.json(res);
     }
+    if (exception instanceof Error) {
+      console.error(exception);
+      honoCtx.status(500);
+      return honoCtx.json({
+        statusCode: 500,
+        message: "Internal Server Error",
+        cause: exception.message
+      });
+    }
     console.error(exception);
     honoCtx.status(500);
+    let errorMessage;
+    if (typeof exception === "symbol") {
+      errorMessage = exception.toString();
+    } else if (exception === null || exception === void 0) {
+      errorMessage = String(exception);
+    } else if (typeof exception === "object") {
+      errorMessage = JSON.stringify(exception);
+    } else {
+      errorMessage = String(exception);
+    }
     return honoCtx.json({
       statusCode: 500,
-      message: "Internal Server Error"
+      message: "Internal Server Error",
+      error: errorMessage
     });
   }
 };
@@ -1957,6 +2630,7 @@ var HonoDi = HonoDiFactory;
 
 exports.All = All;
 exports.AppError = AppError;
+exports.Application = Application;
 exports.BadGatewayException = BadGatewayException;
 exports.BadRequestError = BadRequestError;
 exports.BadRequestException = BadRequestException;
@@ -1981,9 +2655,7 @@ exports.Head = Head;
 exports.Header = Header;
 exports.Headers = Headers;
 exports.HonoDi = HonoDi;
-exports.HonoDiApplication = HonoDiApplication;
 exports.HonoDiFactory = HonoDiFactory;
-exports.HonoDiScanner = HonoDiScanner;
 exports.HostParam = HostParam;
 exports.HttpCode = HttpCode;
 exports.HttpException = HttpException;
@@ -2016,6 +2688,7 @@ exports.RequestMethod = RequestMethod;
 exports.RequestTimeoutException = RequestTimeoutException;
 exports.Response = Response2;
 exports.RouteParamtypes = RouteParamtypes;
+exports.Scanner = Scanner;
 exports.Scope = Scope;
 exports.ServiceUnavailableException = ServiceUnavailableException;
 exports.Session = Session;