@hono-di/core 0.0.7 → 0.0.9

package/dist/core.js

@@ -3,17 +3,11 @@ import { Hono } from 'hono';
 import { Observable, from, lastValueFrom } from 'rxjs';
 import { mergeMap } from 'rxjs/operators';
 
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __decorateClass = (decorators, target, key, kind) => {
-  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
-  for (var i = decorators.length - 1, decorator; i >= 0; i--)
-    if (decorator = decorators[i])
-      result = (decorator(result)) || result;
-  return result;
-};
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 
 // src/interfaces.ts
-var RequestMethod = /* @__PURE__ */ ((RequestMethod2) => {
+var RequestMethod = /* @__PURE__ */ (function(RequestMethod2) {
   RequestMethod2["GET"] = "get";
   RequestMethod2["POST"] = "post";
   RequestMethod2["PUT"] = "put";
@@ -23,18 +17,23 @@ var RequestMethod = /* @__PURE__ */ ((RequestMethod2) => {
   RequestMethod2["OPTIONS"] = "options";
   RequestMethod2["HEAD"] = "head";
   return RequestMethod2;
-})(RequestMethod || {});
+})({});
 
 // src/injector/module.ts
 var Module = class {
-  constructor(metatype, token) {
-    this.metatype = metatype;
-    this.token = token;
+  static {
+    __name(this, "Module");
   }
+  metatype;
+  token;
   _providers = /* @__PURE__ */ new Map();
   _imports = /* @__PURE__ */ new Set();
   _exports = /* @__PURE__ */ new Set();
   _controllers = /* @__PURE__ */ new Map();
+  constructor(metatype, token) {
+    this.metatype = metatype;
+    this.token = token;
+  }
   get providers() {
     return this._providers;
   }
@@ -69,6 +68,9 @@ var Module = class {
 
 // src/injector/container.ts
 var Container = class {
+  static {
+    __name(this, "Container");
+  }
   modules = /* @__PURE__ */ new Map();
   globalModules = /* @__PURE__ */ new Set();
   addModule(moduleMeta, token) {
@@ -95,6 +97,9 @@ var Container = class {
 
 // src/injector/context-id.ts
 var ContextId = class _ContextId {
+  static {
+    __name(this, "ContextId");
+  }
   static idCounter = 0;
   id;
   constructor() {
@@ -103,29 +108,47 @@ var ContextId = class _ContextId {
 };
 new ContextId();
 
+// src/injector/scope.ts
+var Scope = /* @__PURE__ */ (function(Scope2) {
+  Scope2[Scope2["DEFAULT"] = 0] = "DEFAULT";
+  Scope2[Scope2["TRANSIENT"] = 1] = "TRANSIENT";
+  Scope2[Scope2["REQUEST"] = 2] = "REQUEST";
+  return Scope2;
+})({});
+
 // src/injector/module-ref.ts
 var ModuleRef = class {
+  static {
+    __name(this, "ModuleRef");
+  }
 };
 var ModuleRefImpl = class extends ModuleRef {
+  static {
+    __name(this, "ModuleRefImpl");
+  }
+  container;
+  injector;
+  moduleRef;
   constructor(container, injector, moduleRef) {
-    super();
-    this.container = container;
-    this.injector = injector;
-    this.moduleRef = moduleRef;
+    super(), this.container = container, this.injector = injector, this.moduleRef = moduleRef;
   }
-  get(typeOrToken, options = { strict: true }) {
+  get(typeOrToken, options = {
+    strict: true
+  }) {
     const token = typeOrToken;
     let wrapper = this.moduleRef.getProvider(token);
     if (!wrapper && !options.strict) ;
     if (!wrapper) {
       throw new Error(`ModuleRef cannot find provider for ${token.toString()}`);
     }
-    if (wrapper.scope !== 0 /* DEFAULT */) {
+    if (wrapper.scope !== Scope.DEFAULT) {
       throw new Error(`Cannot use get() for scoped provider ${token.toString()}. Use resolve() instead.`);
     }
     return wrapper.instance;
   }
-  async resolve(typeOrToken, contextId, options = { strict: true }) {
+  async resolve(typeOrToken, contextId, options = {
+    strict: true
+  }) {
     const token = typeOrToken;
     const wrapper = this.moduleRef.getProvider(token);
     if (!wrapper) {
@@ -137,17 +160,24 @@ var ModuleRefImpl = class extends ModuleRef {
 
 // src/injector/injector.ts
 var Injector = class {
+  static {
+    __name(this, "Injector");
+  }
+  container;
   constructor(container) {
     this.container = container;
   }
   async resolveConstructorParams(wrapper, module, inject, callback, contextId = new ContextId(), inquire = [], parentInquire = []) {
-    if (inquire.some((item) => item === wrapper) && wrapper.scope === 0 /* DEFAULT */) {
+    if (inquire.some((item) => item === wrapper) && wrapper.scope === Scope.DEFAULT) {
       throw new Error(`Circular dependency detected: ${wrapper.name}`);
     }
     const args = [];
     for (const [index, token] of inject.entries()) {
       const isOptional = wrapper.isOptional ? wrapper.isOptional[index] : false;
-      const paramWrapper = await this.resolveSingleParam(token, module, contextId, [...inquire, wrapper], isOptional);
+      const paramWrapper = await this.resolveSingleParam(token, module, contextId, [
+        ...inquire,
+        wrapper
+      ], isOptional);
       args.push(paramWrapper);
     }
     return args;
@@ -170,11 +200,11 @@ var Injector = class {
     }
     if (isForwardRef) {
       return new Proxy({}, {
-        get: (target, prop) => {
+        get: /* @__PURE__ */ __name((target, prop) => {
           if (prop === "then") return void 0;
           if (!wrapper.instance) ;
           return wrapper.instance?.[prop];
-        }
+        }, "get")
       });
     }
     return this.loadInstance(wrapper, contextId, inquire);
@@ -207,17 +237,17 @@ var Injector = class {
     return void 0;
   }
   async loadInstance(wrapper, contextId, inquire = []) {
-    if (wrapper.isResolved && wrapper.scope === 0 /* DEFAULT */) {
+    if (wrapper.isResolved && wrapper.scope === Scope.DEFAULT) {
       return wrapper.instance;
     }
-    if (wrapper.scope === 2 /* REQUEST */) {
+    if (wrapper.scope === Scope.REQUEST) {
       const existing = wrapper.getInstanceByContextId(contextId);
       if (existing) return existing;
     }
     if (wrapper.isAlias) {
       const targetToken = wrapper.useExisting;
       const instance2 = await this.resolveSingleParam(targetToken, wrapper.host, contextId, inquire);
-      if (wrapper.scope === 0 /* DEFAULT */) {
+      if (wrapper.scope === Scope.DEFAULT) {
         wrapper.instance = instance2;
         wrapper.isResolved = true;
       } else {
@@ -232,17 +262,10 @@ var Injector = class {
     }
     if (wrapper.useFactory) {
       const dependencies2 = wrapper.inject || [];
-      const args = await this.resolveConstructorParams(
-        wrapper,
-        wrapper.host,
-        dependencies2,
-        (args2) => {
-        },
-        contextId,
-        inquire
-      );
+      const args = await this.resolveConstructorParams(wrapper, wrapper.host, dependencies2, (args2) => {
+      }, contextId, inquire);
       const instance2 = await wrapper.useFactory(...args);
-      if (wrapper.scope === 0 /* DEFAULT */) {
+      if (wrapper.scope === Scope.DEFAULT) {
         wrapper.instance = instance2;
         wrapper.isResolved = true;
       } else {
@@ -255,31 +278,18 @@ var Injector = class {
       throw new Error("Invalid metatype");
     }
     let dependencies = wrapper.inject || [];
-    const constructorArgs = await this.resolveConstructorParams(
-      wrapper,
-      wrapper.host,
-      dependencies,
-      (args) => {
-      },
-      contextId,
-      inquire
-    );
+    const constructorArgs = await this.resolveConstructorParams(wrapper, wrapper.host, dependencies, (args) => {
+    }, contextId, inquire);
     const instance = new metatype(...constructorArgs);
     if (wrapper.properties) {
       for (const prop of wrapper.properties) {
-        const propInstance = await this.resolveSingleParam(
-          prop.token,
-          wrapper.host,
-          contextId,
-          inquire,
-          prop.isOptional
-        );
+        const propInstance = await this.resolveSingleParam(prop.token, wrapper.host, contextId, inquire, prop.isOptional);
         if (propInstance !== void 0) {
           instance[prop.key] = propInstance;
         }
       }
     }
-    if (wrapper.scope === 0 /* DEFAULT */) {
+    if (wrapper.scope === Scope.DEFAULT) {
       wrapper.instance = instance;
       wrapper.isResolved = true;
     } else {
@@ -291,22 +301,22 @@ var Injector = class {
 
 // src/injector/instance-wrapper.ts
 var InstanceWrapper = class {
+  static {
+    __name(this, "InstanceWrapper");
+  }
   id;
   token;
   name;
   metatype;
-  scope = 0 /* DEFAULT */;
+  scope = Scope.DEFAULT;
   host;
-  // Generic logic
   inject;
   isOptional;
   properties;
   instance;
-  // Singleton instance
   instancesPerContext = /* @__PURE__ */ new Map();
   isResolved = false;
   isPending = false;
-  // For circular dependency detection
   isAlias = false;
   useFactory;
   useValue;
@@ -315,7 +325,7 @@ var InstanceWrapper = class {
     this.token = metadata.token;
     this.name = metadata.name;
     this.metatype = metadata.metatype;
-    this.scope = metadata.scope ?? 0 /* DEFAULT */;
+    this.scope = metadata.scope ?? Scope.DEFAULT;
     this.host = metadata.host;
     this.instance = metadata.instance;
     this.inject = metadata.inject;
@@ -327,18 +337,18 @@ var InstanceWrapper = class {
     this.id = Math.random().toString(36).substring(7);
   }
   getInstanceByContextId(contextId) {
-    if (this.scope === 1 /* TRANSIENT */) {
+    if (this.scope === Scope.TRANSIENT) {
       return void 0;
     }
-    if (this.scope === 0 /* DEFAULT */) {
+    if (this.scope === Scope.DEFAULT) {
       return this.instance;
     }
     return this.instancesPerContext.get(contextId);
   }
   setInstanceByContextId(contextId, instance) {
-    if (this.scope === 0 /* DEFAULT */) {
+    if (this.scope === Scope.DEFAULT) {
       this.instance = instance;
-    } else if (this.scope === 2 /* REQUEST */) {
+    } else if (this.scope === Scope.REQUEST) {
       this.instancesPerContext.set(contextId, instance);
     }
   }
@@ -379,6 +389,9 @@ var METADATA_KEYS = {
 
 // src/services/logger.service.ts
 var Logger = class _Logger {
+  static {
+    __name(this, "Logger");
+  }
   static lastTimestamp;
   static instance;
   context;
@@ -433,10 +446,8 @@ var Logger = class _Logger {
       red: "\x1B[31m",
       green: "\x1B[32m",
       yellow: "\x1B[33m"};
-    process.stdout.write(
-      `${C.green}[Hono] ${pid}${C.reset} - ${timestamp}${color}${level.toUpperCase().padStart(7)}${C.reset} ${C.yellow}${contextMessage}${C.reset}${C.green}${output}${C.reset} ${C.yellow}${timeDiff}${C.reset}
-`
-    );
+    process.stdout.write(`${C.green}[Hono] ${pid}${C.reset} - ${timestamp}${color}${level.toUpperCase().padStart(7)}${C.reset} ${C.yellow}${contextMessage}${C.reset}${C.green}${output}${C.reset} ${C.yellow}${timeDiff}${C.reset}
+`);
     if (trace) {
       process.stdout.write(`${C.red}${trace}${C.reset}
 `);
@@ -475,6 +486,10 @@ var Logger = class _Logger {
 
 // src/scanner.ts
 var HonoDiScanner = class {
+  static {
+    __name(this, "HonoDiScanner");
+  }
+  container;
   constructor(container) {
     this.container = container;
   }
@@ -501,7 +516,7 @@ var HonoDiScanner = class {
       name: moduleClass.name,
       metatype: moduleClass,
       host: moduleRef,
-      scope: 0 /* DEFAULT */
+      scope: Scope.DEFAULT
     });
     this.scanDependencies(moduleWrapper);
     moduleRef.addProvider(moduleWrapper);
@@ -513,10 +528,22 @@ var HonoDiScanner = class {
     const options = {
       ...decoratorOptions,
       ...dynamicMetadata,
-      imports: [...decoratorOptions.imports || [], ...dynamicMetadata.imports || []],
-      providers: [...decoratorOptions.providers || [], ...dynamicMetadata.providers || []],
-      exports: [...decoratorOptions.exports || [], ...dynamicMetadata.exports || []],
-      controllers: [...decoratorOptions.controllers || [], ...dynamicMetadata.controllers || []]
+      imports: [
+        ...decoratorOptions.imports || [],
+        ...dynamicMetadata.imports || []
+      ],
+      providers: [
+        ...decoratorOptions.providers || [],
+        ...dynamicMetadata.providers || []
+      ],
+      exports: [
+        ...decoratorOptions.exports || [],
+        ...dynamicMetadata.exports || []
+      ],
+      controllers: [
+        ...decoratorOptions.controllers || [],
+        ...dynamicMetadata.controllers || []
+      ]
     };
     if (options.imports) {
       for (const importedModule of options.imports) {
@@ -524,7 +551,10 @@ var HonoDiScanner = class {
         if (importedModule && typeof importedModule.forwardRef === "function") {
           actualImport = importedModule.forwardRef();
         }
-        const importedRef = await this.scanModule(actualImport, [...scope, moduleClass]);
+        const importedRef = await this.scanModule(actualImport, [
+          ...scope,
+          moduleClass
+        ]);
         if (importedRef) {
           moduleRef.addImport(importedRef);
         }
@@ -557,7 +587,7 @@ var HonoDiScanner = class {
         name: token2.name,
         metatype: provider,
         host: moduleRef,
-        scope: 0 /* DEFAULT */
+        scope: Scope.DEFAULT
       });
       this.scanDependencies(wrapper2);
       moduleRef.addProvider(wrapper2);
@@ -568,7 +598,7 @@ var HonoDiScanner = class {
       token,
       name: token && token.name ? token.name : typeof token === "string" ? token : "CustomProvider",
       host: moduleRef,
-      scope: provider.scope || 0 /* DEFAULT */
+      scope: provider.scope || Scope.DEFAULT
     });
     if (provider.useValue !== void 0) {
       wrapper.useValue = provider.useValue;
@@ -591,7 +621,7 @@ var HonoDiScanner = class {
       name: token.name,
       metatype: controller,
       host: moduleRef,
-      scope: 0 /* DEFAULT */
+      scope: Scope.DEFAULT
     });
     this.scanDependencies(wrapper);
     moduleRef.addController(wrapper);
@@ -622,6 +652,9 @@ var HonoDiScanner = class {
 
 // src/execution-context-host.ts
 var ExecutionContextHost = class {
+  static {
+    __name(this, "ExecutionContextHost");
+  }
   args;
   constructorRef;
   handler;
@@ -648,31 +681,100 @@ var ExecutionContextHost = class {
   }
   switchToHttp() {
     return {
-      getRequest: () => this.context.req,
-      getResponse: () => this.context,
-      getNext: () => this.next ?? (() => Promise.resolve()),
-      getContext: () => this.context
+      getRequest: /* @__PURE__ */ __name(() => this.context.req, "getRequest"),
+      getResponse: /* @__PURE__ */ __name(() => this.context, "getResponse"),
+      getNext: /* @__PURE__ */ __name(() => this.next ?? (() => Promise.resolve()), "getNext"),
+      getContext: /* @__PURE__ */ __name(() => this.context, "getContext")
     };
   }
 };
 function Injectable(options) {
   return (target) => {
-    Reflect.defineMetadata(METADATA_KEYS.SCOPE, 0 /* DEFAULT */, target);
+    Reflect.defineMetadata(METADATA_KEYS.SCOPE, options?.scope ?? Scope.DEFAULT, target);
+  };
+}
+__name(Injectable, "Injectable");
+function createRouteDecorator(method) {
+  return (path = "/") => {
+    return (target, propertyKey, descriptor) => {
+      if (!Reflect.hasMetadata(METADATA_KEYS.ROUTES, target.constructor)) {
+        Reflect.defineMetadata(METADATA_KEYS.ROUTES, [], target.constructor);
+      }
+      const routes = Reflect.getMetadata(METADATA_KEYS.ROUTES, target.constructor);
+      routes.push({
+        requestMethod: method,
+        path,
+        methodName: propertyKey
+      });
+      Reflect.defineMetadata(METADATA_KEYS.ROUTES, routes, target.constructor);
+    };
   };
 }
+__name(createRouteDecorator, "createRouteDecorator");
+createRouteDecorator(RequestMethod.GET);
+createRouteDecorator(RequestMethod.POST);
+createRouteDecorator(RequestMethod.PUT);
+createRouteDecorator(RequestMethod.DELETE);
+createRouteDecorator(RequestMethod.PATCH);
+createRouteDecorator(RequestMethod.OPTIONS);
+createRouteDecorator(RequestMethod.HEAD);
+createRouteDecorator(RequestMethod.ALL);
 function Catch(...exceptions) {
   return (target) => {
     Reflect.defineMetadata(METADATA_KEYS.FILTER_CATCH, exceptions, target);
-    Reflect.defineMetadata(METADATA_KEYS.SCOPE, 0 /* DEFAULT */, target);
+    Reflect.defineMetadata(METADATA_KEYS.SCOPE, Scope.DEFAULT, target);
+  };
+}
+__name(Catch, "Catch");
+var RouteParamtypes = /* @__PURE__ */ (function(RouteParamtypes2) {
+  RouteParamtypes2[RouteParamtypes2["REQUEST"] = 0] = "REQUEST";
+  RouteParamtypes2[RouteParamtypes2["RESPONSE"] = 1] = "RESPONSE";
+  RouteParamtypes2[RouteParamtypes2["NEXT"] = 2] = "NEXT";
+  RouteParamtypes2[RouteParamtypes2["BODY"] = 3] = "BODY";
+  RouteParamtypes2[RouteParamtypes2["QUERY"] = 4] = "QUERY";
+  RouteParamtypes2[RouteParamtypes2["PARAM"] = 5] = "PARAM";
+  RouteParamtypes2[RouteParamtypes2["HEADERS"] = 6] = "HEADERS";
+  RouteParamtypes2[RouteParamtypes2["SESSION"] = 7] = "SESSION";
+  RouteParamtypes2[RouteParamtypes2["FILE"] = 8] = "FILE";
+  RouteParamtypes2[RouteParamtypes2["FILES"] = 9] = "FILES";
+  RouteParamtypes2[RouteParamtypes2["HOST"] = 10] = "HOST";
+  RouteParamtypes2[RouteParamtypes2["IP"] = 11] = "IP";
+  RouteParamtypes2[RouteParamtypes2["CONTEXT"] = 12] = "CONTEXT";
+  RouteParamtypes2[RouteParamtypes2["CUSTOM"] = 13] = "CUSTOM";
+  return RouteParamtypes2;
+})({});
+function assignMetadata(args, paramtype, index, data, ...pipes) {
+  return {
+    ...args,
+    [`${paramtype}:${index}`]: {
+      index,
+      data,
+      pipes,
+      paramtype
+    }
+  };
+}
+__name(assignMetadata, "assignMetadata");
+function createRouteParamDecorator(paramtype) {
+  return (data) => {
+    return (target, key, index) => {
+      const args = Reflect.getMetadata(METADATA_KEYS.ROUTE_ARGS_METADATA, target.constructor, key) || {};
+      Reflect.defineMetadata(METADATA_KEYS.ROUTE_ARGS_METADATA, assignMetadata(args, paramtype, index, data), target.constructor, key);
+    };
   };
 }
+__name(createRouteParamDecorator, "createRouteParamDecorator");
 
 // src/middleware/builder.ts
 var MiddlewareBuilder = class {
+  static {
+    __name(this, "MiddlewareBuilder");
+  }
+  module;
+  configs = [];
   constructor(module) {
     this.module = module;
   }
-  configs = [];
   apply(...middleware) {
     return new MiddlewareConfigProxyImpl(this, middleware);
   }
@@ -688,12 +790,17 @@ var MiddlewareBuilder = class {
     return this.configs;
   }
 };
-var MiddlewareConfigProxyImpl = class {
+var MiddlewareConfigProxyImpl = class MiddlewareConfigProxyImpl2 {
+  static {
+    __name(this, "MiddlewareConfigProxyImpl");
+  }
+  builder;
+  middleware;
+  excludes = [];
   constructor(builder, middleware) {
     this.builder = builder;
     this.middleware = middleware;
   }
-  excludes = [];
   exclude(...routes) {
     this.excludes = routes;
     return this;
@@ -706,10 +813,13 @@ var MiddlewareConfigProxyImpl = class {
 
 // src/common/exceptions/http.exception.ts
 var HttpException = class extends Error {
+  static {
+    __name(this, "HttpException");
+  }
+  response;
+  status;
   constructor(response, status) {
-    super();
-    this.response = response;
-    this.status = status;
+    super(), this.response = response, this.status = status;
     this.message = typeof response === "string" ? response : JSON.stringify(response);
   }
   getResponse() {
@@ -720,89 +830,144 @@ var HttpException = class extends Error {
   }
   static createBody(message, error, statusCode) {
     if (!message) {
-      return { statusCode, error };
+      return {
+        statusCode,
+        error
+      };
     }
-    return typeof message === "object" && !Array.isArray(message) ? message : { statusCode, error, message };
+    return typeof message === "object" && !Array.isArray(message) ? message : {
+      statusCode,
+      error,
+      message
+    };
   }
 };
 
 // src/common/exceptions/index.ts
 var BadRequestException = class extends HttpException {
+  static {
+    __name(this, "BadRequestException");
+  }
   constructor(message, error = "Bad Request") {
     super(HttpException.createBody(message, error, 400), 400);
   }
 };
 var UnauthorizedException = class extends HttpException {
+  static {
+    __name(this, "UnauthorizedException");
+  }
   constructor(message, error = "Unauthorized") {
     super(HttpException.createBody(message, error, 401), 401);
   }
 };
 var NotFoundException = class extends HttpException {
+  static {
+    __name(this, "NotFoundException");
+  }
   constructor(message, error = "Not Found") {
     super(HttpException.createBody(message, error, 404), 404);
   }
 };
 var ForbiddenException = class extends HttpException {
+  static {
+    __name(this, "ForbiddenException");
+  }
   constructor(message, error = "Forbidden") {
     super(HttpException.createBody(message, error, 403), 403);
   }
 };
 var NotAcceptableException = class extends HttpException {
+  static {
+    __name(this, "NotAcceptableException");
+  }
   constructor(message, error = "Not Acceptable") {
     super(HttpException.createBody(message, error, 406), 406);
   }
 };
 var RequestTimeoutException = class extends HttpException {
+  static {
+    __name(this, "RequestTimeoutException");
+  }
   constructor(message, error = "Request Timeout") {
     super(HttpException.createBody(message, error, 408), 408);
   }
 };
 var ConflictException = class extends HttpException {
+  static {
+    __name(this, "ConflictException");
+  }
   constructor(message, error = "Conflict") {
     super(HttpException.createBody(message, error, 409), 409);
   }
 };
 var GoneException = class extends HttpException {
+  static {
+    __name(this, "GoneException");
+  }
   constructor(message, error = "Gone") {
     super(HttpException.createBody(message, error, 410), 410);
   }
 };
 var PayloadTooLargeException = class extends HttpException {
+  static {
+    __name(this, "PayloadTooLargeException");
+  }
   constructor(message, error = "Payload Too Large") {
     super(HttpException.createBody(message, error, 413), 413);
   }
 };
 var UnsupportedMediaTypeException = class extends HttpException {
+  static {
+    __name(this, "UnsupportedMediaTypeException");
+  }
   constructor(message, error = "Unsupported Media Type") {
     super(HttpException.createBody(message, error, 415), 415);
   }
 };
 var UnprocessableEntityException = class extends HttpException {
+  static {
+    __name(this, "UnprocessableEntityException");
+  }
   constructor(message, error = "Unprocessable Entity") {
     super(HttpException.createBody(message, error, 422), 422);
   }
 };
 var InternalServerErrorException = class extends HttpException {
+  static {
+    __name(this, "InternalServerErrorException");
+  }
   constructor(message, error = "Internal Server Error") {
     super(HttpException.createBody(message, error, 500), 500);
   }
 };
 var NotImplementedException = class extends HttpException {
+  static {
+    __name(this, "NotImplementedException");
+  }
   constructor(message, error = "Not Implemented") {
     super(HttpException.createBody(message, error, 501), 501);
   }
 };
 var BadGatewayException = class extends HttpException {
+  static {
+    __name(this, "BadGatewayException");
+  }
   constructor(message, error = "Bad Gateway") {
     super(HttpException.createBody(message, error, 502), 502);
   }
 };
 var ServiceUnavailableException = class extends HttpException {
+  static {
+    __name(this, "ServiceUnavailableException");
+  }
   constructor(message, error = "Service Unavailable") {
     super(HttpException.createBody(message, error, 503), 503);
   }
 };
 var GatewayTimeoutException = class extends HttpException {
+  static {
+    __name(this, "GatewayTimeoutException");
+  }
   constructor(message, error = "Gateway Timeout") {
     super(HttpException.createBody(message, error, 504), 504);
   }
@@ -810,15 +975,21 @@ var GatewayTimeoutException = class extends HttpException {
 
 // src/application.ts
 var HonoDiApplication = class {
-  constructor(app, container, injector) {
-    this.app = app;
-    this.container = container;
-    this.injector = injector;
+  static {
+    __name(this, "HonoDiApplication");
   }
+  app;
+  container;
+  injector;
   globalFilters = [];
   globalPipes = [];
   globalGuards = [];
   globalInterceptors = [];
+  constructor(app, container, injector) {
+    this.app = app;
+    this.container = container;
+    this.injector = injector;
+  }
   useGlobalFilters(...filters) {
     this.globalFilters.push(...filters);
     return this;
@@ -903,7 +1074,9 @@ var HonoDiApplication = class {
       const fullPath = this.combinePaths(globalPrefix, this.combinePaths(prefix, route.path));
       app[route.requestMethod](fullPath, async (c) => {
         const contextId = new ContextId();
-        const executionContext = new ExecutionContextHost([c], controllerClass, controllerClass.prototype[route.methodName]);
+        const executionContext = new ExecutionContextHost([
+          c
+        ], controllerClass, controllerClass.prototype[route.methodName]);
         try {
           const wrapper = moduleRef.getProvider(controllerClass) || moduleRef.controllers.get(controllerClass);
           if (!wrapper) {
@@ -911,49 +1084,33 @@ var HonoDiApplication = class {
           }
           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 guards = await this.resolveContextItems([
+            ...this.globalGuards,
+            ...Reflect.getMetadata(METADATA_KEYS.USE_GUARDS, controllerClass) || [],
+            ...Reflect.getMetadata(METADATA_KEYS.USE_GUARDS, controllerInstance[route.methodName]) || []
+          ], moduleRef, contextId);
           if (!await this.runGuards(guards, executionContext)) {
             c.status(403);
-            return c.json({ statusCode: 403, message: "Forbidden resource" });
+            return c.json({
+              statusCode: 403,
+              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
-          );
+          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 interceptorChain = async (index) => {
+          const interceptorChain = /* @__PURE__ */ __name(async (index) => {
             if (index >= interceptors.length) {
               return new Observable((subscriber) => {
                 try {
@@ -973,9 +1130,9 @@ var HonoDiApplication = class {
               });
             }
             return interceptors[index].intercept(executionContext, {
-              handle: () => from(interceptorChain(index + 1)).pipe(mergeMap((obs2) => obs2))
+              handle: /* @__PURE__ */ __name(() => from(interceptorChain(index + 1)).pipe(mergeMap((obs2) => obs2)), "handle")
             });
-          };
+          }, "interceptorChain");
           const obs = await interceptorChain(0);
           const result = await lastValueFrom(obs);
           const httpCode = Reflect.getMetadata(METADATA_KEYS.HTTP_CODE, controllerInstance[route.methodName]);
@@ -1008,19 +1165,17 @@ var HonoDiApplication = class {
     });
   }
   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
-    );
+    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]);
+        const host = new ExecutionContextHost([
+          c
+        ], controllerClass, moduleRef.controllers.get(controllerClass)?.instance?.[methodName]);
         return await filter.catch(exception, host);
       }
     }
@@ -1052,7 +1207,7 @@ var HonoDiApplication = class {
             name: item.name,
             metatype: item,
             host: moduleRef,
-            scope: 1 /* TRANSIENT */
+            scope: Scope.TRANSIENT
           });
           scanner.scanDependencies(wrapper);
         }
@@ -1073,19 +1228,19 @@ var HonoDiApplication = class {
       let value;
       const { index, data, pipes, paramtype } = arg;
       switch (paramtype) {
-        case 0 /* REQUEST */:
+        case RouteParamtypes.REQUEST:
           value = c.req;
           break;
-        case 1 /* RESPONSE */:
+        case RouteParamtypes.RESPONSE:
           value = c;
           break;
-        case 2 /* NEXT */:
+        case RouteParamtypes.NEXT:
           value = context.getArgs()[1];
           break;
-        case 12 /* CONTEXT */:
+        case RouteParamtypes.CONTEXT:
           value = c;
           break;
-        case 3 /* BODY */:
+        case RouteParamtypes.BODY:
           if (data && c.req.parseBody) {
             const body = await c.req.parseBody();
             value = body[data];
@@ -1098,19 +1253,19 @@ var HonoDiApplication = class {
             }
           }
           break;
-        case 4 /* QUERY */:
+        case RouteParamtypes.QUERY:
           value = data ? c.req.query(data) : c.req.query();
           break;
-        case 5 /* PARAM */:
+        case RouteParamtypes.PARAM:
           value = data ? c.req.param(data) : c.req.param();
           break;
-        case 6 /* HEADERS */:
+        case RouteParamtypes.HEADERS:
           value = data ? c.req.header(data) : c.req.header();
           break;
-        case 11 /* IP */:
+        case RouteParamtypes.IP:
           value = c.req.header("x-forwarded-for") || "127.0.0.1";
           break;
-        case 13 /* CUSTOM */:
+        case RouteParamtypes.CUSTOM:
           const factory = arg.pipes[0];
           if (typeof factory === "function") {
             value = factory(data, context);
@@ -1120,9 +1275,16 @@ var HonoDiApplication = class {
           value = null;
       }
       const paramPipeInstances = await this.resolveContextItems(pipes || [], moduleRef, contextId);
-      const allPipes = [...methodPipes, ...paramPipeInstances];
+      const allPipes = [
+        ...methodPipes,
+        ...paramPipeInstances
+      ];
       for (const pipe of allPipes) {
-        value = await pipe.transform(value, { type: "custom", metatype: null, data });
+        value = await pipe.transform(value, {
+          type: "custom",
+          metatype: null,
+          data
+        });
       }
       args[index] = value;
     }
@@ -1160,7 +1322,7 @@ var HonoDiApplication = class {
             token: m,
             name: m.name,
             metatype: m,
-            scope: 1 /* TRANSIENT */
+            scope: Scope.TRANSIENT
           });
           const scanner = new HonoDiScanner(this.container);
           scanner.scanDependencies(wrapper);
@@ -1170,7 +1332,10 @@ var HonoDiApplication = class {
           instances.push(instance);
         }
       }
-      resolvedConfigs.push({ ...config, instances });
+      resolvedConfigs.push({
+        ...config,
+        instances
+      });
     }
     this.app.use("*", async (c, next) => {
       const path = c.req.path;
@@ -1185,14 +1350,14 @@ var HonoDiApplication = class {
       if (matchingMiddleware.length === 0) {
         return await next();
       }
-      const executeChain = async (index, finalNext) => {
+      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 = async () => {
+          const nextFn = /* @__PURE__ */ __name(async () => {
             nextCalled = true;
             try {
               await executeChain(index + 1, finalNext);
@@ -1200,7 +1365,7 @@ var HonoDiApplication = class {
             } catch (e) {
               reject(e);
             }
-          };
+          }, "nextFn");
           try {
             const useFn = middleware.use ? middleware.use.bind(middleware) : middleware;
             const result = useFn(c, nextFn);
@@ -1215,7 +1380,7 @@ var HonoDiApplication = class {
             reject(e);
           }
         });
-      };
+      }, "executeChain");
       await executeChain(0, next);
     });
   }
@@ -1226,7 +1391,7 @@ var HonoDiApplication = class {
         if (normalizedRoute === "*" || path.startsWith(normalizedRoute)) return true;
         if (path === normalizedRoute) return true;
       } else if (typeof route === "object" && route.path && route.method) {
-        if (route.method !== -1 && route.method !== "all" /* ALL */ && route.method !== method.toLowerCase()) {
+        if (route.method !== -1 && route.method !== RequestMethod.ALL && route.method !== method.toLowerCase()) {
           continue;
         }
         if (route.path === "*" || path === route.path) return true;
@@ -1283,6 +1448,9 @@ var HonoDiApplication = class {
 
 // src/factory.ts
 var HonoDiFactory = class {
+  static {
+    __name(this, "HonoDiFactory");
+  }
   static logger = new Logger("HonoDiFactory");
   static async create(rootModule, appOrOptions) {
     let app;
@@ -1317,12 +1485,12 @@ var HonoDiFactory = class {
     const globalContextId = new ContextId();
     for (const module of modules.values()) {
       for (const wrapper of module.providers.values()) {
-        if (wrapper.scope === 0 /* DEFAULT */) {
+        if (wrapper.scope === Scope.DEFAULT) {
           await injector.loadInstance(wrapper, globalContextId);
         }
       }
       for (const wrapper of module.controllers.values()) {
-        if (wrapper.scope === 0 /* DEFAULT */) {
+        if (wrapper.scope === Scope.DEFAULT) {
           await injector.loadInstance(wrapper, globalContextId);
         }
       }
@@ -1347,11 +1515,24 @@ var HonoDiFactory = class {
 
 // src/utils.ts
 function forwardRef(fn) {
-  return { forwardRef: fn };
+  return {
+    forwardRef: fn
+  };
 }
+__name(forwardRef, "forwardRef");
 
 // src/services/reflector.service.ts
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
 var Reflector = class {
+  static {
+    __name(this, "Reflector");
+  }
   get(metadataKey, target) {
     return Reflect.getMetadata(metadataKey, target);
   }
@@ -1379,12 +1560,22 @@ var Reflector = class {
     return result;
   }
 };
-Reflector = __decorateClass([
+Reflector = _ts_decorate([
   Injectable()
 ], Reflector);
 
 // src/common/pipes/index.ts
+function _ts_decorate2(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate2, "_ts_decorate");
 var ParseIntPipe = class {
+  static {
+    __name(this, "ParseIntPipe");
+  }
   transform(value, metadata) {
     const isNumeric = !isNaN(parseFloat(value)) && isFinite(value);
     if (!isNumeric) {
@@ -1393,10 +1584,13 @@ var ParseIntPipe = class {
     return parseInt(value, 10);
   }
 };
-ParseIntPipe = __decorateClass([
+ParseIntPipe = _ts_decorate2([
   Injectable()
 ], ParseIntPipe);
 var ParseFloatPipe = class {
+  static {
+    __name(this, "ParseFloatPipe");
+  }
   transform(value, metadata) {
     const isNumeric = !isNaN(parseFloat(value)) && isFinite(value);
     if (!isNumeric) {
@@ -1405,10 +1599,13 @@ var ParseFloatPipe = class {
     return parseFloat(value);
   }
 };
-ParseFloatPipe = __decorateClass([
+ParseFloatPipe = _ts_decorate2([
   Injectable()
 ], ParseFloatPipe);
 var ParseBoolPipe = class {
+  static {
+    __name(this, "ParseBoolPipe");
+  }
   transform(value, metadata) {
     if (value === true || value === "true") {
       return true;
@@ -1419,50 +1616,71 @@ var ParseBoolPipe = class {
     throw new BadRequestException("Validation failed (boolean string is expected)");
   }
 };
-ParseBoolPipe = __decorateClass([
+ParseBoolPipe = _ts_decorate2([
   Injectable()
 ], ParseBoolPipe);
 var ValidationPipe = class {
+  static {
+    __name(this, "ValidationPipe");
+  }
   transform(value, metadata) {
     return value;
   }
 };
-ValidationPipe = __decorateClass([
+ValidationPipe = _ts_decorate2([
   Injectable()
 ], ValidationPipe);
 
 // src/common/errors/AppError.ts
 var AppError = class _AppError extends Error {
+  static {
+    __name(this, "AppError");
+  }
+  statusCode;
+  message;
+  isOperational;
   constructor(statusCode, message, isOperational = true) {
-    super(message);
-    this.statusCode = statusCode;
-    this.message = message;
-    this.isOperational = isOperational;
+    super(message), this.statusCode = statusCode, this.message = message, this.isOperational = isOperational;
     Object.setPrototypeOf(this, _AppError.prototype);
     Error.captureStackTrace(this, this.constructor);
   }
 };
 var NotFoundError = class extends AppError {
+  static {
+    __name(this, "NotFoundError");
+  }
   constructor(message = "Resource not found") {
     super(404, message);
   }
 };
 var BadRequestError = class extends AppError {
+  static {
+    __name(this, "BadRequestError");
+  }
   constructor(message = "Bad request") {
     super(400, message);
   }
 };
 var UnauthorizedError = class extends AppError {
+  static {
+    __name(this, "UnauthorizedError");
+  }
   constructor(message = "Unauthorized") {
     super(401, message);
   }
 };
 var ForbiddenError = class extends AppError {
+  static {
+    __name(this, "ForbiddenError");
+  }
   constructor(message = "Forbidden") {
     super(403, message);
   }
 };
 var ConflictError = class extends AppError {
+  static {
+    __name(this, "ConflictError");
+  }
   constructor(message = "Resource already exists") {
     super(409, message);
   }
@@ -1470,10 +1688,13 @@ var ConflictError = class extends AppError {
 
 // src/common/exceptions/HttpException.ts
 var HttpException2 = class extends Error {
+  static {
+    __name(this, "HttpException");
+  }
+  response;
+  status;
   constructor(response, status) {
-    super();
-    this.response = response;
-    this.status = status;
+    super(), this.response = response, this.status = status;
     this.message = typeof response === "string" ? response : JSON.stringify(response);
   }
   getResponse() {
@@ -1484,14 +1705,31 @@ var HttpException2 = class extends Error {
   }
   static createBody(message, error, statusCode) {
     if (!message) {
-      return { statusCode, error };
+      return {
+        statusCode,
+        error
+      };
     }
-    return typeof message === "object" && !Array.isArray(message) ? message : { statusCode, error, message };
+    return typeof message === "object" && !Array.isArray(message) ? message : {
+      statusCode,
+      error,
+      message
+    };
   }
 };
 
 // src/common/filters/BaseExceptionFilter.ts
+function _ts_decorate3(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate3, "_ts_decorate");
 var BaseExceptionFilter = class {
+  static {
+    __name(this, "BaseExceptionFilter");
+  }
   catch(exception, host) {
     const ctx = host.switchToHttp();
     ctx.getResponse();
@@ -1510,7 +1748,7 @@ var BaseExceptionFilter = class {
     });
   }
 };
-BaseExceptionFilter = __decorateClass([
+BaseExceptionFilter = _ts_decorate3([
   Catch()
 ], BaseExceptionFilter);