@hono-di/core 0.0.7 → 0.0.9

package/dist/core.cjs

@@ -5,17 +5,11 @@ var hono = require('hono');
 var rxjs = require('rxjs');
 var operators = require('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";
@@ -25,18 +19,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;
   }
@@ -71,6 +70,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) {
@@ -97,6 +99,9 @@ var Container = class {
 
 // src/injector/context-id.ts
 var ContextId = class _ContextId {
+  static {
+    __name(this, "ContextId");
+  }
   static idCounter = 0;
   id;
   constructor() {
@@ -105,29 +110,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) {
@@ -139,17 +162,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;
@@ -172,11 +202,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);
@@ -209,17 +239,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 {
@@ -234,17 +264,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 {
@@ -257,31 +280,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 {
@@ -293,22 +303,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;
@@ -317,7 +327,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;
@@ -329,18 +339,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);
     }
   }
@@ -381,6 +391,9 @@ var METADATA_KEYS = {
 
 // src/services/logger.service.ts
 var Logger = class _Logger {
+  static {
+    __name(this, "Logger");
+  }
   static lastTimestamp;
   static instance;
   context;
@@ -435,10 +448,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}
 `);
@@ -477,6 +488,10 @@ var Logger = class _Logger {
 
 // src/scanner.ts
 var HonoDiScanner = class {
+  static {
+    __name(this, "HonoDiScanner");
+  }
+  container;
   constructor(container) {
     this.container = container;
   }
@@ -503,7 +518,7 @@ var HonoDiScanner = class {
       name: moduleClass.name,
       metatype: moduleClass,
       host: moduleRef,
-      scope: 0 /* DEFAULT */
+      scope: Scope.DEFAULT
     });
     this.scanDependencies(moduleWrapper);
     moduleRef.addProvider(moduleWrapper);
@@ -515,10 +530,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) {
@@ -526,7 +553,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);
         }
@@ -559,7 +589,7 @@ var HonoDiScanner = class {
         name: token2.name,
         metatype: provider,
         host: moduleRef,
-        scope: 0 /* DEFAULT */
+        scope: Scope.DEFAULT
       });
       this.scanDependencies(wrapper2);
       moduleRef.addProvider(wrapper2);
@@ -570,7 +600,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;
@@ -593,7 +623,7 @@ var HonoDiScanner = class {
       name: token.name,
       metatype: controller,
       host: moduleRef,
-      scope: 0 /* DEFAULT */
+      scope: Scope.DEFAULT
     });
     this.scanDependencies(wrapper);
     moduleRef.addController(wrapper);
@@ -624,6 +654,9 @@ var HonoDiScanner = class {
 
 // src/execution-context-host.ts
 var ExecutionContextHost = class {
+  static {
+    __name(this, "ExecutionContextHost");
+  }
   args;
   constructorRef;
   handler;
@@ -650,31 +683,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);
   }
@@ -690,12 +792,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;
@@ -708,10 +815,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() {
@@ -722,89 +832,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);
   }
@@ -812,15 +977,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;
@@ -905,7 +1076,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) {
@@ -913,49 +1086,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 rxjs.Observable((subscriber) => {
                 try {
@@ -975,9 +1132,9 @@ var HonoDiApplication = class {
               });
             }
             return interceptors[index].intercept(executionContext, {
-              handle: () => rxjs.from(interceptorChain(index + 1)).pipe(operators.mergeMap((obs2) => obs2))
+              handle: /* @__PURE__ */ __name(() => rxjs.from(interceptorChain(index + 1)).pipe(operators.mergeMap((obs2) => obs2)), "handle")
             });
-          };
+          }, "interceptorChain");
           const obs = await interceptorChain(0);
           const result = await rxjs.lastValueFrom(obs);
           const httpCode = Reflect.getMetadata(METADATA_KEYS.HTTP_CODE, controllerInstance[route.methodName]);
@@ -1010,19 +1167,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);
       }
     }
@@ -1054,7 +1209,7 @@ var HonoDiApplication = class {
             name: item.name,
             metatype: item,
             host: moduleRef,
-            scope: 1 /* TRANSIENT */
+            scope: Scope.TRANSIENT
           });
           scanner.scanDependencies(wrapper);
         }
@@ -1075,19 +1230,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];
@@ -1100,19 +1255,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);
@@ -1122,9 +1277,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;
     }
@@ -1162,7 +1324,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);
@@ -1172,7 +1334,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;
@@ -1187,14 +1352,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);
@@ -1202,7 +1367,7 @@ var HonoDiApplication = class {
             } catch (e) {
               reject(e);
             }
-          };
+          }, "nextFn");
           try {
             const useFn = middleware.use ? middleware.use.bind(middleware) : middleware;
             const result = useFn(c, nextFn);
@@ -1217,7 +1382,7 @@ var HonoDiApplication = class {
             reject(e);
           }
         });
-      };
+      }, "executeChain");
       await executeChain(0, next);
     });
   }
@@ -1228,7 +1393,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;
@@ -1285,6 +1450,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;
@@ -1319,12 +1487,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);
         }
       }
@@ -1349,11 +1517,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");
 exports.Reflector = class Reflector {
+  static {
+    __name(this, "Reflector");
+  }
   get(metadataKey, target) {
     return Reflect.getMetadata(metadataKey, target);
   }
@@ -1381,12 +1562,22 @@ exports.Reflector = class Reflector {
     return result;
   }
 };
-exports.Reflector = __decorateClass([
+exports.Reflector = _ts_decorate([
   Injectable()
 ], exports.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");
 exports.ParseIntPipe = class ParseIntPipe {
+  static {
+    __name(this, "ParseIntPipe");
+  }
   transform(value, metadata) {
     const isNumeric = !isNaN(parseFloat(value)) && isFinite(value);
     if (!isNumeric) {
@@ -1395,10 +1586,13 @@ exports.ParseIntPipe = class ParseIntPipe {
     return parseInt(value, 10);
   }
 };
-exports.ParseIntPipe = __decorateClass([
+exports.ParseIntPipe = _ts_decorate2([
   Injectable()
 ], exports.ParseIntPipe);
 exports.ParseFloatPipe = class ParseFloatPipe {
+  static {
+    __name(this, "ParseFloatPipe");
+  }
   transform(value, metadata) {
     const isNumeric = !isNaN(parseFloat(value)) && isFinite(value);
     if (!isNumeric) {
@@ -1407,10 +1601,13 @@ exports.ParseFloatPipe = class ParseFloatPipe {
     return parseFloat(value);
   }
 };
-exports.ParseFloatPipe = __decorateClass([
+exports.ParseFloatPipe = _ts_decorate2([
   Injectable()
 ], exports.ParseFloatPipe);
 exports.ParseBoolPipe = class ParseBoolPipe {
+  static {
+    __name(this, "ParseBoolPipe");
+  }
   transform(value, metadata) {
     if (value === true || value === "true") {
       return true;
@@ -1421,50 +1618,71 @@ exports.ParseBoolPipe = class ParseBoolPipe {
     throw new BadRequestException("Validation failed (boolean string is expected)");
   }
 };
-exports.ParseBoolPipe = __decorateClass([
+exports.ParseBoolPipe = _ts_decorate2([
   Injectable()
 ], exports.ParseBoolPipe);
 exports.ValidationPipe = class ValidationPipe {
+  static {
+    __name(this, "ValidationPipe");
+  }
   transform(value, metadata) {
     return value;
   }
 };
-exports.ValidationPipe = __decorateClass([
+exports.ValidationPipe = _ts_decorate2([
   Injectable()
 ], exports.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);
   }
@@ -1472,10 +1690,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() {
@@ -1486,14 +1707,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");
 exports.BaseExceptionFilter = class BaseExceptionFilter {
+  static {
+    __name(this, "BaseExceptionFilter");
+  }
   catch(exception, host) {
     const ctx = host.switchToHttp();
     ctx.getResponse();
@@ -1512,7 +1750,7 @@ exports.BaseExceptionFilter = class BaseExceptionFilter {
     });
   }
 };
-exports.BaseExceptionFilter = __decorateClass([
+exports.BaseExceptionFilter = _ts_decorate3([
   Catch()
 ], exports.BaseExceptionFilter);