@ajke/core 0.1.0

package/dist/index.cjs

@@ -0,0 +1,974 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } } function _optionalChain(ops) { let lastAccessLHS = undefined; let value = ops[0]; let i = 1; while (i < ops.length) { const op = ops[i]; const fn = ops[i + 1]; i += 2; if ((op === 'optionalAccess' || op === 'optionalCall') && value == null) { return undefined; } if (op === 'access' || op === 'optionalAccess') { lastAccessLHS = value; value = fn(value); } else if (op === 'call' || op === 'optionalCall') { value = fn((...args) => value.call(lastAccessLHS, ...args)); lastAccessLHS = undefined; } } return value; } var _class;
+
+
+
+
+var _chunkYUBEJL4Tcjs = require('./chunk-YUBEJL4T.cjs');
+
+
+var _chunkZBDE64SDcjs = require('./chunk-ZBDE64SD.cjs');
+
+// src/decorators/core/injectable.decorator.ts
+var _tsyringe = require('tsyringe');
+
+// src/utils/forward-ref.util.ts
+function forwardRef(fn) {
+  return { forwardRef: fn };
+}
+function isForwardRef(val) {
+  return val !== null && val !== void 0 && typeof val === "object" && typeof val.forwardRef === "function";
+}
+
+// src/decorators/core/injectable.decorator.ts
+var INJECT_CUSTOM_TOKENS_KEY = "wilt:inject:custom:tokens";
+function Injectable() {
+  return (target) => {
+    _tsyringe.injectable.call(void 0, )(target);
+  };
+}
+function Inject(token) {
+  return (target, propertyKey, parameterIndex) => {
+    if (isForwardRef(token)) {
+      const existing2 = Reflect.getMetadata(INJECT_CUSTOM_TOKENS_KEY, target) || {};
+      existing2[parameterIndex] = token;
+      Reflect.defineMetadata(INJECT_CUSTOM_TOKENS_KEY, existing2, target);
+      return;
+    }
+    if (!token) {
+      const paramTypes = Reflect.getMetadata("design:paramtypes", target) || [];
+      const paramType = paramTypes[parameterIndex];
+      if (paramType) {
+        return _tsyringe.inject.call(void 0, paramType)(target, propertyKey, parameterIndex);
+      }
+      return;
+    }
+    const existing = Reflect.getMetadata(INJECT_CUSTOM_TOKENS_KEY, target) || {};
+    existing[parameterIndex] = token;
+    Reflect.defineMetadata(INJECT_CUSTOM_TOKENS_KEY, existing, target);
+    return _tsyringe.inject.call(void 0, token)(target, propertyKey, parameterIndex);
+  };
+}
+
+// src/decorators/core/set-metadata.decorator.ts
+function SetMetadata(metadataKey, metadataValue) {
+  const decoratorFactory = (target, key, descriptor) => {
+    if (descriptor) {
+      Reflect.defineMetadata(metadataKey, metadataValue, descriptor.value);
+      return descriptor;
+    }
+    Reflect.defineMetadata(metadataKey, metadataValue, target);
+    return target;
+  };
+  decoratorFactory.KEY = metadataKey;
+  return decoratorFactory;
+}
+
+// src/decorators/core/use-guards.decorator.ts
+var GUARDS_METADATA = "wilt:guards";
+function UseGuards(...guards) {
+  return (target, key, descriptor) => {
+    if (descriptor) {
+      const existing2 = Reflect.getMetadata(GUARDS_METADATA, descriptor.value) || [];
+      Reflect.defineMetadata(GUARDS_METADATA, [...existing2, ...guards], descriptor.value);
+      return descriptor;
+    }
+    const existing = Reflect.getMetadata(GUARDS_METADATA, target) || [];
+    Reflect.defineMetadata(GUARDS_METADATA, [...existing, ...guards], target);
+    return target;
+  };
+}
+
+// src/decorators/core/use-interceptors.decorator.ts
+var INTERCEPTORS_METADATA = "wilt:interceptors";
+function UseInterceptors(...interceptors) {
+  return (target, key, descriptor) => {
+    if (descriptor) {
+      const existing2 = Reflect.getMetadata(INTERCEPTORS_METADATA, descriptor.value) || [];
+      Reflect.defineMetadata(INTERCEPTORS_METADATA, [...existing2, ...interceptors], descriptor.value);
+      return descriptor;
+    }
+    const existing = Reflect.getMetadata(INTERCEPTORS_METADATA, target) || [];
+    Reflect.defineMetadata(INTERCEPTORS_METADATA, [...existing, ...interceptors], target);
+    return target;
+  };
+}
+
+// src/decorators/core/exception-filters.decorator.ts
+var FILTERS_METADATA = "wilt:filters";
+var CATCH_METADATA = "wilt:catch";
+function Catch(...exceptions) {
+  return (target) => {
+    Reflect.defineMetadata(CATCH_METADATA, exceptions, target);
+    return target;
+  };
+}
+function UseFilters(...filters) {
+  return (target, key, descriptor) => {
+    if (descriptor) {
+      const existing2 = Reflect.getMetadata(FILTERS_METADATA, descriptor.value) || [];
+      Reflect.defineMetadata(FILTERS_METADATA, [...existing2, ...filters], descriptor.value);
+      return descriptor;
+    }
+    const existing = Reflect.getMetadata(FILTERS_METADATA, target) || [];
+    Reflect.defineMetadata(FILTERS_METADATA, [...existing, ...filters], target);
+    return target;
+  };
+}
+
+// src/decorators/core/optional.decorator.ts
+var OPTIONAL_METADATA = "wilt:optional";
+function Optional() {
+  return (target, _key, parameterIndex) => {
+    const existing = Reflect.getMetadata(OPTIONAL_METADATA, target) || [];
+    existing.push(parameterIndex);
+    Reflect.defineMetadata(OPTIONAL_METADATA, existing, target);
+  };
+}
+
+// src/decorators/http/controller.decorator.ts
+
+
+// src/context/execution-context.ts
+function createExecutionContext(c, controllerClass, handler) {
+  return {
+    getClass: () => controllerClass,
+    getHandler: () => handler,
+    switchToHttp: () => ({
+      getRequest: () => c
+    })
+  };
+}
+function createArgumentsHost(c) {
+  return {
+    switchToHttp: () => ({
+      getRequest: () => c
+    })
+  };
+}
+
+// src/decorators/http/header.decorator.ts
+var HEADER_METADATA = "wilt:response-headers";
+function Header(name, value) {
+  return (_target, _key, descriptor) => {
+    const existing = Reflect.getMetadata(HEADER_METADATA, descriptor.value) || [];
+    existing.push({ name, value });
+    Reflect.defineMetadata(HEADER_METADATA, existing, descriptor.value);
+    return descriptor;
+  };
+}
+
+// src/decorators/http/http-code.decorator.ts
+var HTTP_CODE_METADATA = "wilt:http-code";
+function HttpCode(statusCode) {
+  return (_target, _key, descriptor) => {
+    Reflect.defineMetadata(HTTP_CODE_METADATA, statusCode, descriptor.value);
+    return descriptor;
+  };
+}
+
+// src/decorators/http/redirect.decorator.ts
+var REDIRECT_METADATA = "wilt:redirect";
+function Redirect(url, statusCode = 302) {
+  return (_target, _key, descriptor) => {
+    Reflect.defineMetadata(REDIRECT_METADATA, { url, statusCode }, descriptor.value);
+    return descriptor;
+  };
+}
+
+// src/decorators/http/route-params.decorator.ts
+var ROUTE_PARAMS_METADATA = "wilt:route-params";
+var TOTAL_PARAMS_METADATA = "wilt:total-params";
+function recordTotalParams(target, key) {
+  if (!Reflect.hasMetadata(TOTAL_PARAMS_METADATA, target, key)) {
+    const fn = target[key];
+    if (typeof fn === "function") {
+      Reflect.defineMetadata(TOTAL_PARAMS_METADATA, fn.length, target, key);
+    }
+  }
+}
+function createParamDecorator(type) {
+  return (data) => (target, propertyKey, parameterIndex) => {
+    const key = propertyKey;
+    const existing = Reflect.getMetadata(ROUTE_PARAMS_METADATA, target, key) || [];
+    existing.push({ index: parameterIndex, type, data });
+    Reflect.defineMetadata(ROUTE_PARAMS_METADATA, existing, target, key);
+    recordTotalParams(target, key);
+  };
+}
+var Body = createParamDecorator("body");
+var Param = createParamDecorator("param");
+var Query = createParamDecorator("query");
+var Headers = createParamDecorator("headers");
+function Ip() {
+  return (target, propertyKey, parameterIndex) => {
+    const key = propertyKey;
+    const existing = Reflect.getMetadata(ROUTE_PARAMS_METADATA, target, key) || [];
+    existing.push({ index: parameterIndex, type: "ip" });
+    Reflect.defineMetadata(ROUTE_PARAMS_METADATA, existing, target, key);
+    recordTotalParams(target, key);
+  };
+}
+function Req() {
+  return (target, propertyKey, parameterIndex) => {
+    const key = propertyKey;
+    const existing = Reflect.getMetadata(ROUTE_PARAMS_METADATA, target, key) || [];
+    existing.push({ index: parameterIndex, type: "req" });
+    Reflect.defineMetadata(ROUTE_PARAMS_METADATA, existing, target, key);
+    recordTotalParams(target, key);
+  };
+}
+
+// src/exceptions/http-exceptions.ts
+var BadRequestException = class extends _chunkYUBEJL4Tcjs.HttpException {
+  constructor(message = "Bad Request") {
+    super(message, 400);
+    this.name = "BadRequestException";
+  }
+};
+var UnauthorizedException = class extends _chunkYUBEJL4Tcjs.HttpException {
+  constructor(message = "Unauthorized") {
+    super(message, 401);
+    this.name = "UnauthorizedException";
+  }
+};
+var ForbiddenException = class extends _chunkYUBEJL4Tcjs.HttpException {
+  constructor(message = "Forbidden") {
+    super(message, 403);
+    this.name = "ForbiddenException";
+  }
+};
+var NotFoundException = class extends _chunkYUBEJL4Tcjs.HttpException {
+  constructor(message = "Not Found") {
+    super(message, 404);
+    this.name = "NotFoundException";
+  }
+};
+var MethodNotAllowedException = class extends _chunkYUBEJL4Tcjs.HttpException {
+  constructor(message = "Method Not Allowed") {
+    super(message, 405);
+    this.name = "MethodNotAllowedException";
+  }
+};
+var ConflictException = class extends _chunkYUBEJL4Tcjs.HttpException {
+  constructor(message = "Conflict") {
+    super(message, 409);
+    this.name = "ConflictException";
+  }
+};
+var GoneException = class extends _chunkYUBEJL4Tcjs.HttpException {
+  constructor(message = "Gone") {
+    super(message, 410);
+    this.name = "GoneException";
+  }
+};
+var UnprocessableEntityException = class extends _chunkYUBEJL4Tcjs.HttpException {
+  constructor(message = "Unprocessable Entity") {
+    super(message, 422);
+    this.name = "UnprocessableEntityException";
+  }
+};
+var TooManyRequestsException = class extends _chunkYUBEJL4Tcjs.HttpException {
+  constructor(message = "Too Many Requests") {
+    super(message, 429);
+    this.name = "TooManyRequestsException";
+  }
+};
+var InternalServerErrorException = class extends _chunkYUBEJL4Tcjs.HttpException {
+  constructor(message = "Internal Server Error") {
+    super(message, 500);
+    this.name = "InternalServerErrorException";
+  }
+};
+var NotImplementedException = class extends _chunkYUBEJL4Tcjs.HttpException {
+  constructor(message = "Not Implemented") {
+    super(message, 501);
+    this.name = "NotImplementedException";
+  }
+};
+var ServiceUnavailableException = class extends _chunkYUBEJL4Tcjs.HttpException {
+  constructor(message = "Service Unavailable") {
+    super(message, 503);
+    this.name = "ServiceUnavailableException";
+  }
+};
+
+// src/decorators/http/controller.decorator.ts
+function Controller(prefix = "") {
+  return (target) => {
+    _tsyringe.injectable.call(void 0, )(target);
+    target.prototype.prefix = prefix;
+    target.prototype.constructorParams = target.prototype.constructorParams || [];
+    target.prototype.constructorClass = target;
+  };
+}
+function resolveFromRegistry(ClassOrInstance, instanceRegistry) {
+  if (typeof ClassOrInstance !== "function") return ClassOrInstance;
+  if (_optionalChain([instanceRegistry, 'optionalAccess', _2 => _2.has, 'call', _3 => _3(ClassOrInstance)])) return instanceRegistry.get(ClassOrInstance);
+  return new ClassOrInstance();
+}
+async function resolveParamArgs(paramMeta, c, totalParams) {
+  const maxIndex = Math.max(totalParams - 1, ...paramMeta.map((p) => p.index));
+  const args = new Array(maxIndex + 1).fill(void 0);
+  const filledIndices = new Set(paramMeta.map((p) => p.index));
+  let body;
+  const needsBody = paramMeta.some((p) => p.type === "body");
+  if (needsBody) {
+    const ct = c.req.header("content-type") || "";
+    if (ct.includes("multipart/form-data")) {
+      const fd = await c.req.formData();
+      body = {};
+      fd.forEach((v, k) => {
+        body[k] = v;
+      });
+    } else {
+      body = await c.req.json().catch(() => ({}));
+    }
+  }
+  for (const p of paramMeta) {
+    switch (p.type) {
+      case "body":
+        args[p.index] = p.data ? _optionalChain([body, 'optionalAccess', _4 => _4[p.data]]) : body;
+        break;
+      case "param":
+        args[p.index] = p.data ? c.req.param(p.data) : c.req.param();
+        break;
+      case "query":
+        args[p.index] = p.data ? c.req.query(p.data) : c.req.query();
+        break;
+      case "headers":
+        args[p.index] = p.data ? c.req.header(p.data) : Object.fromEntries(c.req.raw.headers.entries());
+        break;
+      case "ip":
+        args[p.index] = c.req.header("cf-connecting-ip") || c.req.header("x-forwarded-for") || "";
+        break;
+      case "req":
+        args[p.index] = c;
+        break;
+    }
+  }
+  for (let i = 0; i <= maxIndex; i++) {
+    if (!filledIndices.has(i)) args[i] = c;
+  }
+  return args;
+}
+function registerControllerRoutes(router, controller, prefix = "", instanceRegistry) {
+  const routes = controller.constructor.prototype.routes || [];
+  const controllerClass = controller.constructor;
+  for (const route of routes) {
+    const handlerFn = controller[route.handler];
+    const fullPath = prefix + route.path;
+    const proto = controllerClass.prototype;
+    const classGuards = Reflect.getMetadata(GUARDS_METADATA, controllerClass) || [];
+    const methodGuards = Reflect.getMetadata(GUARDS_METADATA, handlerFn) || [];
+    const guards = [...classGuards, ...methodGuards];
+    const classInterceptors = Reflect.getMetadata(INTERCEPTORS_METADATA, controllerClass) || [];
+    const methodInterceptors = Reflect.getMetadata(INTERCEPTORS_METADATA, handlerFn) || [];
+    const interceptors = [...classInterceptors, ...methodInterceptors];
+    const classFilters = Reflect.getMetadata(FILTERS_METADATA, controllerClass) || [];
+    const methodFilters = Reflect.getMetadata(FILTERS_METADATA, handlerFn) || [];
+    const filters = [...classFilters, ...methodFilters];
+    const httpCode = Reflect.getMetadata(HTTP_CODE_METADATA, handlerFn);
+    const headersToSet = Reflect.getMetadata(HEADER_METADATA, handlerFn) || [];
+    const redirectMeta = Reflect.getMetadata(REDIRECT_METADATA, handlerFn);
+    const paramMeta = Reflect.getMetadata(ROUTE_PARAMS_METADATA, proto, route.handler) || [];
+    const totalParams = _nullishCoalesce(Reflect.getMetadata(TOTAL_PARAMS_METADATA, proto, route.handler), () => ( 0));
+    const methodMiddlewares = handlerFn.middlewares || [];
+    const finalHandler = async (c) => {
+      const execCtx = createExecutionContext(c, controllerClass, handlerFn);
+      const runCore = async () => {
+        for (const G of guards) {
+          const guard = resolveFromRegistry(G, instanceRegistry);
+          const ok = await guard.canActivate(execCtx);
+          if (!ok) throw new ForbiddenException();
+        }
+        const callHandler = async () => {
+          let result;
+          if (paramMeta.length > 0) {
+            const args = await resolveParamArgs(paramMeta, c, totalParams);
+            result = await handlerFn.call(controller, ...args);
+          } else {
+            result = await handlerFn.call(controller, c);
+          }
+          for (const { name, value } of headersToSet) {
+            c.header(name, value);
+          }
+          if (redirectMeta) {
+            const url = result && typeof result === "object" && "url" in result ? result.url : redirectMeta.url;
+            const code = result && typeof result === "object" && "statusCode" in result ? result.statusCode : redirectMeta.statusCode;
+            return c.redirect(url, code);
+          }
+          if (result instanceof Response) return result;
+          if (result !== void 0 && result !== null) {
+            return c.json(result, _nullishCoalesce(httpCode, () => ( 200)));
+          }
+          return new Response(null, { status: _nullishCoalesce(httpCode, () => ( 204)) });
+        };
+        if (methodMiddlewares.length > 0) {
+          let idx = 0;
+          const next = async () => {
+            if (idx < methodMiddlewares.length) {
+              return await methodMiddlewares[idx++](c, next);
+            }
+            return callHandler();
+          };
+          return await next();
+        }
+        return callHandler();
+      };
+      const runWithInterceptors = async () => {
+        if (interceptors.length === 0) return runCore();
+        let chain = runCore;
+        for (let i = interceptors.length - 1; i >= 0; i--) {
+          const interceptor = resolveFromRegistry(interceptors[i], instanceRegistry);
+          const inner = chain;
+          chain = () => interceptor.intercept(execCtx, { handle: inner });
+        }
+        return chain();
+      };
+      if (filters.length === 0) return runWithInterceptors();
+      try {
+        return await runWithInterceptors();
+      } catch (err) {
+        for (const F of filters) {
+          const filter = resolveFromRegistry(F, instanceRegistry);
+          const catchTypes = Reflect.getMetadata(CATCH_METADATA, _nullishCoalesce(filter.constructor, () => ( F))) || [];
+          if (catchTypes.length === 0 || catchTypes.some((T) => err instanceof T)) {
+            const host = createArgumentsHost(c);
+            const res = await filter.catch(err, host);
+            if (res instanceof Response) return res;
+          }
+        }
+        throw err;
+      }
+    };
+    switch (route.method) {
+      case "GET":
+        router.get(fullPath, finalHandler);
+        break;
+      case "POST":
+        router.post(fullPath, finalHandler);
+        break;
+      case "PUT":
+        router.put(fullPath, finalHandler);
+        break;
+      case "DELETE":
+        router.delete(fullPath, finalHandler);
+        break;
+      case "PATCH":
+        router.patch(fullPath, finalHandler);
+        break;
+    }
+  }
+}
+
+// src/decorators/http/route-mapping.decorator.ts
+function createMethodDecorator(method) {
+  return (path = "") => (target, propertyKey, descriptor) => {
+    if (!target.constructor.prototype.routes) {
+      target.constructor.prototype.routes = [];
+    }
+    target.constructor.prototype.routes.push({
+      method,
+      path,
+      handler: propertyKey
+    });
+    return descriptor;
+  };
+}
+var Get = createMethodDecorator("GET");
+var Post = createMethodDecorator("POST");
+var Put = createMethodDecorator("PUT");
+var Delete = createMethodDecorator("DELETE");
+var Patch = createMethodDecorator("PATCH");
+
+// src/decorators/modules/module.decorator.ts
+
+function Module(config) {
+  return (target) => {
+    target.prototype.moduleConfig = config;
+    if (config.providers) {
+      config.providers.forEach((ProviderClass) => {
+        if (ProviderClass && typeof ProviderClass === "function") {
+          _tsyringe.injectable.call(void 0, )(ProviderClass);
+        }
+      });
+    }
+  };
+}
+
+// src/decorators/modules/global.decorator.ts
+var GLOBAL_MODULE_METADATA = "wilt:global";
+function Global() {
+  return (target) => {
+    Reflect.defineMetadata(GLOBAL_MODULE_METADATA, true, target);
+    return target;
+  };
+}
+
+// src/injector/module.factory.ts
+var _hono = require('hono');
+
+// src/injector/module-compiler.ts
+function collectModuleTree(moduleClass, visiting, visited, controllers, providers, globalProviders = []) {
+  if (visited.has(moduleClass)) return;
+  visiting.add(moduleClass);
+  const instance = new moduleClass();
+  const config = instance.moduleConfig || {};
+  const isGlobal = Reflect.getMetadata(GLOBAL_MODULE_METADATA, moduleClass) === true;
+  for (const c of _nullishCoalesce(config.controllers, () => ( []))) {
+    if (!controllers.includes(c)) controllers.push(c);
+  }
+  for (const p of _nullishCoalesce(config.providers, () => ( []))) {
+    if (!providers.includes(p)) providers.push(p);
+    if (isGlobal && !globalProviders.includes(p)) globalProviders.push(p);
+  }
+  for (const importRef of _nullishCoalesce(config.imports, () => ( []))) {
+    const isRef = isForwardRef(importRef);
+    const ImportedClass = isRef ? importRef.forwardRef() : importRef;
+    if (visiting.has(ImportedClass)) {
+      if (!isRef) {
+        throw new Error(
+          `[Wilt DI] Circular module dependency detected: "${moduleClass.name}" imports "${ImportedClass.name}" without forwardRef. Wrap it with forwardRef(() => ${ImportedClass.name}) in "${moduleClass.name}" imports array, and do the same in "${ImportedClass.name}".`
+        );
+      }
+      continue;
+    }
+    collectModuleTree(ImportedClass, visiting, visited, controllers, providers, globalProviders);
+  }
+  visiting.delete(moduleClass);
+  visited.add(moduleClass);
+}
+
+// src/injector/injector.ts
+function createCircularProxy(registry, tokenClass) {
+  return new Proxy(
+    {},
+    {
+      get(_target, prop) {
+        const instance = registry.get(tokenClass);
+        if (!instance) {
+          throw new Error(
+            `[Wilt DI] Circular dependency proxy for "${tokenClass.name}" was accessed before the real instance was created. Make sure both sides use @Inject(forwardRef(() => ...)).`
+          );
+        }
+        const val = instance[prop];
+        return typeof val === "function" ? val.bind(instance) : val;
+      },
+      set(_target, prop, value) {
+        const instance = registry.get(tokenClass);
+        if (instance) instance[prop] = value;
+        return true;
+      }
+    }
+  );
+}
+function resolveInstance(ProviderClass, instanceRegistry, inProgress) {
+  if (instanceRegistry.has(ProviderClass)) {
+    return instanceRegistry.get(ProviderClass);
+  }
+  if (inProgress.has(ProviderClass)) {
+    _chunkYUBEJL4Tcjs.logger.warn(
+      `Circular dependency detected for "${ProviderClass.name}". Injecting a lazy proxy \u2014 ensure forwardRef() is used on both sides.`,
+      "ModuleFactory"
+    );
+    return createCircularProxy(instanceRegistry, ProviderClass);
+  }
+  inProgress.add(ProviderClass);
+  const paramTypes = Reflect.getMetadata("design:paramtypes", ProviderClass) || [];
+  const customTokens = Reflect.getMetadata(INJECT_CUSTOM_TOKENS_KEY, ProviderClass) || {};
+  const optionalIndices = Reflect.getMetadata(OPTIONAL_METADATA, ProviderClass) || [];
+  const customIndices = Object.keys(customTokens).map(Number);
+  const paramCount = Math.max(
+    paramTypes.length,
+    customIndices.length > 0 ? Math.max(...customIndices) + 1 : 0
+  );
+  const deps = Array.from({ length: paramCount }, (_, i) => {
+    const customToken = customTokens[i];
+    const paramType = paramTypes[i];
+    const isOptional = optionalIndices.includes(i);
+    let actualClass;
+    if (customToken) {
+      actualClass = isForwardRef(customToken) ? customToken.forwardRef() : customToken;
+    } else {
+      actualClass = paramType;
+    }
+    if (!actualClass || actualClass === Object || actualClass === Function) {
+      if (!isOptional) {
+        _chunkYUBEJL4Tcjs.logger.warn(
+          `Cannot resolve param[${i}] for "${ProviderClass.name}": no type info. Use @Inject(TheClass) to specify it explicitly.`,
+          "ModuleFactory"
+        );
+      }
+      return void 0;
+    }
+    try {
+      return resolveInstance(actualClass, instanceRegistry, inProgress);
+    } catch (err) {
+      if (isOptional) return void 0;
+      throw err;
+    }
+  });
+  const instance = new ProviderClass(...deps);
+  instanceRegistry.set(ProviderClass, instance);
+  inProgress.delete(ProviderClass);
+  _chunkYUBEJL4Tcjs.logger.debug(`Created instance: ${ProviderClass.name}`, "ModuleFactory");
+  return instance;
+}
+
+// src/injector/module.factory.ts
+function createModule(moduleClass, { middlewares = [] } = {}) {
+  const router = new (0, _hono.Hono)();
+  _chunkYUBEJL4Tcjs.logger.info(`Creating module: ${moduleClass.name}`, "ModuleFactory");
+  middlewares.forEach((middleware) => router.use("*", middleware));
+  const controllers = [];
+  const providers = [];
+  const globalProviders = [];
+  collectModuleTree(moduleClass, /* @__PURE__ */ new Set(), /* @__PURE__ */ new Set(), controllers, providers, globalProviders);
+  _chunkYUBEJL4Tcjs.logger.info(
+    `Resolved ${providers.length} providers, ${controllers.length} controllers`,
+    "ModuleFactory"
+  );
+  const instanceRegistry = /* @__PURE__ */ new Map();
+  const inProgress = /* @__PURE__ */ new Set();
+  for (const ProviderClass of globalProviders) {
+    resolveInstance(ProviderClass, instanceRegistry, inProgress);
+  }
+  for (const ProviderClass of providers) {
+    resolveInstance(ProviderClass, instanceRegistry, inProgress);
+  }
+  for (const ControllerClass of controllers) {
+    try {
+      resolveInstance(ControllerClass, instanceRegistry, inProgress);
+      const controller = instanceRegistry.get(ControllerClass);
+      const prefix = controller.constructor.prototype.prefix || "";
+      registerControllerRoutes(router, controller, prefix, instanceRegistry);
+      _chunkYUBEJL4Tcjs.logger.debug(
+        `Registered controller: ${ControllerClass.name} at "${prefix}"`,
+        "ModuleFactory"
+      );
+    } catch (error) {
+      _chunkYUBEJL4Tcjs.logger.error(
+        `Failed to create controller "${ControllerClass.name}": ${error}`,
+        "ModuleFactory"
+      );
+      throw error;
+    }
+  }
+  for (const instance of instanceRegistry.values()) {
+    if (typeof _optionalChain([instance, 'optionalAccess', _5 => _5.onModuleInit]) === "function") {
+      const result = instance.onModuleInit();
+      if (result instanceof Promise) {
+        result.catch(
+          (err) => _chunkYUBEJL4Tcjs.logger.error(`onModuleInit failed for ${_optionalChain([instance, 'access', _6 => _6.constructor, 'optionalAccess', _7 => _7.name])}: ${err}`, "ModuleFactory")
+        );
+      }
+    }
+  }
+  _chunkYUBEJL4Tcjs.logger.info(`Module "${moduleClass.name}" created successfully`, "ModuleFactory");
+  return router;
+}
+
+// src/pipes/validate.pipe.ts
+function Validate(rules) {
+  return function(target, propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    descriptor.value = async function(...args) {
+      const c = _nullishCoalesce(args.find((a) => a != null && typeof a.json === "function" && a.req != null), () => ( args[0]));
+      const body = await c.req.json().catch(() => ({}));
+      const errors = [];
+      for (const rule of rules) {
+        const value = body[rule.field];
+        if (rule.required && (value === void 0 || value === null || value === "")) {
+          errors.push(`${rule.field} is required`);
+          continue;
+        }
+        if (value === void 0 || value === null) {
+          continue;
+        }
+        if (rule.type) {
+          const actualType = Array.isArray(value) ? "array" : typeof value;
+          if (actualType !== rule.type) {
+            errors.push(`${rule.field} must be of type ${rule.type}`);
+          }
+        }
+        if (rule.type === "string" || typeof value === "string") {
+          if (rule.minLength && value.length < rule.minLength) {
+            errors.push(`${rule.field} must be at least ${rule.minLength} characters long`);
+          }
+          if (rule.maxLength && value.length > rule.maxLength) {
+            errors.push(`${rule.field} must be at most ${rule.maxLength} characters long`);
+          }
+        }
+        if (rule.pattern && typeof value === "string" && !rule.pattern.test(value)) {
+          errors.push(`${rule.field} format is invalid`);
+        }
+        if (rule.custom && !rule.custom(value)) {
+          errors.push(`${rule.field} validation failed`);
+        }
+      }
+      if (errors.length > 0) {
+        return c.json(
+          {
+            success: false,
+            error: {
+              code: "VALIDATION_ERROR",
+              message: "Validation failed",
+              details: errors
+            },
+            timestamp: (/* @__PURE__ */ new Date()).toISOString()
+          },
+          400
+        );
+      }
+      return originalMethod.call(this, ...args);
+    };
+    return descriptor;
+  };
+}
+
+// src/pipes/zod-validate.pipe.ts
+var _zod = require('zod');
+function ZodValidate(schema) {
+  return function(target, propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    descriptor.value = async function(...args) {
+      const c = _nullishCoalesce(args.find((a) => a != null && typeof a.json === "function" && a.req != null), () => ( args[0]));
+      try {
+        const contentType = c.req.header("content-type") || "";
+        let input = {};
+        if (contentType.includes("multipart/form-data")) {
+          const formData = await c.req.formData();
+          formData.forEach((val, key) => {
+            input[key] = val;
+          });
+        } else {
+          input = await c.req.json().catch(() => ({}));
+        }
+        const validatedData = schema.parse(input);
+        c.set("validatedData", validatedData);
+        return originalMethod.call(this, ...args);
+      } catch (error) {
+        if (error instanceof _zod.z.ZodError) {
+          const errors = error.issues.map((err) => ({
+            field: err.path.join("."),
+            message: err.message,
+            code: err.code
+          }));
+          return c.json(
+            {
+              success: false,
+              error: { code: "VALIDATION_ERROR", message: "Validation failed", details: errors },
+              message: _nullishCoalesce(errors[0].message, () => ( "Validation failed")),
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            },
+            400
+          );
+        }
+        throw error;
+      }
+    };
+    return descriptor;
+  };
+}
+
+// src/pipes/zod-query.pipe.ts
+
+function QueryValidate(schema) {
+  return function(target, propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    descriptor.value = async function(...args) {
+      const c = _nullishCoalesce(args.find((a) => a != null && typeof a.json === "function" && a.req != null), () => ( args[0]));
+      try {
+        const queryParams = c.req.query();
+        const validatedData = schema.parse(queryParams);
+        c.set("validatedQuery", validatedData);
+        return originalMethod.call(this, ...args);
+      } catch (error) {
+        if (error instanceof _zod.z.ZodError) {
+          const errors = error.issues.map((err) => ({
+            field: err.path.join("."),
+            message: err.message,
+            code: err.code
+          }));
+          return c.json(
+            {
+              success: false,
+              error: {
+                code: "VALIDATION_ERROR",
+                message: "Query validation failed",
+                details: errors
+              },
+              message: _nullishCoalesce(errors[0].message, () => ( "Validation failed")),
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            },
+            400
+          );
+        }
+        throw error;
+      }
+    };
+    return descriptor;
+  };
+}
+
+// src/services/reflector.service.ts
+var Reflector = class {
+  get(metadataKey, target) {
+    return Reflect.getMetadata(metadataKey, target);
+  }
+  getAllAndOverride(metadataKey, targets) {
+    for (const target of targets) {
+      const value = Reflect.getMetadata(metadataKey, target);
+      if (value !== void 0) return value;
+    }
+    return void 0;
+  }
+  getAllAndMerge(metadataKey, targets) {
+    return targets.reduce((acc, target) => {
+      const value = Reflect.getMetadata(metadataKey, target);
+      if (Array.isArray(value)) return [...acc, ...value];
+      return acc;
+    }, []);
+  }
+};
+Reflector = exports.Reflector = _chunkZBDE64SDcjs.__decorateClass.call(void 0, [
+  Injectable()
+], Reflector);
+
+// src/utils/response.util.ts
+var _ResponseUtil = (_class = class __ResponseUtil {
+  
+  __init() {this.logger = console}
+  constructor() {;_class.prototype.__init.call(this);
+  }
+  // Prevent direct instantiation
+  static getInstance() {
+    if (!__ResponseUtil.instance) {
+      __ResponseUtil.instance = new __ResponseUtil();
+    }
+    return __ResponseUtil.instance;
+  }
+  success(c, data, message, status = 200) {
+    const response = {
+      success: true,
+      data,
+      message,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    return c.json(response, status);
+  }
+  error(c, message, status = 400) {
+    const response = {
+      success: false,
+      error: {
+        message
+      },
+      message,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    return c.json(response, status);
+  }
+  paginated(c, data, page, limit, total, message) {
+    const totalPages = _nullishCoalesce(Math.ceil(total / limit), () => ( 1));
+    const response = {
+      success: true,
+      data,
+      message,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      pagination: {
+        page,
+        limit,
+        total,
+        totalPages
+      }
+    };
+    return c.json(response);
+  }
+}, _class);
+var ResponseUtil = _ResponseUtil.getInstance();
+
+// src/utils/apply-decorators.util.ts
+function applyDecorators(...decorators) {
+  return (target, key, descriptor) => {
+    for (const decorator of decorators.reverse()) {
+      const result = decorator(target, key, descriptor);
+      if (result !== void 0) {
+        if (descriptor !== void 0) {
+          descriptor = result;
+        } else {
+          target = result;
+        }
+      }
+    }
+    return _nullishCoalesce(descriptor, () => ( target));
+  };
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+exports.BadRequestException = BadRequestException; exports.Body = Body; exports.CATCH_METADATA = CATCH_METADATA; exports.Catch = Catch; exports.ConflictException = ConflictException; exports.Controller = Controller; exports.Delete = Delete; exports.FILTERS_METADATA = FILTERS_METADATA; exports.ForbiddenException = ForbiddenException; exports.GLOBAL_MODULE_METADATA = GLOBAL_MODULE_METADATA; exports.GUARDS_METADATA = GUARDS_METADATA; exports.Get = Get; exports.Global = Global; exports.GoneException = GoneException; exports.HEADER_METADATA = HEADER_METADATA; exports.HTTP_CODE_METADATA = HTTP_CODE_METADATA; exports.Header = Header; exports.Headers = Headers; exports.HttpCode = HttpCode; exports.HttpException = _chunkYUBEJL4Tcjs.HttpException; exports.INJECT_CUSTOM_TOKENS_KEY = INJECT_CUSTOM_TOKENS_KEY; exports.INTERCEPTORS_METADATA = INTERCEPTORS_METADATA; exports.Inject = Inject; exports.Injectable = Injectable; exports.InternalServerErrorException = InternalServerErrorException; exports.Ip = Ip; exports.MethodNotAllowedException = MethodNotAllowedException; exports.Module = Module; exports.NotFoundException = NotFoundException; exports.NotImplementedException = NotImplementedException; exports.OPTIONAL_METADATA = OPTIONAL_METADATA; exports.Optional = Optional; exports.Param = Param; exports.Patch = Patch; exports.Post = Post; exports.Put = Put; exports.Query = Query; exports.QueryValidate = QueryValidate; exports.REDIRECT_METADATA = REDIRECT_METADATA; exports.ROUTE_PARAMS_METADATA = ROUTE_PARAMS_METADATA; exports.Redirect = Redirect; exports.Reflector = Reflector; exports.Req = Req; exports.Request = Req; exports.ResponseUtil = ResponseUtil; exports.ServiceUnavailableException = ServiceUnavailableException; exports.SetMetadata = SetMetadata; exports.TOTAL_PARAMS_METADATA = TOTAL_PARAMS_METADATA; exports.TooManyRequestsException = TooManyRequestsException; exports.UnauthorizedException = UnauthorizedException; exports.UnprocessableEntityException = UnprocessableEntityException; exports.UseFilters = UseFilters; exports.UseGuards = UseGuards; exports.UseInterceptors = UseInterceptors; exports.Validate = Validate; exports.ZodValidate = ZodValidate; exports._ResponseUtil = _ResponseUtil; exports.applyDecorators = applyDecorators; exports.createArgumentsHost = createArgumentsHost; exports.createExecutionContext = createExecutionContext; exports.createModule = createModule; exports.errorHandler = _chunkYUBEJL4Tcjs.errorHandler; exports.forwardRef = forwardRef; exports.isForwardRef = isForwardRef; exports.registerControllerRoutes = registerControllerRoutes; exports.requestLogger = _chunkYUBEJL4Tcjs.requestLogger;
+//# sourceMappingURL=index.cjs.map