@hono-di/core 0.0.6

package/dist/core.cjs

@@ -0,0 +1,1554 @@
+'use strict';
+
+require('reflect-metadata');
+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;
+};
+
+// src/interfaces.ts
+var RequestMethod = /* @__PURE__ */ ((RequestMethod2) => {
+  RequestMethod2["GET"] = "get";
+  RequestMethod2["POST"] = "post";
+  RequestMethod2["PUT"] = "put";
+  RequestMethod2["DELETE"] = "delete";
+  RequestMethod2["PATCH"] = "patch";
+  RequestMethod2["ALL"] = "all";
+  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;
+  }
+  _providers = /* @__PURE__ */ new Map();
+  _imports = /* @__PURE__ */ new Set();
+  _exports = /* @__PURE__ */ new Set();
+  _controllers = /* @__PURE__ */ new Map();
+  get providers() {
+    return this._providers;
+  }
+  get imports() {
+    return this._imports;
+  }
+  get exports() {
+    return this._exports;
+  }
+  get controllers() {
+    return this._controllers;
+  }
+  addProvider(provider) {
+    this._providers.set(provider.token, provider);
+  }
+  addController(controller) {
+    this._controllers.set(controller.token, controller);
+  }
+  addImport(module) {
+    this._imports.add(module);
+  }
+  addExport(token) {
+    this._exports.add(token);
+  }
+  hasProvider(token) {
+    return this._providers.has(token);
+  }
+  getProvider(token) {
+    return this._providers.get(token);
+  }
+};
+
+// src/injector/container.ts
+var Container = class {
+  modules = /* @__PURE__ */ new Map();
+  globalModules = /* @__PURE__ */ new Set();
+  addModule(moduleMeta, token) {
+    if (!this.modules.has(token)) {
+      const module = new Module(moduleMeta, token);
+      this.modules.set(token, module);
+      return module;
+    }
+    return this.modules.get(token);
+  }
+  addGlobalModule(module) {
+    this.globalModules.add(module);
+  }
+  getGlobalModules() {
+    return this.globalModules;
+  }
+  getModuleByToken(token) {
+    return this.modules.get(token);
+  }
+  getModules() {
+    return this.modules;
+  }
+};
+
+// src/injector/context-id.ts
+var ContextId = class _ContextId {
+  static idCounter = 0;
+  id;
+  constructor() {
+    this.id = _ContextId.idCounter++;
+  }
+};
+new ContextId();
+
+// src/injector/module-ref.ts
+var ModuleRef = class {
+};
+var ModuleRefImpl = class extends ModuleRef {
+  constructor(container, injector, moduleRef) {
+    super();
+    this.container = container;
+    this.injector = injector;
+    this.moduleRef = moduleRef;
+  }
+  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 */) {
+      throw new Error(`Cannot use get() for scoped provider ${token.toString()}. Use resolve() instead.`);
+    }
+    return wrapper.instance;
+  }
+  async resolve(typeOrToken, contextId, options = { strict: true }) {
+    const token = typeOrToken;
+    const wrapper = this.moduleRef.getProvider(token);
+    if (!wrapper) {
+      throw new Error(`ModuleRef cannot find provider for ${token.toString()}`);
+    }
+    return this.injector.loadInstance(wrapper, contextId || new ContextId());
+  }
+};
+
+// src/injector/injector.ts
+var Injector = class {
+  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 */) {
+      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);
+      args.push(paramWrapper);
+    }
+    return args;
+  }
+  async resolveSingleParam(token, targetModule, contextId, inquire, isOptional = false) {
+    let isForwardRef = false;
+    if (token && token.forwardRef) {
+      token = token.forwardRef();
+      isForwardRef = true;
+    }
+    if (token === ModuleRef) {
+      return new ModuleRefImpl(this.container, this, targetModule);
+    }
+    const wrapper = this.lookupProvider(token, targetModule);
+    if (!wrapper) {
+      if (isOptional) {
+        return void 0;
+      }
+      throw new Error(`HonoDi can't resolve dependencies of the ${targetModule.metatype.name} (??). Please make sure that the argument "${token.toString()}" at index [?] is available in the ${targetModule.metatype.name} context.`);
+    }
+    if (isForwardRef) {
+      return new Proxy({}, {
+        get: (target, prop) => {
+          if (prop === "then") return void 0;
+          if (!wrapper.instance) ;
+          return wrapper.instance?.[prop];
+        }
+      });
+    }
+    return this.loadInstance(wrapper, contextId, inquire);
+  }
+  lookupProvider(token, module) {
+    if (module.hasProvider(token)) {
+      return module.getProvider(token);
+    }
+    for (const importedModule of module.imports) {
+      if (importedModule.exports.has(token)) {
+        if (importedModule.hasProvider(token)) {
+          return importedModule.getProvider(token);
+        }
+        const nestedWrapper = this.lookupProvider(token, importedModule);
+        if (nestedWrapper) return nestedWrapper;
+      }
+    }
+    if (this.container) {
+      for (const globalModule of this.container.getGlobalModules()) {
+        if (globalModule === module) continue;
+        if (globalModule.exports.has(token)) {
+          if (globalModule.hasProvider(token)) {
+            return globalModule.getProvider(token);
+          }
+          const nestedWrapper = this.lookupProvider(token, globalModule);
+          if (nestedWrapper) return nestedWrapper;
+        }
+      }
+    }
+    return void 0;
+  }
+  async loadInstance(wrapper, contextId, inquire = []) {
+    if (wrapper.isResolved && wrapper.scope === 0 /* DEFAULT */) {
+      return wrapper.instance;
+    }
+    if (wrapper.scope === 2 /* 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 */) {
+        wrapper.instance = instance2;
+        wrapper.isResolved = true;
+      } else {
+        wrapper.setInstanceByContextId(contextId, instance2);
+      }
+      return instance2;
+    }
+    if (wrapper.useValue !== void 0) {
+      wrapper.instance = wrapper.useValue;
+      wrapper.isResolved = true;
+      return wrapper.instance;
+    }
+    if (wrapper.useFactory) {
+      const dependencies2 = wrapper.inject || [];
+      const args = await this.resolveConstructorParams(
+        wrapper,
+        wrapper.host,
+        dependencies2,
+        (args2) => {
+        },
+        contextId,
+        inquire
+      );
+      const instance2 = await wrapper.useFactory(...args);
+      if (wrapper.scope === 0 /* DEFAULT */) {
+        wrapper.instance = instance2;
+        wrapper.isResolved = true;
+      } else {
+        wrapper.setInstanceByContextId(contextId, instance2);
+      }
+      return instance2;
+    }
+    const { metatype } = wrapper;
+    if (!metatype || typeof metatype !== "function") {
+      throw new Error("Invalid metatype");
+    }
+    let dependencies = wrapper.inject || [];
+    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
+        );
+        if (propInstance !== void 0) {
+          instance[prop.key] = propInstance;
+        }
+      }
+    }
+    if (wrapper.scope === 0 /* DEFAULT */) {
+      wrapper.instance = instance;
+      wrapper.isResolved = true;
+    } else {
+      wrapper.setInstanceByContextId(contextId, instance);
+    }
+    return instance;
+  }
+};
+
+// src/injector/instance-wrapper.ts
+var InstanceWrapper = class {
+  id;
+  token;
+  name;
+  metatype;
+  scope = 0 /* 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;
+  useExisting;
+  constructor(metadata) {
+    this.token = metadata.token;
+    this.name = metadata.name;
+    this.metatype = metadata.metatype;
+    this.scope = metadata.scope ?? 0 /* DEFAULT */;
+    this.host = metadata.host;
+    this.instance = metadata.instance;
+    this.inject = metadata.inject;
+    this.useFactory = metadata.useFactory;
+    this.useValue = metadata.useValue;
+    this.useExisting = metadata.useExisting;
+    this.isAlias = !!metadata.useExisting;
+    this.isOptional = metadata.isOptional;
+    this.id = Math.random().toString(36).substring(7);
+  }
+  getInstanceByContextId(contextId) {
+    if (this.scope === 1 /* TRANSIENT */) {
+      return void 0;
+    }
+    if (this.scope === 0 /* DEFAULT */) {
+      return this.instance;
+    }
+    return this.instancesPerContext.get(contextId);
+  }
+  setInstanceByContextId(contextId, instance) {
+    if (this.scope === 0 /* DEFAULT */) {
+      this.instance = instance;
+    } else if (this.scope === 2 /* REQUEST */) {
+      this.instancesPerContext.set(contextId, instance);
+    }
+  }
+  addCtorMetadata(index, token) {
+    if (!this.inject) {
+      this.inject = [];
+    }
+    this.inject[index] = token;
+  }
+};
+
+// src/constants.ts
+var METADATA_KEYS = {
+  MODULE: /* @__PURE__ */ Symbol("module"),
+  GLOBAL: /* @__PURE__ */ Symbol("global"),
+  CONTROLLER: /* @__PURE__ */ Symbol("controller"),
+  FLUSH_ROLES: /* @__PURE__ */ Symbol("flush_roles"),
+  OPTS: /* @__PURE__ */ Symbol("opts"),
+  PARAMS: /* @__PURE__ */ Symbol("params"),
+  ROUTES: /* @__PURE__ */ Symbol("routes"),
+  FILTER_CATCH: /* @__PURE__ */ Symbol("filter_catch"),
+  FILTER_EXCEPTION: /* @__PURE__ */ Symbol("filter_exception"),
+  USE_FILTERS: /* @__PURE__ */ Symbol("use_filters"),
+  USE_PIPES: /* @__PURE__ */ Symbol("use_pipes"),
+  USE_GUARDS: /* @__PURE__ */ Symbol("use_guards"),
+  USE_INTERCEPTORS: /* @__PURE__ */ Symbol("use_interceptors"),
+  ROUTE_ARGS_METADATA: /* @__PURE__ */ Symbol("route_args_metadata"),
+  INJECTIONS: /* @__PURE__ */ Symbol("injections"),
+  OPTIONAL: /* @__PURE__ */ Symbol("optional"),
+  SCOPE: /* @__PURE__ */ Symbol("scope"),
+  METHOD_INJECTIONS: /* @__PURE__ */ Symbol("method_injections"),
+  METHOD_OPTIONAL: /* @__PURE__ */ Symbol("method_optional"),
+  PROPERTY_DEPS: /* @__PURE__ */ Symbol("property_deps"),
+  HTTP_CODE: /* @__PURE__ */ Symbol("http_code"),
+  HEADERS: /* @__PURE__ */ Symbol("headers"),
+  REDIRECT: /* @__PURE__ */ Symbol("redirect")
+};
+
+// src/services/logger.service.ts
+var Logger = class _Logger {
+  static lastTimestamp;
+  static instance;
+  context;
+  constructor(context) {
+    this.context = context;
+  }
+  info(message, ...meta) {
+    const metaStr = meta.length > 0 ? ` ${JSON.stringify(meta)}` : "";
+    this.log(message + metaStr, "info");
+  }
+  static log(message, context = "") {
+    this.printMessage("log", message, context);
+  }
+  static error(message, trace = "", context = "") {
+    this.printMessage("error", message, context, trace);
+  }
+  static warn(message, context = "") {
+    this.printMessage("warn", message, context);
+  }
+  static debug(message, context = "") {
+    this.printMessage("debug", message, context);
+  }
+  static verbose(message, context = "") {
+    this.printMessage("verbose", message, context);
+  }
+  log(message, context) {
+    _Logger.log(message, context || this.context);
+  }
+  error(message, trace = "", context) {
+    _Logger.error(message, trace, context || this.context);
+  }
+  warn(message, context) {
+    _Logger.warn(message, context || this.context);
+  }
+  debug(message, context) {
+    _Logger.debug(message, context || this.context);
+  }
+  verbose(message, context) {
+    _Logger.verbose(message, context || this.context);
+  }
+  static printMessage(level, message, context = "", trace = "") {
+    const color = this.getColorByLevel(level);
+    const date = /* @__PURE__ */ new Date();
+    const timestamp = date.toLocaleString();
+    const pid = process.pid;
+    const contextMessage = context ? `[${context}] ` : "";
+    const output = message instanceof Object ? JSON.stringify(message, null, 2) : message;
+    const currentTimestamp = Date.now();
+    const timeDiff = _Logger.updateAndGetTimestampDiff(currentTimestamp);
+    const C = {
+      reset: "\x1B[0m",
+      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}
+`
+    );
+    if (trace) {
+      process.stdout.write(`${C.red}${trace}${C.reset}
+`);
+    }
+  }
+  static updateAndGetTimestampDiff(timestamp) {
+    let result = "";
+    if (this.lastTimestamp) {
+      result = `+${timestamp - this.lastTimestamp}ms`;
+    }
+    this.lastTimestamp = timestamp;
+    return result;
+  }
+  static getColorByLevel(level) {
+    const C = {
+      red: "\x1B[31m",
+      green: "\x1B[32m",
+      yellow: "\x1B[33m",
+      magenta: "\x1B[35m",
+      cyan: "\x1B[36m"
+    };
+    switch (level) {
+      case "debug":
+        return C.magenta;
+      case "warn":
+        return C.yellow;
+      case "error":
+        return C.red;
+      case "verbose":
+        return C.cyan;
+      default:
+        return C.green;
+    }
+  }
+};
+
+// src/scanner.ts
+var HonoDiScanner = class {
+  constructor(container) {
+    this.container = container;
+  }
+  logger = new Logger("HonoDiScanner");
+  async scan(module) {
+    await this.scanModule(module);
+  }
+  async scanModule(moduleDefinition, scope = []) {
+    let moduleClass;
+    let dynamicMetadata = {};
+    if (moduleDefinition && "module" in moduleDefinition) {
+      moduleClass = moduleDefinition.module;
+      dynamicMetadata = moduleDefinition;
+    } else {
+      moduleClass = moduleDefinition;
+    }
+    const token = moduleClass.name;
+    if (this.container.getModuleByToken(token)) {
+      return this.container.getModuleByToken(token);
+    }
+    const moduleRef = this.container.addModule(moduleClass, token);
+    const moduleWrapper = new InstanceWrapper({
+      token: moduleClass,
+      name: moduleClass.name,
+      metatype: moduleClass,
+      host: moduleRef,
+      scope: 0 /* DEFAULT */
+    });
+    this.scanDependencies(moduleWrapper);
+    moduleRef.addProvider(moduleWrapper);
+    const decoratorOptions = Reflect.getMetadata(METADATA_KEYS.MODULE, moduleClass) || {};
+    const isGlobal = Reflect.getMetadata(METADATA_KEYS.GLOBAL, moduleClass);
+    if (isGlobal) {
+      this.container.addGlobalModule(moduleRef);
+    }
+    const options = {
+      ...decoratorOptions,
+      ...dynamicMetadata,
+      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) {
+        let actualImport = importedModule;
+        if (importedModule && typeof importedModule.forwardRef === "function") {
+          actualImport = importedModule.forwardRef();
+        }
+        const importedRef = await this.scanModule(actualImport, [...scope, moduleClass]);
+        if (importedRef) {
+          moduleRef.addImport(importedRef);
+        }
+      }
+    }
+    if (options.providers) {
+      for (const provider of options.providers) {
+        this.insertProvider(provider, moduleRef);
+      }
+    }
+    if (options.controllers) {
+      for (const controller of options.controllers) {
+        this.insertController(controller, moduleRef);
+      }
+    }
+    if (options.exports) {
+      for (const exportToken of options.exports) {
+        moduleRef.addExport(exportToken);
+      }
+    }
+    return moduleRef;
+  }
+  insertProvider(provider, moduleRef) {
+    provider && !provider.constructor;
+    const isPlainObject = provider && typeof provider === "object" && "provide" in provider;
+    if (!isPlainObject) {
+      const token2 = provider;
+      const wrapper2 = new InstanceWrapper({
+        token: token2,
+        name: token2.name,
+        metatype: provider,
+        host: moduleRef,
+        scope: 0 /* DEFAULT */
+      });
+      this.scanDependencies(wrapper2);
+      moduleRef.addProvider(wrapper2);
+      return;
+    }
+    const token = provider.provide;
+    const wrapper = new InstanceWrapper({
+      token,
+      name: token && token.name ? token.name : typeof token === "string" ? token : "CustomProvider",
+      host: moduleRef,
+      scope: provider.scope || 0 /* DEFAULT */
+    });
+    if (provider.useValue !== void 0) {
+      wrapper.useValue = provider.useValue;
+    } else if (provider.useFactory) {
+      wrapper.useFactory = provider.useFactory;
+      wrapper.inject = provider.inject || [];
+    } else if (provider.useClass) {
+      wrapper.metatype = provider.useClass;
+      this.scanDependencies(wrapper);
+    } else if (provider.useExisting) {
+      wrapper.useExisting = provider.useExisting;
+      wrapper.isAlias = true;
+    }
+    moduleRef.addProvider(wrapper);
+  }
+  insertController(controller, moduleRef) {
+    const token = controller;
+    const wrapper = new InstanceWrapper({
+      token,
+      name: token.name,
+      metatype: controller,
+      host: moduleRef,
+      scope: 0 /* DEFAULT */
+    });
+    this.scanDependencies(wrapper);
+    moduleRef.addController(wrapper);
+  }
+  scanDependencies(wrapper) {
+    const paramTypes = Reflect.getMetadata("design:paramtypes", wrapper.metatype) || [];
+    const injections = Reflect.getMetadata(METADATA_KEYS.INJECTIONS, wrapper.metatype) || [];
+    const optionals = Reflect.getMetadata(METADATA_KEYS.OPTIONAL, wrapper.metatype) || [];
+    const mergedInject = [];
+    const mergedOptional = [];
+    for (let i = 0; i < paramTypes.length; i++) {
+      mergedInject[i] = injections[i] || paramTypes[i];
+      mergedOptional[i] = optionals[i] || false;
+    }
+    wrapper.inject = mergedInject;
+    wrapper.isOptional = mergedOptional;
+    const propertyDeps = Reflect.getMetadata(METADATA_KEYS.PROPERTY_DEPS, wrapper.metatype) || [];
+    const optionalProps = Reflect.getMetadata(METADATA_KEYS.OPTIONAL, wrapper.metatype) || [];
+    wrapper.properties = propertyDeps.map((dep) => {
+      return {
+        key: dep.key,
+        token: dep.token,
+        isOptional: optionalProps.includes(dep.key)
+      };
+    });
+  }
+};
+
+// src/execution-context-host.ts
+var ExecutionContextHost = class {
+  args;
+  constructorRef;
+  handler;
+  context;
+  next;
+  constructor(args, constructorRef, handler) {
+    this.args = args;
+    this.constructorRef = constructorRef;
+    this.handler = handler;
+    this.context = args[0];
+    this.next = args[1];
+  }
+  getClass() {
+    return this.constructorRef;
+  }
+  getHandler() {
+    return this.handler;
+  }
+  getArgs() {
+    return this.args;
+  }
+  getType() {
+    return "http";
+  }
+  switchToHttp() {
+    return {
+      getRequest: () => this.context.req,
+      getResponse: () => this.context,
+      getNext: () => this.next ?? (() => Promise.resolve()),
+      getContext: () => this.context
+    };
+  }
+};
+function Injectable(options) {
+  return (target) => {
+    Reflect.defineMetadata(METADATA_KEYS.SCOPE, 0 /* DEFAULT */, target);
+  };
+}
+function Catch(...exceptions) {
+  return (target) => {
+    Reflect.defineMetadata(METADATA_KEYS.FILTER_CATCH, exceptions, target);
+    Reflect.defineMetadata(METADATA_KEYS.SCOPE, 0 /* DEFAULT */, target);
+  };
+}
+
+// src/middleware/builder.ts
+var MiddlewareBuilder = class {
+  constructor(module) {
+    this.module = module;
+  }
+  configs = [];
+  apply(...middleware) {
+    return new MiddlewareConfigProxyImpl(this, middleware);
+  }
+  addConfig(middleware, routes, excludes = []) {
+    this.configs.push({
+      middleware,
+      routes,
+      excludes,
+      module: this.module
+    });
+  }
+  getConfigs() {
+    return this.configs;
+  }
+};
+var MiddlewareConfigProxyImpl = class {
+  constructor(builder, middleware) {
+    this.builder = builder;
+    this.middleware = middleware;
+  }
+  excludes = [];
+  exclude(...routes) {
+    this.excludes = routes;
+    return this;
+  }
+  forRoutes(...routes) {
+    this.builder.addConfig(this.middleware, routes, this.excludes);
+    return this.builder;
+  }
+};
+
+// src/common/exceptions/http.exception.ts
+var HttpException = class extends Error {
+  constructor(response, status) {
+    super();
+    this.response = response;
+    this.status = status;
+    this.message = typeof response === "string" ? response : JSON.stringify(response);
+  }
+  getResponse() {
+    return this.response;
+  }
+  getStatus() {
+    return this.status;
+  }
+  static createBody(message, error, statusCode) {
+    if (!message) {
+      return { statusCode, error };
+    }
+    return typeof message === "object" && !Array.isArray(message) ? message : { statusCode, error, message };
+  }
+};
+
+// src/common/exceptions/index.ts
+var BadRequestException = class extends HttpException {
+  constructor(message, error = "Bad Request") {
+    super(HttpException.createBody(message, error, 400), 400);
+  }
+};
+var UnauthorizedException = class extends HttpException {
+  constructor(message, error = "Unauthorized") {
+    super(HttpException.createBody(message, error, 401), 401);
+  }
+};
+var NotFoundException = class extends HttpException {
+  constructor(message, error = "Not Found") {
+    super(HttpException.createBody(message, error, 404), 404);
+  }
+};
+var ForbiddenException = class extends HttpException {
+  constructor(message, error = "Forbidden") {
+    super(HttpException.createBody(message, error, 403), 403);
+  }
+};
+var NotAcceptableException = class extends HttpException {
+  constructor(message, error = "Not Acceptable") {
+    super(HttpException.createBody(message, error, 406), 406);
+  }
+};
+var RequestTimeoutException = class extends HttpException {
+  constructor(message, error = "Request Timeout") {
+    super(HttpException.createBody(message, error, 408), 408);
+  }
+};
+var ConflictException = class extends HttpException {
+  constructor(message, error = "Conflict") {
+    super(HttpException.createBody(message, error, 409), 409);
+  }
+};
+var GoneException = class extends HttpException {
+  constructor(message, error = "Gone") {
+    super(HttpException.createBody(message, error, 410), 410);
+  }
+};
+var PayloadTooLargeException = class extends HttpException {
+  constructor(message, error = "Payload Too Large") {
+    super(HttpException.createBody(message, error, 413), 413);
+  }
+};
+var UnsupportedMediaTypeException = class extends HttpException {
+  constructor(message, error = "Unsupported Media Type") {
+    super(HttpException.createBody(message, error, 415), 415);
+  }
+};
+var UnprocessableEntityException = class extends HttpException {
+  constructor(message, error = "Unprocessable Entity") {
+    super(HttpException.createBody(message, error, 422), 422);
+  }
+};
+var InternalServerErrorException = class extends HttpException {
+  constructor(message, error = "Internal Server Error") {
+    super(HttpException.createBody(message, error, 500), 500);
+  }
+};
+var NotImplementedException = class extends HttpException {
+  constructor(message, error = "Not Implemented") {
+    super(HttpException.createBody(message, error, 501), 501);
+  }
+};
+var BadGatewayException = class extends HttpException {
+  constructor(message, error = "Bad Gateway") {
+    super(HttpException.createBody(message, error, 502), 502);
+  }
+};
+var ServiceUnavailableException = class extends HttpException {
+  constructor(message, error = "Service Unavailable") {
+    super(HttpException.createBody(message, error, 503), 503);
+  }
+};
+var GatewayTimeoutException = class extends HttpException {
+  constructor(message, error = "Gateway Timeout") {
+    super(HttpException.createBody(message, error, 504), 504);
+  }
+};
+
+// src/application.ts
+var HonoDiApplication = class {
+  constructor(app, container, injector) {
+    this.app = app;
+    this.container = container;
+    this.injector = injector;
+  }
+  globalFilters = [];
+  globalPipes = [];
+  globalGuards = [];
+  globalInterceptors = [];
+  useGlobalFilters(...filters) {
+    this.globalFilters.push(...filters);
+    return this;
+  }
+  useGlobalPipes(...pipes) {
+    this.globalPipes.push(...pipes);
+    return this;
+  }
+  useGlobalInterceptors(...interceptors) {
+    this.globalInterceptors.push(...interceptors);
+    return this;
+  }
+  useGlobalGuards(...guards) {
+    this.globalGuards.push(...guards);
+    return this;
+  }
+  globalPrefix = "";
+  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.");
+    }
+    this.globalPrefix = prefix;
+    return this;
+  }
+  getGlobalPrefix() {
+    return this.globalPrefix;
+  }
+  logger = new Logger("HonoDiApplication");
+  isInitialized = false;
+  async init() {
+    if (this.isInitialized) return this;
+    this.logger.log("Initializing middleware...");
+    await this.initializeMiddleware();
+    this.logger.log("Registering controllers...");
+    this.registerControllersFromContainer();
+    this.logger.log("Calling OnApplicationBootstrap...");
+    await this.callLifecycleHook("onApplicationBootstrap");
+    this.isInitialized = true;
+    return this;
+  }
+  async listen(port, callback) {
+    if (!this.isInitialized) await this.init();
+    const server = Bun.serve({
+      port: Number(port),
+      fetch: this.app.fetch
+    });
+    if (callback) callback();
+    return server;
+  }
+  async callLifecycleHook(hook) {
+    const modules = this.container.getModules();
+    for (const module of modules.values()) {
+      for (const wrapper of module.providers.values()) {
+        if (wrapper.instance && wrapper.instance[hook]) {
+          await wrapper.instance[hook]();
+        }
+      }
+      for (const wrapper of module.controllers.values()) {
+        if (wrapper.instance && wrapper.instance[hook]) {
+          await wrapper.instance[hook]();
+        }
+      }
+    }
+  }
+  registerControllersFromContainer() {
+    const modules = this.container.getModules();
+    modules.forEach((module) => {
+      module.controllers.forEach((wrapper) => {
+        this.registerControllerRoutes(wrapper.metatype, this.app, module);
+      });
+    });
+  }
+  registerControllerRoutes(controllerClass, app, moduleRef) {
+    if (!Reflect.hasMetadata(METADATA_KEYS.CONTROLLER, controllerClass)) {
+      return;
+    }
+    const { prefix } = Reflect.getMetadata(METADATA_KEYS.CONTROLLER, controllerClass);
+    const routes = Reflect.getMetadata(METADATA_KEYS.ROUTES, controllerClass);
+    if (!routes) return;
+    routes.forEach((route) => {
+      const globalPrefix = this.getGlobalPrefix();
+      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]);
+        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
+          );
+          if (!await this.runGuards(guards, executionContext)) {
+            c.status(403);
+            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
+          );
+          if (args.length === 0 && !Reflect.hasMetadata(METADATA_KEYS.ROUTE_ARGS_METADATA, controllerClass, route.methodName)) {
+            args.push(c);
+          }
+          const interceptorChain = async (index) => {
+            if (index >= interceptors.length) {
+              return new rxjs.Observable((subscriber) => {
+                try {
+                  const result2 = handler(...args);
+                  if (result2 instanceof Promise) {
+                    result2.then((data) => {
+                      subscriber.next(data);
+                      subscriber.complete();
+                    }).catch((err) => subscriber.error(err));
+                  } else {
+                    subscriber.next(result2);
+                    subscriber.complete();
+                  }
+                } catch (err) {
+                  subscriber.error(err);
+                }
+              });
+            }
+            return interceptors[index].intercept(executionContext, {
+              handle: () => rxjs.from(interceptorChain(index + 1)).pipe(operators.mergeMap((obs2) => obs2))
+            });
+          };
+          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);
+          }
+          const headers = Reflect.getMetadata(METADATA_KEYS.HEADERS, controllerInstance[route.methodName]);
+          if (headers) {
+            headers.forEach((h) => c.header(h.name, h.value));
+          }
+          const redirect = Reflect.getMetadata(METADATA_KEYS.REDIRECT, controllerInstance[route.methodName]);
+          if (redirect) {
+            if (result && typeof result === "object" && result.url) {
+              return c.redirect(result.url, result.statusCode || redirect.statusCode);
+            }
+            return c.redirect(redirect.url, redirect.statusCode);
+          }
+          if (result instanceof Response) {
+            return result;
+          }
+          if (result && typeof result.text === "function" && typeof result.headers === "object") {
+            return result;
+          }
+          return c.json(result);
+        } catch (exception) {
+          return await this.handleException(exception, c, controllerClass, route.methodName, moduleRef, 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);
+        if (!wrapper) {
+          wrapper = new InstanceWrapper({
+            token: item,
+            name: item.name,
+            metatype: item,
+            host: moduleRef,
+            scope: 1 /* TRANSIENT */
+          });
+          scanner.scanDependencies(wrapper);
+        }
+        const instance = await this.injector.loadInstance(wrapper, contextId);
+        instances.push(instance);
+      } else {
+        instances.push(item);
+      }
+    }
+    return instances;
+  }
+  async resolveArgs(contextId, context, controller, methodName, moduleRef, methodPipes = []) {
+    const argsMetadata = Reflect.getMetadata(METADATA_KEYS.ROUTE_ARGS_METADATA, controller, methodName) || {};
+    const args = [];
+    const c = context.getArgs()[0];
+    const sortedArgs = Object.values(argsMetadata).sort((a, b) => a.index - b.index);
+    for (const arg of sortedArgs) {
+      let value;
+      const { index, data, pipes, paramtype } = arg;
+      switch (paramtype) {
+        case 0 /* REQUEST */:
+          value = c.req;
+          break;
+        case 1 /* RESPONSE */:
+          value = c;
+          break;
+        case 2 /* NEXT */:
+          value = context.getArgs()[1];
+          break;
+        case 12 /* CONTEXT */:
+          value = c;
+          break;
+        case 3 /* BODY */:
+          if (data && c.req.parseBody) {
+            const body = await c.req.parseBody();
+            value = body[data];
+          } else {
+            try {
+              const body = await c.req.json();
+              value = data ? body[data] : body;
+            } catch (e) {
+              value = null;
+            }
+          }
+          break;
+        case 4 /* QUERY */:
+          value = data ? c.req.query(data) : c.req.query();
+          break;
+        case 5 /* PARAM */:
+          value = data ? c.req.param(data) : c.req.param();
+          break;
+        case 6 /* HEADERS */:
+          value = data ? c.req.header(data) : c.req.header();
+          break;
+        case 11 /* IP */:
+          value = c.req.header("x-forwarded-for") || "127.0.0.1";
+          break;
+        case 13 /* CUSTOM */:
+          const factory = arg.pipes[0];
+          if (typeof factory === "function") {
+            value = factory(data, context);
+          }
+          break;
+        default:
+          value = null;
+      }
+      const paramPipeInstances = await this.resolveContextItems(pipes || [], moduleRef, contextId);
+      const allPipes = [...methodPipes, ...paramPipeInstances];
+      for (const pipe of allPipes) {
+        value = await pipe.transform(value, { type: "custom", metatype: null, data });
+      }
+      args[index] = value;
+    }
+    return args;
+  }
+  async runGuards(guards, context) {
+    for (const guard of guards) {
+      const result = await guard.canActivate(context);
+      if (!result) return false;
+    }
+    return true;
+  }
+  async initializeMiddleware() {
+    const configs = [];
+    const modules = this.container.getModules();
+    for (const module of modules.values()) {
+      const moduleClass = module.metatype;
+      const wrapper = module.getProvider(moduleClass);
+      if (wrapper && wrapper.instance && wrapper.instance.configure) {
+        const builder = new MiddlewareBuilder(module);
+        wrapper.instance.configure(builder);
+        configs.push(...builder.getConfigs());
+      }
+    }
+    if (configs.length === 0) return;
+    const resolvedConfigs = [];
+    const globalContextId = new ContextId();
+    for (const config of configs) {
+      const instances = [];
+      for (const m of config.middleware) {
+        if (typeof m === "function" && !m.prototype?.use) {
+          instances.push(m);
+        } else {
+          const wrapper = new InstanceWrapper({
+            token: m,
+            name: m.name,
+            metatype: m,
+            scope: 1 /* TRANSIENT */
+          });
+          const scanner = new HonoDiScanner(this.container);
+          scanner.scanDependencies(wrapper);
+          const hostModule = config.module || modules.values().next().value;
+          wrapper.host = hostModule;
+          const instance = await this.injector.loadInstance(wrapper, globalContextId);
+          instances.push(instance);
+        }
+      }
+      resolvedConfigs.push({ ...config, instances });
+    }
+    this.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 = 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 () => {
+            nextCalled = true;
+            try {
+              await executeChain(index + 1, finalNext);
+              resolve();
+            } catch (e) {
+              reject(e);
+            }
+          };
+          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);
+          }
+        });
+      };
+      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 (typeof route === "object" && route.path && route.method) {
+        if (route.method !== -1 && route.method !== "all" /* ALL */ && route.method !== method.toLowerCase()) {
+          continue;
+        }
+        if (route.path === "*" || path === route.path) return true;
+      } else if (typeof route === "function") {
+        const prefix = Reflect.getMetadata(METADATA_KEYS.CONTROLLER, route)?.prefix || "";
+        if (path.startsWith(this.combinePaths(prefix, ""))) return true;
+      }
+    }
+    return false;
+  }
+  isRouteExcluded(routes, path, method) {
+    return this.isRouteMatch(routes, path, method);
+  }
+  combinePaths(prefix, path) {
+    const cleanPrefix = prefix ? prefix.replace(/^\/+/, "").replace(/\/+$/, "") : "";
+    const cleanPath = path ? path.replace(/^\/+/, "").replace(/\/+$/, "") : "";
+    let result = "";
+    if (cleanPrefix) result += `/${cleanPrefix}`;
+    if (cleanPath) result += `/${cleanPath}`;
+    return result || "/";
+  }
+  getHttpAdapter() {
+    return this.app;
+  }
+  get(typeOrToken, options) {
+    const modules = this.container.getModules();
+    for (const module of modules.values()) {
+      const provider = module.getProvider(typeOrToken);
+      if (provider && provider.instance) {
+        return provider.instance;
+      }
+    }
+    throw new Error(`Provider ${String(typeOrToken)} not found`);
+  }
+  async close() {
+  }
+  // Getters for global items (internal use)
+  getGlobalFilters() {
+    return this.globalFilters;
+  }
+  getGlobalPipes() {
+    return this.globalPipes;
+  }
+  getGlobalGuards() {
+    return this.globalGuards;
+  }
+  getGlobalInterceptors() {
+    return this.globalInterceptors;
+  }
+  getContainer() {
+    return this.container;
+  }
+};
+
+// src/factory.ts
+var HonoDiFactory = class {
+  static logger = new Logger("HonoDiFactory");
+  static async create(rootModule, appOrOptions) {
+    let app;
+    let autoInit = true;
+    if (appOrOptions && "fetch" in appOrOptions && typeof appOrOptions.fetch === "function") {
+      app = appOrOptions;
+    } else if (appOrOptions) {
+      const options = appOrOptions;
+      app = options.app;
+      if (options.autoInit !== void 0) {
+        autoInit = options.autoInit;
+      }
+    }
+    const container = new Container();
+    const scanner = new HonoDiScanner(container);
+    const injector = new Injector(container);
+    const honoApp = app || new hono.Hono();
+    const bunApp = new HonoDiApplication(honoApp, container, injector);
+    this.logger.log("Scanning modules...");
+    await scanner.scan(rootModule);
+    this.logger.log("Instantiating providers...");
+    await this.instantiateProviders(container, injector);
+    this.logger.log("Calling OnModuleInit...");
+    await this.callLifecycleHook("onModuleInit", container);
+    if (autoInit) {
+      await bunApp.init();
+    }
+    return bunApp;
+  }
+  static async instantiateProviders(container, injector) {
+    const modules = container.getModules();
+    const globalContextId = new ContextId();
+    for (const module of modules.values()) {
+      for (const wrapper of module.providers.values()) {
+        if (wrapper.scope === 0 /* DEFAULT */) {
+          await injector.loadInstance(wrapper, globalContextId);
+        }
+      }
+      for (const wrapper of module.controllers.values()) {
+        if (wrapper.scope === 0 /* DEFAULT */) {
+          await injector.loadInstance(wrapper, globalContextId);
+        }
+      }
+    }
+  }
+  static async callLifecycleHook(hook, container) {
+    const modules = container.getModules();
+    for (const module of modules.values()) {
+      for (const wrapper of module.providers.values()) {
+        if (wrapper.instance && wrapper.instance[hook]) {
+          await wrapper.instance[hook]();
+        }
+      }
+      for (const wrapper of module.controllers.values()) {
+        if (wrapper.instance && wrapper.instance[hook]) {
+          await wrapper.instance[hook]();
+        }
+      }
+    }
+  }
+};
+
+// src/utils.ts
+function forwardRef(fn) {
+  return { forwardRef: fn };
+}
+
+// src/services/reflector.service.ts
+exports.Reflector = class Reflector {
+  get(metadataKey, target) {
+    return Reflect.getMetadata(metadataKey, target);
+  }
+  getAllAndOverride(metadataKey, targets) {
+    for (const target of targets) {
+      const result = Reflect.getMetadata(metadataKey, target);
+      if (result !== void 0) {
+        return result;
+      }
+    }
+    return void 0;
+  }
+  getAllAndMerge(metadataKey, targets) {
+    const result = [];
+    for (const target of targets) {
+      const metadata = Reflect.getMetadata(metadataKey, target);
+      if (metadata) {
+        if (Array.isArray(metadata)) {
+          result.push(...metadata);
+        } else {
+          result.push(metadata);
+        }
+      }
+    }
+    return result;
+  }
+};
+exports.Reflector = __decorateClass([
+  Injectable()
+], exports.Reflector);
+
+// src/common/pipes/index.ts
+exports.ParseIntPipe = class ParseIntPipe {
+  transform(value, metadata) {
+    const isNumeric = !isNaN(parseFloat(value)) && isFinite(value);
+    if (!isNumeric) {
+      throw new BadRequestException("Validation failed (numeric string is expected)");
+    }
+    return parseInt(value, 10);
+  }
+};
+exports.ParseIntPipe = __decorateClass([
+  Injectable()
+], exports.ParseIntPipe);
+exports.ParseFloatPipe = class ParseFloatPipe {
+  transform(value, metadata) {
+    const isNumeric = !isNaN(parseFloat(value)) && isFinite(value);
+    if (!isNumeric) {
+      throw new BadRequestException("Validation failed (numeric string is expected)");
+    }
+    return parseFloat(value);
+  }
+};
+exports.ParseFloatPipe = __decorateClass([
+  Injectable()
+], exports.ParseFloatPipe);
+exports.ParseBoolPipe = class ParseBoolPipe {
+  transform(value, metadata) {
+    if (value === true || value === "true") {
+      return true;
+    }
+    if (value === false || value === "false") {
+      return false;
+    }
+    throw new BadRequestException("Validation failed (boolean string is expected)");
+  }
+};
+exports.ParseBoolPipe = __decorateClass([
+  Injectable()
+], exports.ParseBoolPipe);
+exports.ValidationPipe = class ValidationPipe {
+  transform(value, metadata) {
+    return value;
+  }
+};
+exports.ValidationPipe = __decorateClass([
+  Injectable()
+], exports.ValidationPipe);
+
+// src/common/errors/AppError.ts
+var AppError = class _AppError extends Error {
+  constructor(statusCode, message, isOperational = true) {
+    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 {
+  constructor(message = "Resource not found") {
+    super(404, message);
+  }
+};
+var BadRequestError = class extends AppError {
+  constructor(message = "Bad request") {
+    super(400, message);
+  }
+};
+var UnauthorizedError = class extends AppError {
+  constructor(message = "Unauthorized") {
+    super(401, message);
+  }
+};
+var ForbiddenError = class extends AppError {
+  constructor(message = "Forbidden") {
+    super(403, message);
+  }
+};
+var ConflictError = class extends AppError {
+  constructor(message = "Resource already exists") {
+    super(409, message);
+  }
+};
+
+// src/common/exceptions/HttpException.ts
+var HttpException2 = class extends Error {
+  constructor(response, status) {
+    super();
+    this.response = response;
+    this.status = status;
+    this.message = typeof response === "string" ? response : JSON.stringify(response);
+  }
+  getResponse() {
+    return this.response;
+  }
+  getStatus() {
+    return this.status;
+  }
+  static createBody(message, error, statusCode) {
+    if (!message) {
+      return { statusCode, error };
+    }
+    return typeof message === "object" && !Array.isArray(message) ? message : { statusCode, error, message };
+  }
+};
+
+// src/common/filters/BaseExceptionFilter.ts
+exports.BaseExceptionFilter = class BaseExceptionFilter {
+  catch(exception, host) {
+    const ctx = host.switchToHttp();
+    ctx.getResponse();
+    const honoCtx = ctx.getContext();
+    if (exception instanceof HttpException2) {
+      const status = exception.getStatus();
+      const res = exception.getResponse();
+      honoCtx.status(status);
+      return honoCtx.json(res);
+    }
+    console.error(exception);
+    honoCtx.status(500);
+    return honoCtx.json({
+      statusCode: 500,
+      message: "Internal Server Error"
+    });
+  }
+};
+exports.BaseExceptionFilter = __decorateClass([
+  Catch()
+], exports.BaseExceptionFilter);
+
+exports.AppError = AppError;
+exports.BadGatewayException = BadGatewayException;
+exports.BadRequestError = BadRequestError;
+exports.BadRequestException = BadRequestException;
+exports.ConflictError = ConflictError;
+exports.ConflictException = ConflictException;
+exports.Container = Container;
+exports.ExecutionContextHost = ExecutionContextHost;
+exports.ForbiddenError = ForbiddenError;
+exports.ForbiddenException = ForbiddenException;
+exports.GatewayTimeoutException = GatewayTimeoutException;
+exports.GoneException = GoneException;
+exports.HonoDiApplication = HonoDiApplication;
+exports.HonoDiFactory = HonoDiFactory;
+exports.HonoDiScanner = HonoDiScanner;
+exports.HttpException = HttpException;
+exports.InternalServerErrorException = InternalServerErrorException;
+exports.METADATA_KEYS = METADATA_KEYS;
+exports.MiddlewareBuilder = MiddlewareBuilder;
+exports.ModuleRef = ModuleRef;
+exports.ModuleRefImpl = ModuleRefImpl;
+exports.NotAcceptableException = NotAcceptableException;
+exports.NotFoundError = NotFoundError;
+exports.NotFoundException = NotFoundException;
+exports.NotImplementedException = NotImplementedException;
+exports.PayloadTooLargeException = PayloadTooLargeException;
+exports.RequestMethod = RequestMethod;
+exports.RequestTimeoutException = RequestTimeoutException;
+exports.ServiceUnavailableException = ServiceUnavailableException;
+exports.UnauthorizedError = UnauthorizedError;
+exports.UnauthorizedException = UnauthorizedException;
+exports.UnprocessableEntityException = UnprocessableEntityException;
+exports.UnsupportedMediaTypeException = UnsupportedMediaTypeException;
+exports.forwardRef = forwardRef;
+//# sourceMappingURL=core.cjs.map
+//# sourceMappingURL=core.cjs.map