@ajke/core 0.1.0

package/dist/index.js

@@ -0,0 +1,974 @@
+import {
+  HttpException,
+  errorHandler,
+  logger,
+  requestLogger
+} from "./chunk-AT2R2CGV.js";
+import {
+  __decorateClass
+} from "./chunk-EUXUH3YW.js";
+
+// src/decorators/core/injectable.decorator.ts
+import { injectable, inject as tsyringeInject } from "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) => {
+    injectable()(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 tsyringeInject(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 tsyringeInject(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
+import { injectable as injectable2 } from "tsyringe";
+
+// 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 HttpException {
+  constructor(message = "Bad Request") {
+    super(message, 400);
+    this.name = "BadRequestException";
+  }
+};
+var UnauthorizedException = class extends HttpException {
+  constructor(message = "Unauthorized") {
+    super(message, 401);
+    this.name = "UnauthorizedException";
+  }
+};
+var ForbiddenException = class extends HttpException {
+  constructor(message = "Forbidden") {
+    super(message, 403);
+    this.name = "ForbiddenException";
+  }
+};
+var NotFoundException = class extends HttpException {
+  constructor(message = "Not Found") {
+    super(message, 404);
+    this.name = "NotFoundException";
+  }
+};
+var MethodNotAllowedException = class extends HttpException {
+  constructor(message = "Method Not Allowed") {
+    super(message, 405);
+    this.name = "MethodNotAllowedException";
+  }
+};
+var ConflictException = class extends HttpException {
+  constructor(message = "Conflict") {
+    super(message, 409);
+    this.name = "ConflictException";
+  }
+};
+var GoneException = class extends HttpException {
+  constructor(message = "Gone") {
+    super(message, 410);
+    this.name = "GoneException";
+  }
+};
+var UnprocessableEntityException = class extends HttpException {
+  constructor(message = "Unprocessable Entity") {
+    super(message, 422);
+    this.name = "UnprocessableEntityException";
+  }
+};
+var TooManyRequestsException = class extends HttpException {
+  constructor(message = "Too Many Requests") {
+    super(message, 429);
+    this.name = "TooManyRequestsException";
+  }
+};
+var InternalServerErrorException = class extends HttpException {
+  constructor(message = "Internal Server Error") {
+    super(message, 500);
+    this.name = "InternalServerErrorException";
+  }
+};
+var NotImplementedException = class extends HttpException {
+  constructor(message = "Not Implemented") {
+    super(message, 501);
+    this.name = "NotImplementedException";
+  }
+};
+var ServiceUnavailableException = class extends HttpException {
+  constructor(message = "Service Unavailable") {
+    super(message, 503);
+    this.name = "ServiceUnavailableException";
+  }
+};
+
+// src/decorators/http/controller.decorator.ts
+function Controller(prefix = "") {
+  return (target) => {
+    injectable2()(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 (instanceRegistry?.has(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 ? body?.[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 = 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, httpCode ?? 200);
+          }
+          return new Response(null, { status: 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, 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
+import { injectable as injectable3 } from "tsyringe";
+function Module(config) {
+  return (target) => {
+    target.prototype.moduleConfig = config;
+    if (config.providers) {
+      config.providers.forEach((ProviderClass) => {
+        if (ProviderClass && typeof ProviderClass === "function") {
+          injectable3()(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
+import { Hono } from "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 config.controllers ?? []) {
+    if (!controllers.includes(c)) controllers.push(c);
+  }
+  for (const p of config.providers ?? []) {
+    if (!providers.includes(p)) providers.push(p);
+    if (isGlobal && !globalProviders.includes(p)) globalProviders.push(p);
+  }
+  for (const importRef of 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)) {
+    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) {
+        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);
+  logger.debug(`Created instance: ${ProviderClass.name}`, "ModuleFactory");
+  return instance;
+}
+
+// src/injector/module.factory.ts
+function createModule(moduleClass, { middlewares = [] } = {}) {
+  const router = new Hono();
+  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);
+  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);
+      logger.debug(
+        `Registered controller: ${ControllerClass.name} at "${prefix}"`,
+        "ModuleFactory"
+      );
+    } catch (error) {
+      logger.error(
+        `Failed to create controller "${ControllerClass.name}": ${error}`,
+        "ModuleFactory"
+      );
+      throw error;
+    }
+  }
+  for (const instance of instanceRegistry.values()) {
+    if (typeof instance?.onModuleInit === "function") {
+      const result = instance.onModuleInit();
+      if (result instanceof Promise) {
+        result.catch(
+          (err) => logger.error(`onModuleInit failed for ${instance.constructor?.name}: ${err}`, "ModuleFactory")
+        );
+      }
+    }
+  }
+  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 = 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
+import { z } from "zod";
+function ZodValidate(schema) {
+  return function(target, propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    descriptor.value = async function(...args) {
+      const c = 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 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: errors[0].message ?? "Validation failed",
+              timestamp: (/* @__PURE__ */ new Date()).toISOString()
+            },
+            400
+          );
+        }
+        throw error;
+      }
+    };
+    return descriptor;
+  };
+}
+
+// src/pipes/zod-query.pipe.ts
+import { z as z2 } from "zod";
+function QueryValidate(schema) {
+  return function(target, propertyKey, descriptor) {
+    const originalMethod = descriptor.value;
+    descriptor.value = async function(...args) {
+      const c = 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 z2.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: 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 = __decorateClass([
+  Injectable()
+], Reflector);
+
+// src/utils/response.util.ts
+var _ResponseUtil = class __ResponseUtil {
+  static instance;
+  logger = console;
+  constructor() {
+  }
+  // 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 = 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);
+  }
+};
+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 descriptor ?? target;
+  };
+}
+export {
+  BadRequestException,
+  Body,
+  CATCH_METADATA,
+  Catch,
+  ConflictException,
+  Controller,
+  Delete,
+  FILTERS_METADATA,
+  ForbiddenException,
+  GLOBAL_MODULE_METADATA,
+  GUARDS_METADATA,
+  Get,
+  Global,
+  GoneException,
+  HEADER_METADATA,
+  HTTP_CODE_METADATA,
+  Header,
+  Headers,
+  HttpCode,
+  HttpException,
+  INJECT_CUSTOM_TOKENS_KEY,
+  INTERCEPTORS_METADATA,
+  Inject,
+  Injectable,
+  InternalServerErrorException,
+  Ip,
+  MethodNotAllowedException,
+  Module,
+  NotFoundException,
+  NotImplementedException,
+  OPTIONAL_METADATA,
+  Optional,
+  Param,
+  Patch,
+  Post,
+  Put,
+  Query,
+  QueryValidate,
+  REDIRECT_METADATA,
+  ROUTE_PARAMS_METADATA,
+  Redirect,
+  Reflector,
+  Req,
+  Req as Request,
+  ResponseUtil,
+  ServiceUnavailableException,
+  SetMetadata,
+  TOTAL_PARAMS_METADATA,
+  TooManyRequestsException,
+  UnauthorizedException,
+  UnprocessableEntityException,
+  UseFilters,
+  UseGuards,
+  UseInterceptors,
+  Validate,
+  ZodValidate,
+  _ResponseUtil,
+  applyDecorators,
+  createArgumentsHost,
+  createExecutionContext,
+  createModule,
+  errorHandler,
+  forwardRef,
+  isForwardRef,
+  registerControllerRoutes,
+  requestLogger
+};
+//# sourceMappingURL=index.js.map