@catbee/utils 0.0.8-rc.4 → 1.0.2

package/build/index.cjs

@@ -11,6 +11,7 @@ var expressRateLimit = require('express-rate-limit');
 var os = require('os');
 var fsp = require('fs/promises');
 var promises = require('stream/promises');
+var stream = require('stream');
 var url = require('url');
 var express = require('express');
 var https = require('https');
@@ -1660,7 +1661,7 @@ function addSensitiveFields(fields) {
 __name(addSensitiveFields, "addSensitiveFields");
 var _globalThis = typeof globalThis === "object" ? globalThis : global;
 var _global = _globalThis;
-function setupLogger() {
+function setupLogger(isGlobal = true) {
   const logParams = {
     name: config.logger.name || "@catbee/utils",
     level: config.logger.level || "info",
@@ -1674,14 +1675,14 @@ function setupLogger() {
       ],
       censor: /* @__PURE__ */ __name((value, path3) => redact(value, path3), "censor")
     },
-    // serializers: {
-    //   req: pino.stdSerializers.req,
-    //   request: pino.stdSerializers.req,
-    //   res: pino.stdSerializers.res,
-    //   response: pino.stdSerializers.res,
-    //   err: pino.stdSerializers.err,
-    //   error: pino.stdSerializers.err
-    // },
+    serializers: {
+      req: pino__default.default.stdSerializers.req,
+      request: pino__default.default.stdSerializers.req,
+      res: pino__default.default.stdSerializers.res,
+      response: pino__default.default.stdSerializers.res,
+      err: pino__default.default.stdSerializers.err,
+      error: pino__default.default.stdSerializers.err
+    },
     timestamp: pino.stdTimeFunctions.isoTime
   };
   const logger2 = config.logger.pretty && Env.isDev() ? pino__default.default(logParams, pino__default.default.transport({
@@ -1694,11 +1695,17 @@ function setupLogger() {
       levelFirst: true
     }
   })) : pino__default.default(logParams);
-  _global[GLOBAL_LOGGER_KEY] = logger2;
-  _global[GLOBAL_LOGGER_KEY]?.debug("Logger initialized");
+  if (isGlobal) {
+    _global[GLOBAL_LOGGER_KEY] = logger2;
+    _global[GLOBAL_LOGGER_KEY]?.debug("Logger initialized");
+  }
+  return logger2;
 }
 __name(setupLogger, "setupLogger");
-function getLogger() {
+function getLogger(newInstance = false) {
+  if (newInstance) {
+    return setupLogger(false);
+  }
   const logger2 = ContextStore.get(StoreKeys.LOGGER);
   if (logger2) return logger2;
   if (!_global[GLOBAL_LOGGER_KEY]) {
@@ -1707,7 +1714,7 @@ function getLogger() {
   return _global[GLOBAL_LOGGER_KEY];
 }
 __name(getLogger, "getLogger");
-var logger = getLogger();
+var logger = getLogger(false);
 function createChildLogger(bindings, parentLogger) {
   const logger2 = parentLogger || getLogger();
   return logger2.child(bindings);
@@ -2498,6 +2505,234 @@ function verifySignedToken(token, secret) {
 }
 __name(verifySignedToken, "verifySignedToken");
 
+// src/utils/date.utils.ts
+function formatDate(date, options = {}) {
+  const { format = "yyyy-MM-dd", locale, timeZone } = options;
+  const d = date instanceof Date ? date : new Date(date);
+  if (format === "yyyy-MM-dd") {
+    const yyyy = d.getFullYear();
+    const mm = String(d.getMonth() + 1).padStart(2, "0");
+    const dd = String(d.getDate()).padStart(2, "0");
+    return `${yyyy}-${mm}-${dd}`;
+  }
+  if (format === "yyyy-MM-dd HH:mm:ss") {
+    const yyyy = d.getFullYear();
+    const mm = String(d.getMonth() + 1).padStart(2, "0");
+    const dd = String(d.getDate()).padStart(2, "0");
+    const HH = String(d.getHours()).padStart(2, "0");
+    const MM = String(d.getMinutes()).padStart(2, "0");
+    const SS = String(d.getSeconds()).padStart(2, "0");
+    return `${yyyy}-${mm}-${dd} ${HH}:${MM}:${SS}`;
+  }
+  if (format === "relative") {
+    return formatRelativeTime(date);
+  }
+  return new Intl.DateTimeFormat(locale, {
+    timeZone,
+    year: format.includes("yyyy") || format.includes("y") ? "numeric" : void 0,
+    month: format.includes("MM") || format.includes("M") ? "numeric" : void 0,
+    day: format.includes("dd") || format.includes("d") ? "numeric" : void 0,
+    hour: format.includes("HH") || format.includes("H") ? "numeric" : void 0,
+    minute: format.includes("mm") || format.includes("m") ? "numeric" : void 0,
+    second: format.includes("ss") || format.includes("s") ? "numeric" : void 0,
+    hour12: !format.includes("HH") && !format.includes("H")
+  }).format(d);
+}
+__name(formatDate, "formatDate");
+function formatRelativeTime(date, now = /* @__PURE__ */ new Date(), locale) {
+  const d1 = date instanceof Date ? date : new Date(date);
+  const d2 = now instanceof Date ? now : new Date(now);
+  const diffMs = d1.getTime() - d2.getTime();
+  const diffSecs = Math.round(diffMs / 1e3);
+  const diffMins = Math.round(diffSecs / 60);
+  const diffHours = Math.round(diffMins / 60);
+  const diffDays = Math.round(diffHours / 24);
+  const diffMonths = Math.round(diffDays / 30);
+  const diffYears = Math.round(diffDays / 365);
+  const formatter = new Intl.RelativeTimeFormat(locale, {
+    numeric: "auto"
+  });
+  if (Math.abs(diffSecs) < 60) return formatter.format(diffSecs, "second");
+  if (Math.abs(diffMins) < 60) return formatter.format(diffMins, "minute");
+  if (Math.abs(diffHours) < 24) return formatter.format(diffHours, "hour");
+  if (Math.abs(diffDays) < 30) return formatter.format(diffDays, "day");
+  if (Math.abs(diffMonths) < 12) return formatter.format(diffMonths, "month");
+  return formatter.format(diffYears, "year");
+}
+__name(formatRelativeTime, "formatRelativeTime");
+function parseDate(input, fallback) {
+  if (typeof input === "number") {
+    return new Date(input);
+  }
+  try {
+    const date = new Date(input);
+    if (isNaN(date.getTime())) {
+      return fallback || null;
+    }
+    return date;
+  } catch {
+    return fallback || null;
+  }
+}
+__name(parseDate, "parseDate");
+function dateDiff(date1, date2 = /* @__PURE__ */ new Date(), unit = "days") {
+  const d1 = date1 instanceof Date ? date1 : new Date(date1);
+  const d2 = date2 instanceof Date ? date2 : new Date(date2);
+  const diffMs = d1.getTime() - d2.getTime();
+  switch (unit) {
+    case "milliseconds":
+      return diffMs;
+    case "seconds":
+      return diffMs / 1e3;
+    case "minutes":
+      return diffMs / (1e3 * 60);
+    case "hours":
+      return diffMs / (1e3 * 60 * 60);
+    case "days":
+      return diffMs / (1e3 * 60 * 60 * 24);
+    case "months":
+      return (d1.getFullYear() - d2.getFullYear()) * 12 + d1.getMonth() - d2.getMonth();
+    case "years":
+      return d1.getFullYear() - d2.getFullYear();
+    default:
+      throw new Error(`Unsupported unit: ${unit}`);
+  }
+}
+__name(dateDiff, "dateDiff");
+function addToDate(date, amount, unit) {
+  const d = date instanceof Date ? new Date(date) : new Date(date);
+  switch (unit) {
+    case "milliseconds":
+      d.setMilliseconds(d.getMilliseconds() + amount);
+      break;
+    case "seconds":
+      d.setSeconds(d.getSeconds() + amount);
+      break;
+    case "minutes":
+      d.setMinutes(d.getMinutes() + amount);
+      break;
+    case "hours":
+      d.setHours(d.getHours() + amount);
+      break;
+    case "days":
+      d.setDate(d.getDate() + amount);
+      break;
+    case "months": {
+      const origDate = d.getDate();
+      const origMonth = d.getMonth();
+      d.setDate(1);
+      d.setMonth(origMonth + amount);
+      const lastDay = new Date(d.getFullYear(), d.getMonth() + 1, 0).getDate();
+      d.setDate(Math.min(origDate, lastDay));
+      break;
+    }
+    case "years":
+      d.setFullYear(d.getFullYear() + amount);
+      break;
+    default:
+      throw new Error(`Unsupported unit: ${unit}`);
+  }
+  return d;
+}
+__name(addToDate, "addToDate");
+function startOf(date, unit) {
+  const d = date instanceof Date ? new Date(date) : new Date(date);
+  switch (unit) {
+    case "second":
+      d.setMilliseconds(0);
+      break;
+    case "minute":
+      d.setSeconds(0, 0);
+      break;
+    case "hour":
+      d.setMinutes(0, 0, 0);
+      break;
+    case "day":
+      d.setHours(0, 0, 0, 0);
+      break;
+    case "week":
+      d.setHours(0, 0, 0, 0);
+      d.setDate(d.getDate() - d.getDay());
+      break;
+    case "month":
+      d.setDate(1);
+      d.setHours(0, 0, 0, 0);
+      break;
+    case "quarter":
+      d.setMonth(Math.floor(d.getMonth() / 3) * 3, 1);
+      d.setHours(0, 0, 0, 0);
+      break;
+    case "year":
+      d.setMonth(0, 1);
+      d.setHours(0, 0, 0, 0);
+      break;
+    default:
+      throw new Error(`Unsupported unit: ${unit}`);
+  }
+  return d;
+}
+__name(startOf, "startOf");
+function endOf(date, unit) {
+  const d = date instanceof Date ? new Date(date) : new Date(date);
+  switch (unit) {
+    case "second":
+      d.setMilliseconds(999);
+      break;
+    case "minute":
+      d.setSeconds(59, 999);
+      break;
+    case "hour":
+      d.setMinutes(59, 59, 999);
+      break;
+    case "day":
+      d.setHours(23, 59, 59, 999);
+      break;
+    case "week":
+      d.setDate(d.getDate() - d.getDay() + 6);
+      d.setHours(23, 59, 59, 999);
+      break;
+    case "month":
+      d.setMonth(d.getMonth() + 1, 0);
+      d.setHours(23, 59, 59, 999);
+      break;
+    case "quarter":
+      d.setMonth(Math.floor(d.getMonth() / 3) * 3 + 3, 0);
+      d.setHours(23, 59, 59, 999);
+      break;
+    case "year":
+      d.setMonth(11, 31);
+      d.setHours(23, 59, 59, 999);
+      break;
+    default:
+      throw new Error(`Unsupported unit: ${unit}`);
+  }
+  return d;
+}
+__name(endOf, "endOf");
+function isBetween(date, start, end, inclusive = true) {
+  const d = date instanceof Date ? date.getTime() : date;
+  const s = start instanceof Date ? start.getTime() : start;
+  const e = end instanceof Date ? end.getTime() : end;
+  return inclusive ? d >= s && d <= e : d > s && d < e;
+}
+__name(isBetween, "isBetween");
+function isLeapYear(year) {
+  const y = year instanceof Date ? year.getFullYear() : year;
+  return y % 4 === 0 && y % 100 !== 0 || y % 400 === 0;
+}
+__name(isLeapYear, "isLeapYear");
+function daysInMonth(year, month) {
+  if (year instanceof Date) {
+    month = year.getMonth();
+    year = year.getFullYear();
+  }
+  if (month === void 0) {
+    throw new Error("Month is required when year is a number");
+  }
+  return new Date(year, month + 1, 0).getDate();
+}
+__name(daysInMonth, "daysInMonth");
+
 // src/utils/response.utils.ts
 var SuccessResponse = class {
   static {
@@ -2751,1188 +2986,1500 @@ var HttpStatusCodes = /* @__PURE__ */ (function(HttpStatusCodes2) {
   HttpStatusCodes2[HttpStatusCodes2["NETWORK_AUTHENTICATION_REQUIRED"] = 511] = "NETWORK_AUTHENTICATION_REQUIRED";
   return HttpStatusCodes2;
 })({});
-var ROUTES_KEY = Symbol("routes");
-var MIDDLEWARE_KEY = Symbol("middlewares");
-var PARAMS_KEY = Symbol("params");
-var HTTP_CODE_KEY = Symbol("httpCode");
-var HEADER_KEY = Symbol("headers");
-var BEFORE_KEY = Symbol("before");
-var AFTER_KEY = Symbol("after");
-var ROLES_KEY = Symbol("roles");
-var REDIRECT_KEY = Symbol("redirect");
-var CACHE_KEY = Symbol("cache");
-var RATE_LIMIT_KEY = Symbol("rateLimit");
-var CONTENT_TYPE_KEY = Symbol("contentType");
-var VERSION_KEY = Symbol("version");
-var TIMEOUT_KEY = Symbol("timeout");
-var LOG_KEY = Symbol("log");
-var RateLimiterCache = class RateLimiterCache2 {
+
+// src/utils/exception.utils.ts
+var HttpError = class extends ErrorResponse {
   static {
-    __name(this, "RateLimiterCache");
+    __name(this, "HttpError");
   }
-  cache;
-  constructor(maxSize = 100, ttlMs = 5 * 60 * 1e3) {
-    this.cache = new TTLCache({
-      maxSize,
-      ttlMs
-    });
+  /**
+  * Creates a new HTTP error instance.
+  * @param status - A valid HTTP status code (e.g., 400, 500).
+  * @param message - The error message to return to the client.
+  */
+  constructor(status, message) {
+    super(message);
+    this.status = status;
   }
-  generateKey(options) {
-    return `${options.max}:${options.windowMs}:${options.standardHeaders}:${options.legacyHeaders}`;
+};
+var InternalServerErrorException = class extends ErrorResponse {
+  static {
+    __name(this, "InternalServerErrorException");
   }
-  get(options) {
-    const key = this.generateKey(options);
-    const cached = this.cache.get(key);
-    if (cached) {
-      return cached.limiter;
-    }
-    const limiter = expressRateLimit.rateLimit({
-      ...options,
-      handler: /* @__PURE__ */ __name((req, res) => {
-        const errorResponse = createFinalErrorResponse(req, HttpStatusCodes.TOO_MANY_REQUESTS, "Too Many Requests");
-        res.status(HttpStatusCodes.TOO_MANY_REQUESTS).json(errorResponse);
-      }, "handler")
-    });
-    this.cache.set(key, {
-      limiter,
-      config: key
-    });
-    return limiter;
+  /**
+  * @param message - Optional custom message. Defaults to "Internal server error".
+  */
+  constructor(message = "Internal server error") {
+    super(message);
+    this.status = HttpStatusCodes.INTERNAL_SERVER_ERROR;
   }
-  clear() {
-    this.cache.clear();
+};
+var UnauthorizedException = class extends ErrorResponse {
+  static {
+    __name(this, "UnauthorizedException");
   }
-  size() {
-    return this.cache.size();
+  /**
+  * @param message - Optional custom message. Defaults to "Unauthorized".
+  */
+  constructor(message = "Unauthorized") {
+    super(message);
+    this.status = HttpStatusCodes.UNAUTHORIZED;
   }
-  destroy() {
-    this.cache.destroy();
+};
+var BadRequestException = class extends ErrorResponse {
+  static {
+    __name(this, "BadRequestException");
+  }
+  /**
+  * @param message - Optional custom message. Defaults to "Bad request".
+  */
+  constructor(message = "Bad request") {
+    super(message);
+    this.status = HttpStatusCodes.BAD_REQUEST;
   }
 };
-var rateLimiterCache = new RateLimiterCache();
-var DIContainer = class {
+var NotFoundException = class extends ErrorResponse {
   static {
-    __name(this, "DIContainer");
+    __name(this, "NotFoundException");
   }
-  instances = /* @__PURE__ */ new Map();
-  constructing = /* @__PURE__ */ new Map();
-  register(target) {
-    if (!this.instances.has(target) && !this.constructing.has(target)) ;
+  /**
+  * @param message - Optional custom message. Defaults to "Resource not found".
+  */
+  constructor(message = "Resource not found") {
+    super(message);
+    this.status = HttpStatusCodes.NOT_FOUND;
   }
-  get(target) {
-    if (this.instances.has(target)) {
-      return this.instances.get(target);
-    }
-    if (this.constructing.has(target)) {
-      return this.constructing.get(target);
-    }
-    let proxy = {};
-    this.constructing.set(target, proxy);
-    const paramTypes = Reflect.getMetadata("design:paramtypes", target) || [];
-    const dependencies = paramTypes.map((dep) => this.get(dep));
-    const instance = new target(...dependencies);
-    Object.assign(proxy, instance);
-    this.instances.set(target, proxy);
-    this.constructing.delete(target);
-    Object.setPrototypeOf(proxy, target.prototype);
-    return proxy;
+};
+var ForbiddenException = class extends ErrorResponse {
+  static {
+    __name(this, "ForbiddenException");
   }
-  clear() {
-    this.instances.clear();
-    this.constructing.clear();
+  /**
+  * @param message - Optional custom message. Defaults to "Forbidden".
+  */
+  constructor(message = "Forbidden") {
+    super(message);
+    this.status = HttpStatusCodes.FORBIDDEN;
   }
 };
-var diContainer = new DIContainer();
-function normalizeHeaderValue(value) {
-  if (typeof value === "undefined") return void 0;
-  if (typeof value === "string") return value;
-  if (Array.isArray(value) && value.every((item) => typeof item === "string")) {
-    return value;
+var ConflictException = class extends ErrorResponse {
+  static {
+    __name(this, "ConflictException");
   }
-  return String(value);
-}
-__name(normalizeHeaderValue, "normalizeHeaderValue");
-function Injectable() {
-  return (target) => {
-    Reflect.defineMetadata("injectable", true, target);
-    diContainer.register(target);
-  };
-}
-__name(Injectable, "Injectable");
-function Inject(targetClass) {
-  return (target, propertyKey) => {
-    Object.defineProperty(target, propertyKey, {
-      get: /* @__PURE__ */ __name(function() {
-        return diContainer.get(targetClass);
-      }, "get"),
-      enumerable: true,
-      configurable: true
-    });
-  };
-}
-__name(Inject, "Inject");
-function createRouteDecorator(method) {
-  return (path3) => {
-    return (target, propertyKey, _descriptor) => {
-      const routes = Reflect.getMetadata(ROUTES_KEY, target.constructor) || [];
-      routes.push({
-        path: path3,
-        method,
-        handlerName: propertyKey
-      });
-      Reflect.defineMetadata(ROUTES_KEY, routes, target.constructor);
-    };
-  };
-}
-__name(createRouteDecorator, "createRouteDecorator");
-var Get = createRouteDecorator("get");
-var Post = createRouteDecorator("post");
-var Put = createRouteDecorator("put");
-var Patch = createRouteDecorator("patch");
-var Delete = createRouteDecorator("delete");
-var Options = createRouteDecorator("options");
-var Head = createRouteDecorator("head");
-var Trace = createRouteDecorator("trace");
-var Connect = createRouteDecorator("connect");
-function Controller(basePath) {
-  return (target) => {
-    Reflect.defineMetadata("basePath", basePath, target);
-  };
-}
-__name(Controller, "Controller");
-function Use(...middlewares) {
-  return (target, propertyKey, _descriptor) => {
-    const existing = Reflect.getMetadata(MIDDLEWARE_KEY, target, propertyKey) || [];
-    Reflect.defineMetadata(MIDDLEWARE_KEY, [
-      ...existing,
-      ...middlewares
-    ], target, propertyKey);
-  };
-}
-__name(Use, "Use");
-function createParamDecorator(type, key) {
-  return (paramKey) => {
-    return (target, propertyKey, parameterIndex) => {
-      const params = Reflect.getMetadata(PARAMS_KEY, target, propertyKey) || [];
-      params.push({
-        index: parameterIndex,
-        type,
-        key: paramKey || key
-      });
-      params.sort((a, b) => a.index - b.index);
-      Reflect.defineMetadata(PARAMS_KEY, params, target, propertyKey);
-    };
-  };
-}
-__name(createParamDecorator, "createParamDecorator");
-var Query = createParamDecorator("query");
-var Param = createParamDecorator("param");
-var Body = createParamDecorator("body");
-var Req = createParamDecorator("req");
-var Res = createParamDecorator("res");
-function HttpCode(status) {
-  return (target, propertyKey, _descriptor) => {
-    Reflect.defineMetadata(HTTP_CODE_KEY, status, target, propertyKey);
-  };
-}
-__name(HttpCode, "HttpCode");
-function Header(name, value) {
-  return Headers(name, value);
-}
-__name(Header, "Header");
-function Headers(headers, value) {
-  return (target, propertyKey) => {
-    if (typeof propertyKey === "undefined") {
-      const existing = Reflect.getMetadata(HEADER_KEY, target) || {};
-      const newHeaders = typeof headers === "string" ? {
-        [headers]: value
-      } : headers;
-      Reflect.defineMetadata(HEADER_KEY, {
-        ...existing,
-        ...newHeaders
-      }, target);
-    } else {
-      const existing = Reflect.getMetadata(HEADER_KEY, target, propertyKey) || {};
-      const newHeaders = typeof headers === "string" ? {
-        [headers]: value
-      } : headers;
-      Reflect.defineMetadata(HEADER_KEY, {
-        ...existing,
-        ...newHeaders
-      }, target, propertyKey);
-    }
-  };
+  /**
+  * @param message - Optional custom message. Defaults to "Conflict".
+  */
+  constructor(message = "Conflict") {
+    super(message);
+    this.status = HttpStatusCodes.CONFLICT;
+  }
+};
+var BadGatewayException = class extends ErrorResponse {
+  static {
+    __name(this, "BadGatewayException");
+  }
+  /**
+  * @param message - Optional custom message. Defaults to "Bad Gateway".
+  */
+  constructor(message = "Bad Gateway") {
+    super(message);
+    this.status = HttpStatusCodes.BAD_GATEWAY;
+  }
+};
+var TooManyRequestsException = class extends ErrorResponse {
+  static {
+    __name(this, "TooManyRequestsException");
+  }
+  /**
+  * @param message - Optional custom message. Defaults to "Too many requests".
+  */
+  constructor(message = "Too many requests") {
+    super(message);
+    this.status = HttpStatusCodes.TOO_MANY_REQUESTS;
+  }
+};
+var ServiceUnavailableException = class extends ErrorResponse {
+  static {
+    __name(this, "ServiceUnavailableException");
+  }
+  /**
+  * @param message - Optional custom message. Defaults to "Service Unavailable".
+  */
+  constructor(message = "Service Unavailable") {
+    super(message);
+    this.status = HttpStatusCodes.SERVICE_UNAVAILABLE;
+  }
+};
+var GatewayTimeoutException = class extends ErrorResponse {
+  static {
+    __name(this, "GatewayTimeoutException");
+  }
+  /**
+  * @param message - Optional custom message. Defaults to "Gateway Timeout".
+  */
+  constructor(message = "Gateway Timeout") {
+    super(message);
+    this.status = HttpStatusCodes.GATEWAY_TIMEOUT;
+  }
+};
+var UnprocessableEntityException = class extends ErrorResponse {
+  static {
+    __name(this, "UnprocessableEntityException");
+  }
+  details;
+  /**
+  * @param message - Optional custom message. Defaults to "Unprocessable Entity".
+  * @param details - Optional validation details or additional error context.
+  */
+  constructor(message = "Unprocessable Entity", details) {
+    super(message), this.details = details;
+    this.status = HttpStatusCodes.UNPROCESSABLE_ENTITY;
+  }
+};
+var MethodNotAllowedException = class extends ErrorResponse {
+  static {
+    __name(this, "MethodNotAllowedException");
+  }
+  allowedMethods;
+  /**
+  * @param message - Optional custom message. Defaults to "Method Not Allowed".
+  * @param allowedMethods - Optional array of allowed HTTP methods.
+  */
+  constructor(message = "Method Not Allowed", allowedMethods) {
+    super(message), this.allowedMethods = allowedMethods;
+    this.status = HttpStatusCodes.METHOD_NOT_ALLOWED;
+  }
+};
+var NotAcceptableException = class extends ErrorResponse {
+  static {
+    __name(this, "NotAcceptableException");
+  }
+  /**
+  * @param message - Optional custom message. Defaults to "Not Acceptable".
+  */
+  constructor(message = "Not Acceptable") {
+    super(message);
+    this.status = HttpStatusCodes.NOT_ACCEPTABLE;
+  }
+};
+var RequestTimeoutException = class extends ErrorResponse {
+  static {
+    __name(this, "RequestTimeoutException");
+  }
+  /**
+  * @param message - Optional custom message. Defaults to "Request Timeout".
+  */
+  constructor(message = "Request Timeout") {
+    super(message);
+    this.status = HttpStatusCodes.REQUEST_TIMEOUT;
+  }
+};
+var UnsupportedMediaTypeException = class extends ErrorResponse {
+  static {
+    __name(this, "UnsupportedMediaTypeException");
+  }
+  /**
+  * @param message - Optional custom message. Defaults to "Unsupported Media Type".
+  */
+  constructor(message = "Unsupported Media Type") {
+    super(message);
+    this.status = HttpStatusCodes.UNSUPPORTED_MEDIA_TYPE;
+  }
+};
+var PayloadTooLargeException = class extends ErrorResponse {
+  static {
+    __name(this, "PayloadTooLargeException");
+  }
+  /**
+  * @param message - Optional custom message. Defaults to "Payload Too Large".
+  */
+  constructor(message = "Payload Too Large") {
+    super(message);
+    this.status = HttpStatusCodes.PAYLOAD_TOO_LARGE;
+  }
+};
+var InsufficientStorageException = class extends ErrorResponse {
+  static {
+    __name(this, "InsufficientStorageException");
+  }
+  /**
+  * @param message - Optional custom message. Defaults to "Insufficient Storage".
+  */
+  constructor(message = "Insufficient Storage") {
+    super(message);
+    this.status = HttpStatusCodes.INSUFFICIENT_STORAGE;
+  }
+};
+function isHttpError(error) {
+  return error instanceof ErrorResponse;
 }
-__name(Headers, "Headers");
-function Before(fn) {
-  return (target, propertyKey, _descriptor) => {
-    const hooks = Reflect.getMetadata(BEFORE_KEY, target, propertyKey) || [];
-    hooks.push(fn);
-    Reflect.defineMetadata(BEFORE_KEY, hooks, target, propertyKey);
-  };
+__name(isHttpError, "isHttpError");
+function createHttpError(status, message) {
+  switch (status) {
+    case HttpStatusCodes.BAD_REQUEST:
+      return new BadRequestException(message);
+    case HttpStatusCodes.UNAUTHORIZED:
+      return new UnauthorizedException(message);
+    case HttpStatusCodes.FORBIDDEN:
+      return new ForbiddenException(message);
+    case HttpStatusCodes.NOT_FOUND:
+      return new NotFoundException(message);
+    case HttpStatusCodes.METHOD_NOT_ALLOWED:
+      return new MethodNotAllowedException(message);
+    case HttpStatusCodes.NOT_ACCEPTABLE:
+      return new NotAcceptableException(message);
+    case HttpStatusCodes.REQUEST_TIMEOUT:
+      return new RequestTimeoutException(message);
+    case HttpStatusCodes.CONFLICT:
+      return new ConflictException(message);
+    case HttpStatusCodes.GONE:
+      return new HttpError(HttpStatusCodes.GONE, message || "Gone");
+    case HttpStatusCodes.PAYLOAD_TOO_LARGE:
+      return new PayloadTooLargeException(message);
+    case HttpStatusCodes.UNSUPPORTED_MEDIA_TYPE:
+      return new UnsupportedMediaTypeException(message);
+    case HttpStatusCodes.UNPROCESSABLE_ENTITY:
+      return new UnprocessableEntityException(message);
+    case HttpStatusCodes.TOO_MANY_REQUESTS:
+      return new TooManyRequestsException(message);
+    case HttpStatusCodes.INTERNAL_SERVER_ERROR:
+      return new InternalServerErrorException(message);
+    case HttpStatusCodes.BAD_GATEWAY:
+      return new BadGatewayException(message);
+    case HttpStatusCodes.SERVICE_UNAVAILABLE:
+      return new ServiceUnavailableException(message);
+    case HttpStatusCodes.GATEWAY_TIMEOUT:
+      return new GatewayTimeoutException(message);
+    case HttpStatusCodes.INSUFFICIENT_STORAGE:
+      return new InsufficientStorageException(message);
+    default:
+      return new HttpError(status, message || `HTTP Error ${status}`);
+  }
 }
-__name(Before, "Before");
-function After(fn) {
-  return (target, propertyKey, _descriptor) => {
-    const hooks = Reflect.getMetadata(AFTER_KEY, target, propertyKey) || [];
-    hooks.push(fn);
-    Reflect.defineMetadata(AFTER_KEY, hooks, target, propertyKey);
-  };
+__name(createHttpError, "createHttpError");
+function hasErrorShape(error) {
+  return typeof error === "object" && error !== null && "message" in error && typeof error.message === "string";
 }
-__name(After, "After");
-function Roles(...roles) {
-  return (target, propertyKey, _descriptor) => {
-    if (typeof propertyKey === "undefined") {
-      Reflect.defineMetadata(ROLES_KEY, roles, target);
-    } else {
-      Reflect.defineMetadata(ROLES_KEY, roles, target, propertyKey);
+__name(hasErrorShape, "hasErrorShape");
+function getErrorMessage(error) {
+  if (typeof error === "string") {
+    return error;
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  if (hasErrorShape(error)) {
+    return error.message;
+  }
+  return "Unknown error occurred";
+}
+__name(getErrorMessage, "getErrorMessage");
+function withErrorHandling(handler) {
+  return async (...args) => {
+    try {
+      return await handler(...args);
+    } catch (err) {
+      if (isHttpError(err)) {
+        throw err;
+      }
+      getLogger().error({
+        err
+      }, "Caught error in handler");
+      let status = HttpStatusCodes.INTERNAL_SERVER_ERROR;
+      if (hasErrorShape(err) && typeof err.status === "number") {
+        status = err.status;
+      }
+      throw createHttpError(status, getErrorMessage(err));
     }
   };
 }
-__name(Roles, "Roles");
-function Redirect(url, statusCode = 302) {
-  return (target, propertyKey, descriptor) => {
-    Reflect.defineMetadata(REDIRECT_KEY, {
-      url,
-      statusCode
-    }, target, propertyKey);
-    return descriptor;
-  };
-}
-__name(Redirect, "Redirect");
-function Cache(ttlSeconds) {
-  return (target, propertyKey, _descriptor) => {
-    if (typeof propertyKey === "undefined") {
-      Reflect.defineMetadata(CACHE_KEY, {
-        ttlSeconds
-      }, target);
-    } else {
-      Reflect.defineMetadata(CACHE_KEY, {
-        ttlSeconds
-      }, target, propertyKey);
-    }
-  };
-}
-__name(Cache, "Cache");
-function RateLimit(options) {
-  const opts = {
-    standardHeaders: true,
-    legacyHeaders: false,
-    ...options
-  };
-  return (target, propertyKey, _descriptor) => {
-    if (typeof propertyKey === "undefined") {
-      Reflect.defineMetadata(RATE_LIMIT_KEY, opts, target);
-    } else {
-      Reflect.defineMetadata(RATE_LIMIT_KEY, opts, target, propertyKey);
-    }
-  };
-}
-__name(RateLimit, "RateLimit");
-function ContentType(type) {
-  return (target, propertyKey, _descriptor) => {
-    Reflect.defineMetadata(CONTENT_TYPE_KEY, {
-      type
-    }, target, propertyKey);
-  };
-}
-__name(ContentType, "ContentType");
-function Version(version, options) {
-  const opts = {
-    addPrefix: true,
-    addHeader: true,
-    headerName: "X-API-Version",
-    ...options
-  };
-  return (target, propertyKey, _descriptor) => {
-    if (typeof propertyKey === "undefined") {
-      Reflect.defineMetadata(VERSION_KEY, {
-        version,
-        options: opts
-      }, target);
-    } else {
-      Reflect.defineMetadata(VERSION_KEY, {
-        version,
-        options: opts
-      }, target, propertyKey);
-    }
-  };
-}
-__name(Version, "Version");
-function Timeout(ms) {
-  return (target, propertyKey, _descriptor) => {
-    if (typeof propertyKey === "undefined") {
-      Reflect.defineMetadata(TIMEOUT_KEY, {
-        ms
-      }, target);
-    } else {
-      Reflect.defineMetadata(TIMEOUT_KEY, {
-        ms
-      }, target, propertyKey);
-    }
-  };
-}
-__name(Timeout, "Timeout");
-function Log(options) {
-  return (target, propertyKey, _descriptor) => {
-    const config2 = {
-      logEntry: true,
-      logExit: true,
-      logBody: false,
-      logParams: false,
-      logResponse: false,
-      ...options
-    };
-    if (typeof propertyKey === "undefined") {
-      Reflect.defineMetadata(LOG_KEY, config2, target);
-    } else {
-      Reflect.defineMetadata(LOG_KEY, config2, target, propertyKey);
-    }
-  };
-}
-__name(Log, "Log");
-function registerControllers(router, controllers) {
-  controllers.forEach((ControllerClass) => {
-    const instance = diContainer.get(ControllerClass);
-    const basePath = Reflect.getMetadata("basePath", ControllerClass) || "";
-    const routes = Reflect.getMetadata(ROUTES_KEY, ControllerClass) || [];
-    const controllerRateLimit = Reflect.getMetadata(RATE_LIMIT_KEY, ControllerClass);
-    const controllerCache = Reflect.getMetadata(CACHE_KEY, ControllerClass);
-    const controllerTimeout = Reflect.getMetadata(TIMEOUT_KEY, ControllerClass);
-    const controllerVersion = Reflect.getMetadata(VERSION_KEY, ControllerClass);
-    const controllerRoles = Reflect.getMetadata(ROLES_KEY, ControllerClass);
-    const controllerLogConfig = Reflect.getMetadata(LOG_KEY, ControllerClass);
-    const controllerHeaders = Reflect.getMetadata(HEADER_KEY, ControllerClass) || {};
-    routes.forEach(({ path: path3, method, handlerName }) => {
-      const middlewares = Reflect.getMetadata(MIDDLEWARE_KEY, instance, handlerName) || [];
-      const params = Reflect.getMetadata(PARAMS_KEY, instance, handlerName) || [];
-      const httpCode = Reflect.getMetadata(HTTP_CODE_KEY, instance, handlerName);
-      const methodHeaders = Reflect.getMetadata(HEADER_KEY, instance, handlerName) || {};
-      const headers = {
-        ...controllerHeaders,
-        ...methodHeaders
-      };
-      const beforeHooks = Reflect.getMetadata(BEFORE_KEY, instance, handlerName) || [];
-      const afterHooks = Reflect.getMetadata(AFTER_KEY, instance, handlerName) || [];
-      const redirect = Reflect.getMetadata(REDIRECT_KEY, instance, handlerName);
-      const contentType = Reflect.getMetadata(CONTENT_TYPE_KEY, instance, handlerName);
-      const roles = Reflect.getMetadata(ROLES_KEY, instance, handlerName) || controllerRoles || [];
-      const cache = Reflect.getMetadata(CACHE_KEY, instance, handlerName) || controllerCache;
-      const rateLimitOptions = Reflect.getMetadata(RATE_LIMIT_KEY, instance, handlerName) || controllerRateLimit;
-      const version = Reflect.getMetadata(VERSION_KEY, instance, handlerName) || controllerVersion;
-      const timeout2 = Reflect.getMetadata(TIMEOUT_KEY, instance, handlerName) || controllerTimeout;
-      const logConfig = Reflect.getMetadata(LOG_KEY, instance, handlerName) || controllerLogConfig;
-      let rateLimiter = null;
-      if (rateLimitOptions) {
-        try {
-          rateLimiter = rateLimiterCache.get(rateLimitOptions);
-        } catch (err) {
-          getLogger().warn({
-            err
-          }, "express-rate-limit not available, skipping rate limiting for this route");
-        }
-      }
-      let finalPath = path3;
-      if (version?.options?.addPrefix) {
-        finalPath = `/${version.version}${path3}`;
-      }
-      const handler = /* @__PURE__ */ __name(async (req, res, next) => {
-        req["startTime"] = Date.now();
-        let timeoutId;
-        let timedOut = false;
-        try {
-          if (timeout2) {
-            timeoutId = setTimeout(() => {
-              if (!res.headersSent && !timedOut) {
-                timedOut = true;
-                const errorResponse = createFinalErrorResponse(req, HttpStatusCodes.REQUEST_TIMEOUT, "Request timed out");
-                res.status(HttpStatusCodes.REQUEST_TIMEOUT).json(errorResponse);
-              }
-            }, timeout2.ms);
-          }
-          if (timedOut) return;
-          if (rateLimiter) {
-            await new Promise((resolve2, reject) => {
-              rateLimiter(req, res, (err) => {
-                if (err) reject(err);
-                else resolve2();
-              });
-            });
-          }
-          if (!res.headersSent && contentType) {
-            res.setHeader("Content-Type", contentType.type);
-          }
-          if (version?.options?.addHeader && version?.options?.headerName && version?.version) {
-            if (!res.headersSent) {
-              res.setHeader(version.options.headerName, version.version);
-            }
-          }
-          if (cache && !res.headersSent) {
-            res.setHeader("Cache-Control", `public, max-age=${cache.ttlSeconds}`);
-          }
-          if (logConfig?.logEntry) {
-            const logger2 = getLogger();
-            const logData = {
-              method: req.method,
-              url: req.originalUrl || req.url,
-              userAgent: req.get("User-Agent")
-            };
-            if (logConfig.logParams) {
-              logData.params = req.params;
-              logData.query = req.query;
-            }
-            if (logConfig.logBody) logData.body = req.body;
-            logger2.info({
-              entry: logData
-            }, "Route Entry:");
-          }
-          if (roles.length && !req?.user?.roles?.some((role) => roles.includes(role))) {
-            const errorResponse = createFinalErrorResponse(req, HttpStatusCodes.FORBIDDEN, "Forbidden Insufficient Roles");
-            res.status(HttpStatusCodes.FORBIDDEN).json(errorResponse);
-            if (timeoutId) {
-              clearTimeout(timeoutId);
-            }
-            return;
-          }
-          if (redirect && redirect.url) {
-            if (timeoutId) {
-              clearTimeout(timeoutId);
-            }
-            return res.redirect(redirect.statusCode, redirect.url);
-          }
-          for (const fn of beforeHooks) await fn(req, res);
-          const args = [];
-          if (params.length) {
-            params.forEach(({ index, type, key }) => {
-              switch (type) {
-                case "query":
-                  args[index] = key ? req.query[key] : req.query;
-                  break;
-                case "param":
-                  args[index] = key ? req.params[key] : req.params;
-                  break;
-                case "body":
-                  args[index] = key ? req.body?.[key] : req.body;
-                  break;
-                case "req":
-                  args[index] = req;
-                  break;
-                case "res":
-                  args[index] = res;
-                  break;
-              }
-            });
-          }
-          const result = instance[handlerName](...args);
-          const awaited = result instanceof Promise ? await result : result;
-          if (timeoutId) {
-            clearTimeout(timeoutId);
-          }
-          if (timedOut) return;
-          if (redirect && awaited && typeof awaited === "object" && "url" in awaited) {
-            const redirectUrl = awaited.url;
-            const redirectStatus = awaited.statusCode || redirect.statusCode;
-            return res.redirect(redirectStatus, redirectUrl);
-          }
-          if (!res.headersSent && typeof awaited !== "undefined") {
-            if (httpCode) res.status(httpCode);
-            for (const [k, v] of Object.entries(headers)) {
-              const normalized = normalizeHeaderValue(v);
-              if (typeof normalized !== "undefined") {
-                res.set(k, normalized);
-              }
-            }
-            res.json(awaited);
-          }
-          if (logConfig?.logExit) {
-            const logger2 = getLogger();
-            const logData = {
-              method: req.method,
-              url: req.originalUrl || req.url,
-              statusCode: res.statusCode,
-              duration: `${Date.now() - req.startTime}ms`
-            };
-            if (logConfig.logResponse) logData.response = awaited;
-            logger2.info({
-              exit: logData
-            }, "Route Exit:");
-          }
-          for (const fn of afterHooks) await fn(req, res, awaited);
-        } catch (err) {
-          if (timeoutId) {
-            clearTimeout(timeoutId);
-          }
-          next(err);
-        }
-      }, "handler");
-      router[method](basePath + finalPath, ...middlewares, handler);
+__name(withErrorHandling, "withErrorHandling");
+
+// src/utils/decorators.utils.ts
+var ROUTES_KEY = Symbol("routes");
+var MIDDLEWARE_KEY = Symbol("middlewares");
+var PARAMS_KEY = Symbol("params");
+var HTTP_CODE_KEY = Symbol("httpCode");
+var HEADER_KEY = Symbol("headers");
+var BEFORE_KEY = Symbol("before");
+var AFTER_KEY = Symbol("after");
+var ROLES_KEY = Symbol("roles");
+var REDIRECT_KEY = Symbol("redirect");
+var CACHE_KEY = Symbol("cache");
+var RATE_LIMIT_KEY = Symbol("rateLimit");
+var CONTENT_TYPE_KEY = Symbol("contentType");
+var VERSION_KEY = Symbol("version");
+var TIMEOUT_KEY = Symbol("timeout");
+var LOG_KEY = Symbol("log");
+var RateLimiterCache = class RateLimiterCache2 {
+  static {
+    __name(this, "RateLimiterCache");
+  }
+  cache;
+  constructor(maxSize = 100, ttlMs = 5 * 60 * 1e3) {
+    this.cache = new TTLCache({
+      maxSize,
+      ttlMs
+    });
+  }
+  generateKey(options) {
+    return `${options.max}:${options.windowMs}:${options.standardHeaders}:${options.legacyHeaders}`;
+  }
+  get(options) {
+    const key = this.generateKey(options);
+    const cached = this.cache.get(key);
+    if (cached) {
+      return cached.limiter;
+    }
+    const limiter = expressRateLimit.rateLimit({
+      ...options,
+      handler: /* @__PURE__ */ __name((req, res) => {
+        const errorResponse = createFinalErrorResponse(req, HttpStatusCodes.TOO_MANY_REQUESTS, "Too Many Requests");
+        res.status(HttpStatusCodes.TOO_MANY_REQUESTS).json(errorResponse);
+      }, "handler")
     });
-  });
-}
-__name(registerControllers, "registerControllers");
-async function ensureDir(dirPath) {
-  await fsp__default.default.mkdir(dirPath, {
-    recursive: true
-  });
-}
-__name(ensureDir, "ensureDir");
-async function listFiles(dirPath, recursive = false) {
-  const entries = await fsp__default.default.readdir(dirPath, {
-    withFileTypes: true
-  });
-  const files = [];
-  for (const entry of entries) {
-    const fullPath = path__default.default.join(dirPath, entry.name);
-    if (entry.isFile()) {
-      files.push(fullPath);
-    } else if (recursive && entry.isDirectory()) {
-      const nestedFiles = await listFiles(fullPath, true);
-      files.push(...nestedFiles);
+    this.cache.set(key, {
+      limiter,
+      config: key
+    });
+    return limiter;
+  }
+  clear() {
+    this.cache.clear();
+  }
+  size() {
+    return this.cache.size();
+  }
+  destroy() {
+    this.cache.destroy();
+  }
+};
+var rateLimiterCache = new RateLimiterCache();
+var DIContainer = class {
+  static {
+    __name(this, "DIContainer");
+  }
+  instances = /* @__PURE__ */ new Map();
+  constructing = /* @__PURE__ */ new Map();
+  propertyInjections = /* @__PURE__ */ new Map();
+  register(target) {
+    if (!this.instances.has(target) && !this.constructing.has(target)) ;
+  }
+  /**
+  * Register a property injection to be resolved when the target class is instantiated
+  */
+  registerPropertyInjection(target, propertyKey, injectClass) {
+    const targetClass = target.constructor;
+    if (!this.propertyInjections.has(targetClass)) {
+      this.propertyInjections.set(targetClass, []);
     }
+    this.propertyInjections.get(targetClass).push({
+      targetClass: injectClass,
+      propertyKey
+    });
   }
-  return files;
-}
-__name(listFiles, "listFiles");
-async function deleteDirRecursive(dirPath) {
-  await fsp__default.default.rm(dirPath, {
-    recursive: true,
-    force: true
-  });
-}
-__name(deleteDirRecursive, "deleteDirRecursive");
-async function isDirectory(pathStr) {
-  try {
-    const stat = await fsp__default.default.stat(pathStr);
-    return stat.isDirectory();
-  } catch {
-    return false;
+  get(target) {
+    if (this.instances.has(target)) {
+      return this.instances.get(target);
+    }
+    if (this.constructing.has(target)) {
+      return this.constructing.get(target);
+    }
+    let proxy = {};
+    this.constructing.set(target, proxy);
+    const paramTypes = Reflect.getMetadata("design:paramtypes", target) || [];
+    const dependencies = paramTypes.map((dep) => this.get(dep));
+    const instance = new target(...dependencies);
+    this.applyPropertyInjections(target, instance);
+    Object.assign(proxy, instance);
+    this.instances.set(target, proxy);
+    this.constructing.delete(target);
+    Object.setPrototypeOf(proxy, target.prototype);
+    return proxy;
   }
-}
-__name(isDirectory, "isDirectory");
-async function copyDir(src, dest) {
-  await ensureDir(dest);
-  const entries = await fsp__default.default.readdir(src, {
-    withFileTypes: true
-  });
-  for (const entry of entries) {
-    const srcPath = path__default.default.join(src, entry.name);
-    const destPath = path__default.default.join(dest, entry.name);
-    if (entry.isDirectory()) {
-      await copyDir(srcPath, destPath);
-    } else {
-      await fsp__default.default.copyFile(srcPath, destPath);
+  applyPropertyInjections(targetClass, instance) {
+    const injections = this.propertyInjections.get(targetClass) || [];
+    for (const injection of injections) {
+      const dependency = this.get(injection.targetClass);
+      instance[injection.propertyKey] = dependency;
     }
   }
+  clear() {
+    this.instances.clear();
+    this.constructing.clear();
+    this.propertyInjections.clear();
+  }
+};
+var diContainer = new DIContainer();
+function normalizeHeaderValue(value) {
+  if (typeof value === "undefined") return void 0;
+  if (typeof value === "string") return value;
+  if (Array.isArray(value) && value.every((item) => typeof item === "string")) {
+    return value;
+  }
+  return String(value);
 }
-__name(copyDir, "copyDir");
-async function moveDir(src, dest) {
-  await copyDir(src, dest);
-  await deleteDirRecursive(src);
+__name(normalizeHeaderValue, "normalizeHeaderValue");
+function Injectable() {
+  return (target) => {
+    Reflect.defineMetadata("injectable", true, target);
+    diContainer.register(target);
+  };
 }
-__name(moveDir, "moveDir");
-async function emptyDir(dirPath) {
-  const entries = await fsp__default.default.readdir(dirPath, {
-    withFileTypes: true
-  });
-  for (const entry of entries) {
-    const entryPath = path__default.default.join(dirPath, entry.name);
-    if (entry.isDirectory()) {
-      await fsp__default.default.rm(entryPath, {
-        recursive: true,
-        force: true
+__name(Injectable, "Injectable");
+function Inject(targetClass) {
+  return (target, propertyKey) => {
+    diContainer.registerPropertyInjection(target, propertyKey, targetClass);
+    Object.defineProperty(target, propertyKey, {
+      configurable: true,
+      get: /* @__PURE__ */ __name(function() {
+        const value = Object.getOwnPropertyDescriptor(this, propertyKey)?.value;
+        if (value !== void 0) return value;
+        const injectedValue = diContainer.get(targetClass);
+        Object.defineProperty(this, propertyKey, {
+          value: injectedValue,
+          writable: true,
+          configurable: true
+        });
+        return injectedValue;
+      }, "get"),
+      set: /* @__PURE__ */ __name(function(value) {
+        Object.defineProperty(this, propertyKey, {
+          value,
+          writable: true,
+          configurable: true
+        });
+      }, "set")
+    });
+  };
+}
+__name(Inject, "Inject");
+function inject(targetClass) {
+  return diContainer.get(targetClass);
+}
+__name(inject, "inject");
+function createRouteDecorator(method) {
+  return (path3) => {
+    return (target, propertyKey, _descriptor) => {
+      const routes = Reflect.getMetadata(ROUTES_KEY, target.constructor) || [];
+      routes.push({
+        path: path3,
+        method,
+        handlerName: propertyKey
       });
-    } else {
-      await fsp__default.default.unlink(entryPath);
-    }
-  }
+      Reflect.defineMetadata(ROUTES_KEY, routes, target.constructor);
+    };
+  };
 }
-__name(emptyDir, "emptyDir");
-async function getDirSize(dirPath) {
-  let total = 0;
-  const entries = await fsp__default.default.readdir(dirPath, {
-    withFileTypes: true
-  });
-  for (const entry of entries) {
-    const entryPath = path__default.default.join(dirPath, entry.name);
-    if (entry.isDirectory()) {
-      total += await getDirSize(entryPath);
+__name(createRouteDecorator, "createRouteDecorator");
+var Get = createRouteDecorator("get");
+var Post = createRouteDecorator("post");
+var Put = createRouteDecorator("put");
+var Patch = createRouteDecorator("patch");
+var Delete = createRouteDecorator("delete");
+var Options = createRouteDecorator("options");
+var Head = createRouteDecorator("head");
+var Trace = createRouteDecorator("trace");
+var Connect = createRouteDecorator("connect");
+function Controller(basePath) {
+  return (target) => {
+    Reflect.defineMetadata("basePath", basePath, target);
+  };
+}
+__name(Controller, "Controller");
+function Use(...middlewares) {
+  return (target, propertyKey, _descriptor) => {
+    if (typeof propertyKey === "undefined") {
+      const existing = Reflect.getMetadata(MIDDLEWARE_KEY, target) || [];
+      Reflect.defineMetadata(MIDDLEWARE_KEY, [
+        ...existing,
+        ...middlewares
+      ], target);
     } else {
-      const stat = await fsp__default.default.stat(entryPath);
-      total += stat.size;
+      const existing = Reflect.getMetadata(MIDDLEWARE_KEY, target, propertyKey) || [];
+      Reflect.defineMetadata(MIDDLEWARE_KEY, [
+        ...existing,
+        ...middlewares
+      ], target, propertyKey);
     }
-  }
-  return total;
+  };
 }
-__name(getDirSize, "getDirSize");
-function watchDir(dirPath, callback) {
-  const watcher = fs__default.default.watch(dirPath, (eventType, filename) => {
-    callback(eventType, filename);
+__name(Use, "Use");
+function defineParamMetadata(target, propertyKey, parameterIndex, type, key) {
+  const params = Reflect.getMetadata(PARAMS_KEY, target, propertyKey) || [];
+  params.push({
+    index: parameterIndex,
+    type,
+    key
   });
-  return () => watcher.close();
+  params.sort((a, b) => a.index - b.index);
+  Reflect.defineMetadata(PARAMS_KEY, params, target, propertyKey);
 }
-__name(watchDir, "watchDir");
-async function findFilesByPattern(pattern, options = {}) {
-  const matchPattern = /* @__PURE__ */ __name((name, pattern2) => {
-    let escaped = pattern2.replaceAll(/[.+^${}()|[\]\\]/g, "\\$&");
-    escaped = escaped.replaceAll("*", ".*").replaceAll("?", ".");
-    const regex = new RegExp(`^${escaped}$`);
-    return regex.test(name);
-  }, "matchPattern");
-  const { cwd = process.cwd(), dot = false } = options;
-  const segments = pattern.split("/");
-  async function walk(dir, segIndex) {
-    if (segIndex >= segments.length) return [];
-    const segment = segments[segIndex];
-    const entries = await fs__default.default.promises.readdir(dir, {
-      withFileTypes: true
-    });
-    let matchedFiles = [];
-    for (const entry of entries) {
-      const entryName = entry.name;
-      if (!dot && entryName.startsWith(".")) continue;
-      const fullPath = path__default.default.join(dir, entryName);
-      const isLastSegment = segIndex === segments.length - 1;
-      if (isLastSegment) {
-        if (matchPattern(entryName, segment) && entry.isFile()) {
-          matchedFiles.push(fullPath);
-        }
-      } else if (entry.isDirectory()) {
-        if (matchPattern(entryName, segment)) {
-          matchedFiles.push(...await walk(fullPath, segIndex + 1));
-        }
+__name(defineParamMetadata, "defineParamMetadata");
+function createParamDecorator(type, key) {
+  return (paramKey) => {
+    return (target, propertyKey, parameterIndex) => {
+      defineParamMetadata(target, propertyKey, parameterIndex, type, paramKey ?? key);
+    };
+  };
+}
+__name(createParamDecorator, "createParamDecorator");
+function createParamDecoratorWithoutParam(type) {
+  return () => {
+    return (target, propertyKey, parameterIndex) => {
+      defineParamMetadata(target, propertyKey, parameterIndex, type, void 0);
+    };
+  };
+}
+__name(createParamDecoratorWithoutParam, "createParamDecoratorWithoutParam");
+function createApiUrlParamDecorator(type, key) {
+  return (paramKey, options) => {
+    return (target, propertyKey, parameterIndex) => {
+      const params = Reflect.getMetadata(PARAMS_KEY, target, propertyKey) || [];
+      let paramOptions = void 0;
+      if (typeof options === "object") {
+        paramOptions = {};
+        paramOptions.type = "string";
+        paramOptions.dataType = "single";
+        paramOptions.delimiter = ",";
+        paramOptions.required = false;
+        paramOptions.throwError = true;
+        paramOptions = {
+          ...paramOptions,
+          ...options
+        };
       }
-    }
-    return matchedFiles;
-  }
-  __name(walk, "walk");
-  return walk(cwd, 0);
+      params.push({
+        index: parameterIndex,
+        type,
+        key: paramKey || key,
+        options: paramOptions
+      });
+      params.sort((a, b) => a.index - b.index);
+      Reflect.defineMetadata(PARAMS_KEY, params, target, propertyKey);
+    };
+  };
 }
-__name(findFilesByPattern, "findFilesByPattern");
-async function getSubdirectories(dirPath, recursive = false) {
-  const entries = await fsp__default.default.readdir(dirPath, {
-    withFileTypes: true
-  });
-  const dirs = entries.filter((entry) => entry.isDirectory()).map((entry) => path__default.default.join(dirPath, entry.name));
-  if (recursive && dirs.length > 0) {
-    const nestedDirs = await Promise.all(dirs.map((dir) => getSubdirectories(dir, true)));
-    return [
-      ...dirs,
-      ...nestedDirs.flat()
-    ];
-  }
-  return dirs;
+__name(createApiUrlParamDecorator, "createApiUrlParamDecorator");
+var Query = createApiUrlParamDecorator("query");
+var Param = createApiUrlParamDecorator("param");
+var Body = createParamDecorator("body");
+var ReqLogger = createParamDecoratorWithoutParam("logger");
+var ReqId = createParamDecoratorWithoutParam("reqId");
+var ReqHeader = createParamDecorator("reqHeader");
+var ReqCookie = createParamDecorator("cookie");
+var Req = createParamDecoratorWithoutParam("req");
+var Res = createParamDecoratorWithoutParam("res");
+function HttpCode(status) {
+  return (target, propertyKey, _descriptor) => {
+    Reflect.defineMetadata(HTTP_CODE_KEY, status, target, propertyKey);
+  };
 }
-__name(getSubdirectories, "getSubdirectories");
-async function ensureEmptyDir(dirPath) {
-  if (await isDirectory(dirPath)) {
-    await emptyDir(dirPath);
-  } else {
-    try {
-      await fsp__default.default.unlink(dirPath);
-    } catch (error) {
-      if (error.code !== "ENOENT") {
-        throw error;
-      }
+__name(HttpCode, "HttpCode");
+function Header(name, value) {
+  return Headers(name, value);
+}
+__name(Header, "Header");
+function Headers(headers, value) {
+  return (target, propertyKey) => {
+    if (typeof propertyKey === "undefined") {
+      const existing = Reflect.getMetadata(HEADER_KEY, target) || {};
+      const newHeaders = typeof headers === "string" ? {
+        [headers]: value
+      } : headers;
+      Reflect.defineMetadata(HEADER_KEY, {
+        ...existing,
+        ...newHeaders
+      }, target);
+    } else {
+      const existing = Reflect.getMetadata(HEADER_KEY, target, propertyKey) || {};
+      const newHeaders = typeof headers === "string" ? {
+        [headers]: value
+      } : headers;
+      Reflect.defineMetadata(HEADER_KEY, {
+        ...existing,
+        ...newHeaders
+      }, target, propertyKey);
     }
-    await ensureDir(dirPath);
-  }
+  };
 }
-__name(ensureEmptyDir, "ensureEmptyDir");
-async function createTempDir(options = {}) {
-  const prefix = options.prefix || "tmp-";
-  const parentDir = options.parentDir || os__default.default.tmpdir();
-  const dirName = `${prefix}${crypto.randomBytes(6).toString("hex")}`;
-  const tempDirPath = path__default.default.join(parentDir, dirName);
-  await ensureDir(tempDirPath);
-  const cleanup = /* @__PURE__ */ __name(async () => {
-    try {
-      await deleteDirRecursive(tempDirPath);
-    } catch {
+__name(Headers, "Headers");
+function Before(fn) {
+  return (target, propertyKey, _descriptor) => {
+    if (typeof propertyKey === "undefined") {
+      const hooks = Reflect.getMetadata(BEFORE_KEY, target) || [];
+      hooks.push(fn);
+      Reflect.defineMetadata(BEFORE_KEY, hooks, target);
+    } else {
+      const hooks = Reflect.getMetadata(BEFORE_KEY, target, propertyKey) || [];
+      hooks.push(fn);
+      Reflect.defineMetadata(BEFORE_KEY, hooks, target, propertyKey);
     }
-  }, "cleanup");
-  if (options.cleanup) {
-    process.once("exit", () => {
-      try {
-        fs__default.default.rmSync(tempDirPath, {
-          recursive: true,
-          force: true
-        });
-      } catch {
-      }
-    });
-    const signals = [
-      "SIGINT",
-      "SIGTERM",
-      "SIGUSR1",
-      "SIGUSR2"
-    ];
-    for (const signal of signals) {
-      process.once(signal, () => {
-        cleanup().then(() => process.exit());
-      });
+  };
+}
+__name(Before, "Before");
+function After(fn) {
+  return (target, propertyKey, _descriptor) => {
+    if (typeof propertyKey === "undefined") {
+      const hooks = Reflect.getMetadata(AFTER_KEY, target) || [];
+      hooks.push(fn);
+      Reflect.defineMetadata(AFTER_KEY, hooks, target);
+    } else {
+      const hooks = Reflect.getMetadata(AFTER_KEY, target, propertyKey) || [];
+      hooks.push(fn);
+      Reflect.defineMetadata(AFTER_KEY, hooks, target, propertyKey);
     }
-  }
-  return {
-    path: tempDirPath,
-    cleanup
   };
 }
-__name(createTempDir, "createTempDir");
-async function findNewestFile(dirPath, recursive = false) {
-  const files = await listFiles(dirPath, recursive);
-  if (files.length === 0) return null;
-  const stats = await Promise.all(files.map(async (file) => ({
-    path: file,
-    mtime: (await fsp__default.default.stat(file)).mtime
-  })));
-  return stats.sort((a, b) => b.mtime.getTime() - a.mtime.getTime())[0].path;
+__name(After, "After");
+function Roles(...roles) {
+  return (target, propertyKey, _descriptor) => {
+    if (typeof propertyKey === "undefined") {
+      Reflect.defineMetadata(ROLES_KEY, roles, target);
+    } else {
+      Reflect.defineMetadata(ROLES_KEY, roles, target, propertyKey);
+    }
+  };
 }
-__name(findNewestFile, "findNewestFile");
-async function findOldestFile(dirPath, recursive = false) {
-  const files = await listFiles(dirPath, recursive);
-  if (files.length === 0) return null;
-  const stats = await Promise.all(files.map(async (file) => ({
-    path: file,
-    mtime: (await fsp__default.default.stat(file)).mtime
-  })));
-  return stats.sort((a, b) => a.mtime.getTime() - b.mtime.getTime())[0].path;
+__name(Roles, "Roles");
+function Redirect(url, statusCode = 302) {
+  return (target, propertyKey, descriptor) => {
+    Reflect.defineMetadata(REDIRECT_KEY, {
+      url,
+      statusCode
+    }, target, propertyKey);
+    return descriptor;
+  };
 }
-__name(findOldestFile, "findOldestFile");
-async function findInDir(dirPath, predicate, recursive = false) {
-  const entries = await fsp__default.default.readdir(dirPath, {
-    withFileTypes: true
-  });
-  const results = [];
-  for (const entry of entries) {
-    const entryPath = path__default.default.join(dirPath, entry.name);
-    const stat = await fsp__default.default.stat(entryPath);
-    if (await predicate(entryPath, stat)) {
-      results.push(entryPath);
+__name(Redirect, "Redirect");
+function Cache(ttlSeconds) {
+  return (target, propertyKey, _descriptor) => {
+    if (typeof propertyKey === "undefined") {
+      Reflect.defineMetadata(CACHE_KEY, {
+        ttlSeconds
+      }, target);
+    } else {
+      Reflect.defineMetadata(CACHE_KEY, {
+        ttlSeconds
+      }, target, propertyKey);
     }
-    if (recursive && entry.isDirectory()) {
-      const nestedResults = await findInDir(entryPath, predicate, true);
-      results.push(...nestedResults);
+  };
+}
+__name(Cache, "Cache");
+function RateLimit(options) {
+  const opts = {
+    standardHeaders: true,
+    legacyHeaders: false,
+    ...options
+  };
+  return (target, propertyKey, _descriptor) => {
+    if (typeof propertyKey === "undefined") {
+      Reflect.defineMetadata(RATE_LIMIT_KEY, opts, target);
+    } else {
+      Reflect.defineMetadata(RATE_LIMIT_KEY, opts, target, propertyKey);
     }
-  }
-  return results;
+  };
 }
-__name(findInDir, "findInDir");
-async function watchDirRecursive(dirPath, callback, includeSubdirs = true) {
-  const normalizedBasePath = path__default.default.normalize(dirPath);
-  const watchers = [];
-  const addWatcher = /* @__PURE__ */ __name((dir) => {
-    try {
-      const watcher = fs__default.default.watch(dir, (eventType, filename) => {
-        if (!filename) return;
-        const fullPath = path__default.default.join(dir, filename);
-        const relativePath = path__default.default.relative(normalizedBasePath, fullPath);
-        callback(eventType, relativePath);
-        if (eventType === "rename" && includeSubdirs) {
-          setTimeout(async () => {
-            try {
-              if (await isDirectory(fullPath)) {
-                addWatcher(fullPath);
-              }
-            } catch {
-            }
-          }, 100);
-        }
-      });
-      watchers.push(watcher);
-    } catch {
+__name(RateLimit, "RateLimit");
+function ContentType(type) {
+  return (target, propertyKey, _descriptor) => {
+    if (typeof propertyKey === "undefined") {
+      Reflect.defineMetadata(CONTENT_TYPE_KEY, {
+        type
+      }, target);
+    } else {
+      Reflect.defineMetadata(CONTENT_TYPE_KEY, {
+        type
+      }, target, propertyKey);
     }
-  }, "addWatcher");
-  addWatcher(normalizedBasePath);
-  if (includeSubdirs) {
-    const subdirs = await getSubdirectories(normalizedBasePath, true);
-    for (const subdir of subdirs) {
-      addWatcher(subdir);
+  };
+}
+__name(ContentType, "ContentType");
+function Version(version, options) {
+  const opts = {
+    addPrefix: true,
+    addHeader: true,
+    headerName: "X-API-Version",
+    ...options
+  };
+  return (target, propertyKey, _descriptor) => {
+    if (typeof propertyKey === "undefined") {
+      Reflect.defineMetadata(VERSION_KEY, {
+        version,
+        options: opts
+      }, target);
+    } else {
+      Reflect.defineMetadata(VERSION_KEY, {
+        version,
+        options: opts
+      }, target, propertyKey);
     }
-  }
-  return () => {
-    for (const watcher of watchers) {
-      watcher.close();
+  };
+}
+__name(Version, "Version");
+function Timeout(ms) {
+  return (target, propertyKey, _descriptor) => {
+    if (typeof propertyKey === "undefined") {
+      Reflect.defineMetadata(TIMEOUT_KEY, {
+        ms
+      }, target);
+    } else {
+      Reflect.defineMetadata(TIMEOUT_KEY, {
+        ms
+      }, target, propertyKey);
     }
   };
 }
-__name(watchDirRecursive, "watchDirRecursive");
-async function getDirStats(dirPath) {
-  let fileCount = 0;
-  let dirCount = 0;
-  let totalSize = 0;
-  async function processDir(currentPath) {
-    const entries = await fsp__default.default.readdir(currentPath, {
-      withFileTypes: true
-    });
-    for (const entry of entries) {
-      const entryPath = path__default.default.join(currentPath, entry.name);
-      if (entry.isDirectory()) {
-        dirCount++;
-        await processDir(entryPath);
-      } else if (entry.isFile()) {
-        fileCount++;
-        const stat = await fsp__default.default.stat(entryPath);
-        totalSize += stat.size;
-      }
+__name(Timeout, "Timeout");
+function Log(options) {
+  return (target, propertyKey, _descriptor) => {
+    const config2 = {
+      logEntry: true,
+      logExit: true,
+      logBody: false,
+      logParams: false,
+      logResponse: false,
+      ...options
+    };
+    if (typeof propertyKey === "undefined") {
+      Reflect.defineMetadata(LOG_KEY, config2, target);
+    } else {
+      Reflect.defineMetadata(LOG_KEY, config2, target, propertyKey);
     }
-  }
-  __name(processDir, "processDir");
-  await processDir(dirPath);
-  return {
-    fileCount,
-    dirCount,
-    totalSize
   };
 }
-__name(getDirStats, "getDirStats");
-async function walkDir(dirPath, options) {
-  const traversalOrder = options.traversalOrder || "pre";
-  const entries = await fsp__default.default.readdir(dirPath, {
-    withFileTypes: true
+__name(Log, "Log");
+function registerControllers(router, controllers) {
+  controllers.forEach((ControllerClass) => {
+    if (!Reflect.getMetadata("injectable", ControllerClass)) {
+      Reflect.defineMetadata("injectable", true, ControllerClass);
+      diContainer.register(ControllerClass);
+    }
+    const instance = diContainer.get(ControllerClass);
+    let basePath = Reflect.getMetadata("basePath", ControllerClass) || "";
+    const routes = Reflect.getMetadata(ROUTES_KEY, ControllerClass) || [];
+    const controllerRateLimit = Reflect.getMetadata(RATE_LIMIT_KEY, ControllerClass);
+    const controllerCache = Reflect.getMetadata(CACHE_KEY, ControllerClass);
+    const controllerTimeout = Reflect.getMetadata(TIMEOUT_KEY, ControllerClass);
+    const controllerVersion = Reflect.getMetadata(VERSION_KEY, ControllerClass);
+    const controllerRoles = Reflect.getMetadata(ROLES_KEY, ControllerClass);
+    const controllerLogConfig = Reflect.getMetadata(LOG_KEY, ControllerClass);
+    const controllerHeaders = Reflect.getMetadata(HEADER_KEY, ControllerClass) || {};
+    const controllerMiddlewares = Reflect.getMetadata(MIDDLEWARE_KEY, ControllerClass) || [];
+    const controllerBeforeHooks = Reflect.getMetadata(BEFORE_KEY, ControllerClass) || [];
+    const controllerAfterHooks = Reflect.getMetadata(AFTER_KEY, ControllerClass) || [];
+    const controllerContentType = Reflect.getMetadata(CONTENT_TYPE_KEY, ControllerClass);
+    if (controllerVersion?.options?.addPrefix) {
+      basePath = `/${controllerVersion.version}${basePath || ""}`;
+    }
+    routes.forEach(({ path: path3, method, handlerName }) => {
+      const methodMiddlewares = Reflect.getMetadata(MIDDLEWARE_KEY, instance, handlerName) || [];
+      const params = Reflect.getMetadata(PARAMS_KEY, instance, handlerName) || [];
+      const httpCode = Reflect.getMetadata(HTTP_CODE_KEY, instance, handlerName);
+      const methodHeaders = Reflect.getMetadata(HEADER_KEY, instance, handlerName) || {};
+      const headers = {
+        ...controllerHeaders,
+        ...methodHeaders
+      };
+      const middlewares = [
+        ...controllerMiddlewares,
+        ...methodMiddlewares
+      ];
+      const methodBeforeHooks = Reflect.getMetadata(BEFORE_KEY, instance, handlerName) || [];
+      const methodAfterHooks = Reflect.getMetadata(AFTER_KEY, instance, handlerName) || [];
+      const beforeHooks = [
+        ...controllerBeforeHooks,
+        ...methodBeforeHooks
+      ];
+      const afterHooks = [
+        ...methodAfterHooks,
+        ...controllerAfterHooks
+      ];
+      const redirect = Reflect.getMetadata(REDIRECT_KEY, instance, handlerName);
+      const methodContentType = Reflect.getMetadata(CONTENT_TYPE_KEY, instance, handlerName);
+      const contentType = methodContentType || controllerContentType;
+      const roles = Reflect.getMetadata(ROLES_KEY, instance, handlerName) || controllerRoles || [];
+      const cache = Reflect.getMetadata(CACHE_KEY, instance, handlerName) || controllerCache;
+      const rateLimitOptions = Reflect.getMetadata(RATE_LIMIT_KEY, instance, handlerName) || controllerRateLimit;
+      const methodVersion = Reflect.getMetadata(VERSION_KEY, instance, handlerName);
+      const version = methodVersion || controllerVersion;
+      const timeout2 = Reflect.getMetadata(TIMEOUT_KEY, instance, handlerName) || controllerTimeout;
+      const logConfig = Reflect.getMetadata(LOG_KEY, instance, handlerName) || controllerLogConfig;
+      let rateLimiter = null;
+      if (rateLimitOptions) {
+        try {
+          rateLimiter = rateLimiterCache.get(rateLimitOptions);
+        } catch (err) {
+          getLogger().warn({
+            err
+          }, "express-rate-limit not available, skipping rate limiting for this route");
+        }
+      }
+      let finalPath = path3;
+      if (methodVersion?.options?.addPrefix && methodVersion.version !== controllerVersion?.version) {
+        finalPath = `/${methodVersion.version}${path3}`;
+      }
+      const handler = /* @__PURE__ */ __name(async (req, res, next) => {
+        req["startTime"] = Date.now();
+        let timeoutId;
+        let timedOut = false;
+        try {
+          if (timeout2) {
+            timeoutId = setTimeout(() => {
+              if (!res.headersSent && !timedOut) {
+                timedOut = true;
+                const errorResponse = createFinalErrorResponse(req, HttpStatusCodes.REQUEST_TIMEOUT, "Request timed out");
+                res.status(HttpStatusCodes.REQUEST_TIMEOUT).json(errorResponse);
+              }
+            }, timeout2.ms);
+          }
+          if (timedOut) return;
+          if (rateLimiter) {
+            await new Promise((resolve2, reject) => {
+              rateLimiter(req, res, (err) => {
+                if (err) reject(err);
+                else resolve2();
+              });
+            });
+          }
+          if (!res.headersSent && contentType) {
+            res.setHeader("Content-Type", contentType.type);
+          }
+          if (version?.options?.addHeader && version?.options?.headerName && version?.version) {
+            if (!res.headersSent) {
+              res.setHeader(version.options.headerName, version.version);
+            }
+          }
+          if (cache && !res.headersSent) {
+            res.setHeader("Cache-Control", `public, max-age=${cache.ttlSeconds}`);
+          }
+          if (logConfig?.logEntry) {
+            const logger2 = getLogger();
+            const logData = {
+              method: req.method,
+              url: req.originalUrl || req.url,
+              userAgent: req.get("User-Agent")
+            };
+            if (logConfig.logParams) {
+              logData.params = req.params;
+              logData.query = req.query;
+            }
+            if (logConfig.logBody) logData.body = req.body;
+            logger2.info({
+              entry: logData
+            }, "Route Entry:");
+          }
+          if (roles.length && !req?.user?.roles?.some((role) => roles.includes(role))) {
+            const errorResponse = createFinalErrorResponse(req, HttpStatusCodes.FORBIDDEN, "Forbidden Insufficient Roles");
+            res.status(HttpStatusCodes.FORBIDDEN).json(errorResponse);
+            if (timeoutId) {
+              clearTimeout(timeoutId);
+            }
+            return;
+          }
+          if (redirect && redirect.url) {
+            if (timeoutId) {
+              clearTimeout(timeoutId);
+            }
+            return res.redirect(redirect.statusCode, redirect.url);
+          }
+          for (const fn of beforeHooks) await fn(req, res);
+          const args = [];
+          if (params.length) {
+            params.forEach(({ index, type, key, options }) => {
+              let rawValue;
+              switch (type) {
+                case "query":
+                  rawValue = key ? req.query[key] : req.query;
+                  args[index] = options ? applyParamOptions(rawValue, options, key) : rawValue;
+                  break;
+                case "param":
+                  rawValue = key ? req.params[key] : req.params;
+                  args[index] = options ? applyParamOptions(rawValue, options, key) : rawValue;
+                  break;
+                case "body":
+                  args[index] = key ? req.body?.[key] : req.body;
+                  break;
+                case "req":
+                  args[index] = req;
+                  break;
+                case "res":
+                  args[index] = res;
+                  break;
+                case "logger":
+                  args[index] = getLogger();
+                  break;
+                case "reqHeader":
+                  args[index] = key ? req.headers[key.toLowerCase()] : req.headers;
+                  break;
+                case "reqId":
+                  args[index] = req.headers["x-request-id"] || req?.id || void 0;
+                  break;
+                case "cookie":
+                  args[index] = key ? req.cookies?.[key] : req.cookies;
+                  break;
+              }
+            });
+          }
+          const result = instance[handlerName](...args);
+          const awaited = result instanceof Promise ? await result : result;
+          if (timeoutId) {
+            clearTimeout(timeoutId);
+          }
+          if (timedOut) return;
+          if (redirect && awaited && typeof awaited === "object" && "url" in awaited) {
+            const redirectUrl = awaited.url;
+            const redirectStatus = awaited.statusCode || redirect.statusCode;
+            return res.redirect(redirectStatus, redirectUrl);
+          }
+          if (!res.headersSent && typeof awaited !== "undefined") {
+            if (httpCode) res.status(httpCode);
+            for (const [k, v] of Object.entries(headers)) {
+              const normalized = normalizeHeaderValue(v);
+              if (typeof normalized !== "undefined") {
+                res.set(k, normalized);
+              }
+            }
+            res.json(awaited);
+          }
+          if (logConfig?.logExit) {
+            const logger2 = getLogger();
+            const logData = {
+              method: req.method,
+              url: req.originalUrl || req.url,
+              statusCode: res.statusCode,
+              duration: `${Date.now() - req.startTime}ms`
+            };
+            if (logConfig.logResponse) logData.response = awaited;
+            logger2.info({
+              exit: logData
+            }, "Route Exit:");
+          }
+          for (const fn of afterHooks) await fn(req, res, awaited);
+        } catch (err) {
+          if (timeoutId) {
+            clearTimeout(timeoutId);
+          }
+          next(err);
+        }
+      }, "handler");
+      router[method](basePath + finalPath, ...middlewares, handler);
+    });
   });
-  for (const entry of entries) {
-    const entryPath = path__default.default.join(dirPath, entry.name);
-    const stats = await fsp__default.default.stat(entryPath);
-    const entryInfo = {
-      path: entryPath,
-      name: entry.name,
-      isDirectory: entry.isDirectory(),
-      stats
-    };
-    if (entry.isDirectory()) {
-      if (traversalOrder === "pre") {
-        const shouldContinue = await options.visitorFn(entryInfo);
-        if (shouldContinue !== false) {
-          await walkDir(entryPath, options);
+}
+__name(registerControllers, "registerControllers");
+function applyParamOptions(rawValue, options, key) {
+  if (!options) return rawValue;
+  let value = rawValue;
+  const paramName = key ? `: ${key}` : "";
+  if (value === void 0 || value === null || value === "") {
+    if ("default" in options) {
+      value = options.default;
+    }
+  }
+  if (options.required && (value === void 0 || value === null || value === "")) {
+    throw new BadRequestException(`Required parameter missing${paramName}`);
+  }
+  if (value !== void 0 && value !== null) {
+    if (options.dataType === "array") {
+      const delimiter = options.delimiter || ",";
+      if (typeof value === "string") {
+        value = value.split(delimiter).map((v) => v.trim());
+      } else if (!Array.isArray(value)) {
+        value = [
+          value
+        ];
+      }
+      if (options.type === "string" && options.pattern) {
+        const hasInvalidPattern = value.some((v) => !options.pattern.test(v));
+        if (hasInvalidPattern) {
+          throw new BadRequestException(`Parameter '${key}' array contains values that do not match pattern: ${options.patternName || options.pattern}`);
+        }
+      }
+      if (options.type === "number" && options.pattern) {
+        const hasInvalidPattern = value.some((v) => !options.pattern.test(String(v)));
+        if (hasInvalidPattern) {
+          throw new BadRequestException(`Parameter '${key}' array contains values that do not match pattern: ${options.patternName || options.pattern}`);
+        }
+      }
+      if (options.type === "number" && options.throwError !== false) {
+        const hasInvalidNumber = value.some((v) => isNaN(Number(v)));
+        if (hasInvalidNumber) {
+          throw new BadRequestException(`Type error: expected number array${paramName}`);
+        }
+        if (options.min !== void 0) {
+          const hasBelowMin = value.some((v) => Number(v) < options.min);
+          if (hasBelowMin) {
+            throw new BadRequestException(`Validation error: number array values must be >= ${options.min}${paramName}`);
+          }
+        }
+        if (options.max !== void 0) {
+          const hasAboveMax = value.some((v) => Number(v) > options.max);
+          if (hasAboveMax) {
+            throw new BadRequestException(`Validation error: number array values must be <= ${options.max}${paramName}`);
+          }
+        }
+      }
+      if (options.type === "boolean" && options.throwError !== false) {
+        const hasInvalidBoolean = value.some((v) => !isValidBooleanInput(v));
+        if (hasInvalidBoolean) {
+          throw new BadRequestException(`Type error: expected boolean array${paramName}`);
+        }
+      }
+      if (options.type) {
+        value = value.map((v) => convertType(v, options.type || "string"));
+      }
+    } else if (options.dataType === "object") {
+      if (typeof value === "string") {
+        try {
+          value = JSON.parse(value);
+        } catch (_e) {
+          if (options.throwError !== false) {
+            throw new BadRequestException(`Invalid JSON object${paramName}`);
+          }
+        }
+      }
+    } else if (options.type) {
+      const originalValue = value;
+      value = convertType(value, options.type);
+      if (options.throwError === false) {
+        if (options.type === "number" && typeof value === "number") {
+          if (options.min !== void 0 && value < options.min) {
+            value = void 0;
+          }
+          if (options.max !== void 0 && value > options.max) {
+            value = void 0;
+          }
+        }
+      }
+      if (options.type === "string" && options.pattern && typeof value === "string" && !options.pattern.test(value)) {
+        throw new BadRequestException(`Parameter '${key}' does not match pattern: ${options.patternName || options.pattern}`);
+      } else if (options.type === "number" && options.pattern && typeof value === "number" && !options.pattern.test(String(value))) {
+        throw new BadRequestException(`Parameter '${key}' does not match pattern: ${options.patternName || options.pattern}`);
+      }
+      if (options.throwError !== false) {
+        if (options.type === "number" && typeof value === "number" && isNaN(value)) {
+          throw new BadRequestException(`Type error: expected number${paramName}`);
+        }
+        if (options.type === "number" && typeof value === "number") {
+          if (options.min !== void 0 && value < options.min) {
+            throw new BadRequestException(`Validation error: number must be >= ${options.min}${paramName}`);
+          }
+          if (options.max !== void 0 && value > options.max) {
+            throw new BadRequestException(`Validation error: number must be <= ${options.max}${paramName}`);
+          }
+        }
+        if (options.type === "boolean" && !isValidBooleanInput(originalValue)) {
+          throw new BadRequestException(`Type error: expected boolean${paramName}`);
         }
-      } else {
-        await walkDir(entryPath, options);
-        await options.visitorFn(entryInfo);
       }
-    } else {
-      await options.visitorFn(entryInfo);
     }
   }
-  if (traversalOrder === "post") {
-    const stats = await fsp__default.default.stat(dirPath);
-    const entryInfo = {
-      path: dirPath,
-      name: path__default.default.basename(dirPath),
-      isDirectory: true,
-      stats
-    };
-    await options.visitorFn(entryInfo);
-  }
-}
-__name(walkDir, "walkDir");
-
-// src/utils/exception.utils.ts
-var HttpError = class extends ErrorResponse {
-  static {
-    __name(this, "HttpError");
-  }
-  /**
-  * Creates a new HTTP error instance.
-  * @param status - A valid HTTP status code (e.g., 400, 500).
-  * @param message - The error message to return to the client.
-  */
-  constructor(status, message) {
-    super(message);
-    this.status = status;
-  }
-};
-var InternalServerErrorException = class extends ErrorResponse {
-  static {
-    __name(this, "InternalServerErrorException");
-  }
-  /**
-  * @param message - Optional custom message. Defaults to "Internal server error".
-  */
-  constructor(message = "Internal server error") {
-    super(message);
-    this.status = HttpStatusCodes.INTERNAL_SERVER_ERROR;
-  }
-};
-var UnauthorizedException = class extends ErrorResponse {
-  static {
-    __name(this, "UnauthorizedException");
-  }
-  /**
-  * @param message - Optional custom message. Defaults to "Unauthorized".
-  */
-  constructor(message = "Unauthorized") {
-    super(message);
-    this.status = HttpStatusCodes.UNAUTHORIZED;
-  }
-};
-var BadRequestException = class extends ErrorResponse {
-  static {
-    __name(this, "BadRequestException");
-  }
-  /**
-  * @param message - Optional custom message. Defaults to "Bad request".
-  */
-  constructor(message = "Bad request") {
-    super(message);
-    this.status = HttpStatusCodes.BAD_REQUEST;
-  }
-};
-var NotFoundException = class extends ErrorResponse {
-  static {
-    __name(this, "NotFoundException");
-  }
-  /**
-  * @param message - Optional custom message. Defaults to "Resource not found".
-  */
-  constructor(message = "Resource not found") {
-    super(message);
-    this.status = HttpStatusCodes.NOT_FOUND;
-  }
-};
-var ForbiddenException = class extends ErrorResponse {
-  static {
-    __name(this, "ForbiddenException");
-  }
-  /**
-  * @param message - Optional custom message. Defaults to "Forbidden".
-  */
-  constructor(message = "Forbidden") {
-    super(message);
-    this.status = HttpStatusCodes.FORBIDDEN;
-  }
-};
-var ConflictException = class extends ErrorResponse {
-  static {
-    __name(this, "ConflictException");
-  }
-  /**
-  * @param message - Optional custom message. Defaults to "Conflict".
-  */
-  constructor(message = "Conflict") {
-    super(message);
-    this.status = HttpStatusCodes.CONFLICT;
-  }
-};
-var BadGatewayException = class extends ErrorResponse {
-  static {
-    __name(this, "BadGatewayException");
-  }
-  /**
-  * @param message - Optional custom message. Defaults to "Bad Gateway".
-  */
-  constructor(message = "Bad Gateway") {
-    super(message);
-    this.status = HttpStatusCodes.BAD_GATEWAY;
-  }
-};
-var TooManyRequestsException = class extends ErrorResponse {
-  static {
-    __name(this, "TooManyRequestsException");
-  }
-  /**
-  * @param message - Optional custom message. Defaults to "Too many requests".
-  */
-  constructor(message = "Too many requests") {
-    super(message);
-    this.status = HttpStatusCodes.TOO_MANY_REQUESTS;
-  }
-};
-var ServiceUnavailableException = class extends ErrorResponse {
-  static {
-    __name(this, "ServiceUnavailableException");
-  }
-  /**
-  * @param message - Optional custom message. Defaults to "Service Unavailable".
-  */
-  constructor(message = "Service Unavailable") {
-    super(message);
-    this.status = HttpStatusCodes.SERVICE_UNAVAILABLE;
-  }
-};
-var GatewayTimeoutException = class extends ErrorResponse {
-  static {
-    __name(this, "GatewayTimeoutException");
-  }
-  /**
-  * @param message - Optional custom message. Defaults to "Gateway Timeout".
-  */
-  constructor(message = "Gateway Timeout") {
-    super(message);
-    this.status = HttpStatusCodes.GATEWAY_TIMEOUT;
-  }
-};
-var UnprocessableEntityException = class extends ErrorResponse {
-  static {
-    __name(this, "UnprocessableEntityException");
-  }
-  details;
-  /**
-  * @param message - Optional custom message. Defaults to "Unprocessable Entity".
-  * @param details - Optional validation details or additional error context.
-  */
-  constructor(message = "Unprocessable Entity", details) {
-    super(message), this.details = details;
-    this.status = HttpStatusCodes.UNPROCESSABLE_ENTITY;
-  }
-};
-var MethodNotAllowedException = class extends ErrorResponse {
-  static {
-    __name(this, "MethodNotAllowedException");
+  if (options.transform && typeof options.transform === "function") {
+    value = options.transform(value);
   }
-  allowedMethods;
-  /**
-  * @param message - Optional custom message. Defaults to "Method Not Allowed".
-  * @param allowedMethods - Optional array of allowed HTTP methods.
-  */
-  constructor(message = "Method Not Allowed", allowedMethods) {
-    super(message), this.allowedMethods = allowedMethods;
-    this.status = HttpStatusCodes.METHOD_NOT_ALLOWED;
+  if (options.validate && typeof options.validate === "function") {
+    if (!options.validate(value)) {
+      if (options.throwError !== false) {
+        throw new BadRequestException(`Parameter validation failed${paramName}`);
+      }
+      return void 0;
+    }
   }
-};
-var NotAcceptableException = class extends ErrorResponse {
-  static {
-    __name(this, "NotAcceptableException");
+  return value;
+}
+__name(applyParamOptions, "applyParamOptions");
+function isValidBooleanInput(value) {
+  if (typeof value === "boolean") return true;
+  if (typeof value === "number") return value === 0 || value === 1;
+  if (typeof value === "string") {
+    const normalizedValue = value.toLowerCase().trim();
+    return [
+      "true",
+      "false",
+      "0",
+      "1",
+      "yes",
+      "no"
+    ].includes(normalizedValue);
   }
-  /**
-  * @param message - Optional custom message. Defaults to "Not Acceptable".
-  */
-  constructor(message = "Not Acceptable") {
-    super(message);
-    this.status = HttpStatusCodes.NOT_ACCEPTABLE;
+  return false;
+}
+__name(isValidBooleanInput, "isValidBooleanInput");
+function convertType(value, type) {
+  if (value === void 0 || value === null) {
+    return value;
   }
-};
-var RequestTimeoutException = class extends ErrorResponse {
-  static {
-    __name(this, "RequestTimeoutException");
+  switch (type) {
+    case "number":
+      return Number(value);
+    case "boolean":
+      if (typeof value === "string") {
+        const normalizedValue = value.toLowerCase().trim();
+        return normalizedValue === "true" || normalizedValue === "1" || normalizedValue === "yes";
+      }
+      return value === true || value === 1;
+    case "string":
+    default:
+      return String(value);
   }
-  /**
-  * @param message - Optional custom message. Defaults to "Request Timeout".
-  */
-  constructor(message = "Request Timeout") {
-    super(message);
-    this.status = HttpStatusCodes.REQUEST_TIMEOUT;
+}
+__name(convertType, "convertType");
+async function ensureDir(dirPath) {
+  await fsp__default.default.mkdir(dirPath, {
+    recursive: true
+  });
+}
+__name(ensureDir, "ensureDir");
+async function listFiles(dirPath, recursive = false) {
+  const entries = await fsp__default.default.readdir(dirPath, {
+    withFileTypes: true
+  });
+  const files = [];
+  for (const entry of entries) {
+    const fullPath = path__default.default.join(dirPath, entry.name);
+    if (entry.isFile()) {
+      files.push(fullPath);
+    } else if (recursive && entry.isDirectory()) {
+      const nestedFiles = await listFiles(fullPath, true);
+      files.push(...nestedFiles);
+    }
   }
-};
-var UnsupportedMediaTypeException = class extends ErrorResponse {
-  static {
-    __name(this, "UnsupportedMediaTypeException");
+  return files;
+}
+__name(listFiles, "listFiles");
+async function deleteDirRecursive(dirPath) {
+  await fsp__default.default.rm(dirPath, {
+    recursive: true,
+    force: true
+  });
+}
+__name(deleteDirRecursive, "deleteDirRecursive");
+async function isDirectory(pathStr) {
+  try {
+    const stat = await fsp__default.default.stat(pathStr);
+    return stat.isDirectory();
+  } catch {
+    return false;
   }
-  /**
-  * @param message - Optional custom message. Defaults to "Unsupported Media Type".
-  */
-  constructor(message = "Unsupported Media Type") {
-    super(message);
-    this.status = HttpStatusCodes.UNSUPPORTED_MEDIA_TYPE;
+}
+__name(isDirectory, "isDirectory");
+async function copyDir(src, dest) {
+  await ensureDir(dest);
+  const entries = await fsp__default.default.readdir(src, {
+    withFileTypes: true
+  });
+  for (const entry of entries) {
+    const srcPath = path__default.default.join(src, entry.name);
+    const destPath = path__default.default.join(dest, entry.name);
+    if (entry.isDirectory()) {
+      await copyDir(srcPath, destPath);
+    } else {
+      await fsp__default.default.copyFile(srcPath, destPath);
+    }
   }
-};
-var PayloadTooLargeException = class extends ErrorResponse {
-  static {
-    __name(this, "PayloadTooLargeException");
+}
+__name(copyDir, "copyDir");
+async function moveDir(src, dest) {
+  await copyDir(src, dest);
+  await deleteDirRecursive(src);
+}
+__name(moveDir, "moveDir");
+async function emptyDir(dirPath) {
+  const entries = await fsp__default.default.readdir(dirPath, {
+    withFileTypes: true
+  });
+  for (const entry of entries) {
+    const entryPath = path__default.default.join(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      await fsp__default.default.rm(entryPath, {
+        recursive: true,
+        force: true
+      });
+    } else {
+      await fsp__default.default.unlink(entryPath);
+    }
   }
-  /**
-  * @param message - Optional custom message. Defaults to "Payload Too Large".
-  */
-  constructor(message = "Payload Too Large") {
-    super(message);
-    this.status = HttpStatusCodes.PAYLOAD_TOO_LARGE;
+}
+__name(emptyDir, "emptyDir");
+async function getDirSize(dirPath) {
+  let total = 0;
+  const entries = await fsp__default.default.readdir(dirPath, {
+    withFileTypes: true
+  });
+  for (const entry of entries) {
+    const entryPath = path__default.default.join(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      total += await getDirSize(entryPath);
+    } else {
+      const stat = await fsp__default.default.stat(entryPath);
+      total += stat.size;
+    }
   }
-};
-var InsufficientStorageException = class extends ErrorResponse {
-  static {
-    __name(this, "InsufficientStorageException");
+  return total;
+}
+__name(getDirSize, "getDirSize");
+function watchDir(dirPath, callback) {
+  const watcher = fs__default.default.watch(dirPath, (eventType, filename) => {
+    callback(eventType, filename);
+  });
+  return () => watcher.close();
+}
+__name(watchDir, "watchDir");
+async function findFilesByPattern(pattern, options = {}) {
+  const matchPattern = /* @__PURE__ */ __name((name, pattern2) => {
+    let escaped = pattern2.replaceAll(/[.+^${}()|[\]\\]/g, "\\$&");
+    escaped = escaped.replaceAll("*", ".*").replaceAll("?", ".");
+    const regex = new RegExp(`^${escaped}$`);
+    return regex.test(name);
+  }, "matchPattern");
+  const { cwd = process.cwd(), dot = false } = options;
+  const segments = pattern.split("/");
+  async function walk(dir, segIndex) {
+    if (segIndex >= segments.length) return [];
+    const segment = segments[segIndex];
+    const entries = await fs__default.default.promises.readdir(dir, {
+      withFileTypes: true
+    });
+    let matchedFiles = [];
+    for (const entry of entries) {
+      const entryName = entry.name;
+      if (!dot && entryName.startsWith(".")) continue;
+      const fullPath = path__default.default.join(dir, entryName);
+      const isLastSegment = segIndex === segments.length - 1;
+      if (isLastSegment) {
+        if (matchPattern(entryName, segment) && entry.isFile()) {
+          matchedFiles.push(fullPath);
+        }
+      } else if (entry.isDirectory()) {
+        if (matchPattern(entryName, segment)) {
+          matchedFiles.push(...await walk(fullPath, segIndex + 1));
+        }
+      }
+    }
+    return matchedFiles;
   }
-  /**
-  * @param message - Optional custom message. Defaults to "Insufficient Storage".
-  */
-  constructor(message = "Insufficient Storage") {
-    super(message);
-    this.status = HttpStatusCodes.INSUFFICIENT_STORAGE;
+  __name(walk, "walk");
+  return walk(cwd, 0);
+}
+__name(findFilesByPattern, "findFilesByPattern");
+async function getSubdirectories(dirPath, recursive = false) {
+  const entries = await fsp__default.default.readdir(dirPath, {
+    withFileTypes: true
+  });
+  const dirs = entries.filter((entry) => entry.isDirectory()).map((entry) => path__default.default.join(dirPath, entry.name));
+  if (recursive && dirs.length > 0) {
+    const nestedDirs = await Promise.all(dirs.map((dir) => getSubdirectories(dir, true)));
+    return [
+      ...dirs,
+      ...nestedDirs.flat()
+    ];
   }
-};
-function isHttpError(error) {
-  return error instanceof ErrorResponse;
+  return dirs;
 }
-__name(isHttpError, "isHttpError");
-function createHttpError(status, message) {
-  switch (status) {
-    case HttpStatusCodes.BAD_REQUEST:
-      return new BadRequestException(message);
-    case HttpStatusCodes.UNAUTHORIZED:
-      return new UnauthorizedException(message);
-    case HttpStatusCodes.FORBIDDEN:
-      return new ForbiddenException(message);
-    case HttpStatusCodes.NOT_FOUND:
-      return new NotFoundException(message);
-    case HttpStatusCodes.METHOD_NOT_ALLOWED:
-      return new MethodNotAllowedException(message);
-    case HttpStatusCodes.NOT_ACCEPTABLE:
-      return new NotAcceptableException(message);
-    case HttpStatusCodes.REQUEST_TIMEOUT:
-      return new RequestTimeoutException(message);
-    case HttpStatusCodes.CONFLICT:
-      return new ConflictException(message);
-    case HttpStatusCodes.GONE:
-      return new HttpError(HttpStatusCodes.GONE, message || "Gone");
-    case HttpStatusCodes.PAYLOAD_TOO_LARGE:
-      return new PayloadTooLargeException(message);
-    case HttpStatusCodes.UNSUPPORTED_MEDIA_TYPE:
-      return new UnsupportedMediaTypeException(message);
-    case HttpStatusCodes.UNPROCESSABLE_ENTITY:
-      return new UnprocessableEntityException(message);
-    case HttpStatusCodes.TOO_MANY_REQUESTS:
-      return new TooManyRequestsException(message);
-    case HttpStatusCodes.INTERNAL_SERVER_ERROR:
-      return new InternalServerErrorException(message);
-    case HttpStatusCodes.BAD_GATEWAY:
-      return new BadGatewayException(message);
-    case HttpStatusCodes.SERVICE_UNAVAILABLE:
-      return new ServiceUnavailableException(message);
-    case HttpStatusCodes.GATEWAY_TIMEOUT:
-      return new GatewayTimeoutException(message);
-    case HttpStatusCodes.INSUFFICIENT_STORAGE:
-      return new InsufficientStorageException(message);
-    default:
-      return new HttpError(status, message || `HTTP Error ${status}`);
+__name(getSubdirectories, "getSubdirectories");
+async function ensureEmptyDir(dirPath) {
+  if (await isDirectory(dirPath)) {
+    await emptyDir(dirPath);
+  } else {
+    try {
+      await fsp__default.default.unlink(dirPath);
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw error;
+      }
+    }
+    await ensureDir(dirPath);
+  }
+}
+__name(ensureEmptyDir, "ensureEmptyDir");
+async function createTempDir(options = {}) {
+  const prefix = options.prefix || "tmp-";
+  const parentDir = options.parentDir || os__default.default.tmpdir();
+  const dirName = `${prefix}${crypto.randomBytes(6).toString("hex")}`;
+  const tempDirPath = path__default.default.join(parentDir, dirName);
+  await ensureDir(tempDirPath);
+  const cleanup = /* @__PURE__ */ __name(async () => {
+    try {
+      await deleteDirRecursive(tempDirPath);
+    } catch {
+    }
+  }, "cleanup");
+  if (options.cleanup) {
+    process.once("exit", () => {
+      try {
+        fs__default.default.rmSync(tempDirPath, {
+          recursive: true,
+          force: true
+        });
+      } catch {
+      }
+    });
+    const signals = [
+      "SIGINT",
+      "SIGTERM",
+      "SIGUSR1",
+      "SIGUSR2"
+    ];
+    for (const signal of signals) {
+      process.once(signal, () => {
+        cleanup().then(() => process.exit());
+      });
+    }
   }
+  return {
+    path: tempDirPath,
+    cleanup
+  };
 }
-__name(createHttpError, "createHttpError");
-function hasErrorShape(error) {
-  return typeof error === "object" && error !== null && "message" in error && typeof error.message === "string";
+__name(createTempDir, "createTempDir");
+async function findNewestFile(dirPath, recursive = false) {
+  const files = await listFiles(dirPath, recursive);
+  if (files.length === 0) return null;
+  const stats = await Promise.all(files.map(async (file) => ({
+    path: file,
+    mtime: (await fsp__default.default.stat(file)).mtime
+  })));
+  return stats.sort((a, b) => b.mtime.getTime() - a.mtime.getTime())[0].path;
 }
-__name(hasErrorShape, "hasErrorShape");
-function getErrorMessage(error) {
-  if (typeof error === "string") {
-    return error;
-  }
-  if (error instanceof Error) {
-    return error.message;
-  }
-  if (hasErrorShape(error)) {
-    return error.message;
+__name(findNewestFile, "findNewestFile");
+async function findOldestFile(dirPath, recursive = false) {
+  const files = await listFiles(dirPath, recursive);
+  if (files.length === 0) return null;
+  const stats = await Promise.all(files.map(async (file) => ({
+    path: file,
+    mtime: (await fsp__default.default.stat(file)).mtime
+  })));
+  return stats.sort((a, b) => a.mtime.getTime() - b.mtime.getTime())[0].path;
+}
+__name(findOldestFile, "findOldestFile");
+async function findInDir(dirPath, predicate, recursive = false) {
+  const entries = await fsp__default.default.readdir(dirPath, {
+    withFileTypes: true
+  });
+  const results = [];
+  for (const entry of entries) {
+    const entryPath = path__default.default.join(dirPath, entry.name);
+    const stat = await fsp__default.default.stat(entryPath);
+    if (await predicate(entryPath, stat)) {
+      results.push(entryPath);
+    }
+    if (recursive && entry.isDirectory()) {
+      const nestedResults = await findInDir(entryPath, predicate, true);
+      results.push(...nestedResults);
+    }
   }
-  return "Unknown error occurred";
+  return results;
 }
-__name(getErrorMessage, "getErrorMessage");
-function withErrorHandling(handler) {
-  return async (...args) => {
+__name(findInDir, "findInDir");
+async function watchDirRecursive(dirPath, callback, includeSubdirs = true) {
+  const normalizedBasePath = path__default.default.normalize(dirPath);
+  const watchers = [];
+  const addWatcher = /* @__PURE__ */ __name((dir) => {
     try {
-      return await handler(...args);
-    } catch (err) {
-      if (isHttpError(err)) {
-        throw err;
-      }
-      getLogger().error({
-        err
-      }, "Caught error in handler");
-      let status = HttpStatusCodes.INTERNAL_SERVER_ERROR;
-      if (hasErrorShape(err) && typeof err.status === "number") {
-        status = err.status;
+      const watcher = fs__default.default.watch(dir, (eventType, filename) => {
+        if (!filename) return;
+        const fullPath = path__default.default.join(dir, filename);
+        const relativePath = path__default.default.relative(normalizedBasePath, fullPath);
+        callback(eventType, relativePath);
+        if (eventType === "rename" && includeSubdirs) {
+          setTimeout(async () => {
+            try {
+              if (await isDirectory(fullPath)) {
+                addWatcher(fullPath);
+              }
+            } catch {
+            }
+          }, 100);
+        }
+      });
+      watchers.push(watcher);
+    } catch {
+    }
+  }, "addWatcher");
+  addWatcher(normalizedBasePath);
+  if (includeSubdirs) {
+    const subdirs = await getSubdirectories(normalizedBasePath, true);
+    for (const subdir of subdirs) {
+      addWatcher(subdir);
+    }
+  }
+  return () => {
+    for (const watcher of watchers) {
+      watcher.close();
+    }
+  };
+}
+__name(watchDirRecursive, "watchDirRecursive");
+async function getDirStats(dirPath) {
+  let fileCount = 0;
+  let dirCount = 0;
+  let totalSize = 0;
+  async function processDir(currentPath) {
+    const entries = await fsp__default.default.readdir(currentPath, {
+      withFileTypes: true
+    });
+    for (const entry of entries) {
+      const entryPath = path__default.default.join(currentPath, entry.name);
+      if (entry.isDirectory()) {
+        dirCount++;
+        await processDir(entryPath);
+      } else if (entry.isFile()) {
+        fileCount++;
+        const stat = await fsp__default.default.stat(entryPath);
+        totalSize += stat.size;
       }
-      throw createHttpError(status, getErrorMessage(err));
     }
+  }
+  __name(processDir, "processDir");
+  await processDir(dirPath);
+  return {
+    fileCount,
+    dirCount,
+    totalSize
   };
 }
-__name(withErrorHandling, "withErrorHandling");
+__name(getDirStats, "getDirStats");
+async function walkDir(dirPath, options) {
+  const traversalOrder = options.traversalOrder || "pre";
+  const entries = await fsp__default.default.readdir(dirPath, {
+    withFileTypes: true
+  });
+  for (const entry of entries) {
+    const entryPath = path__default.default.join(dirPath, entry.name);
+    const stats = await fsp__default.default.stat(entryPath);
+    const entryInfo = {
+      path: entryPath,
+      name: entry.name,
+      isDirectory: entry.isDirectory(),
+      stats
+    };
+    if (entry.isDirectory()) {
+      if (traversalOrder === "pre") {
+        const shouldContinue = await options.visitorFn(entryInfo);
+        if (shouldContinue !== false) {
+          await walkDir(entryPath, options);
+        }
+      } else {
+        await walkDir(entryPath, options);
+        await options.visitorFn(entryInfo);
+      }
+    } else {
+      await options.visitorFn(entryInfo);
+    }
+  }
+  if (traversalOrder === "post") {
+    const stats = await fsp__default.default.stat(dirPath);
+    const entryInfo = {
+      path: dirPath,
+      name: path__default.default.basename(dirPath),
+      isDirectory: true,
+      stats
+    };
+    await options.visitorFn(entryInfo);
+  }
+}
+__name(walkDir, "walkDir");
 async function fileExists(path3) {
   try {
     await fsp__default.default.access(path3);
@@ -4259,6 +4806,202 @@ function healthCheck(options) {
 }
 __name(healthCheck, "healthCheck");
 
+// src/utils/performance.utils.ts
+function timeSync(fn, options = {}) {
+  const { label = fn.name || "anonymous function", log = false, logLevel = "debug" } = options;
+  const startTime = performance.now();
+  const result = fn();
+  const endTime = performance.now();
+  const durationMs = endTime - startTime;
+  const durationSec = durationMs / 1e3;
+  const timing = {
+    durationMs,
+    durationSec,
+    startTime,
+    endTime,
+    label
+  };
+  if (log) {
+    const logger2 = getLogger();
+    const message = `${label} completed in ${durationMs.toFixed(2)}ms`;
+    switch (logLevel) {
+      case "trace":
+        logger2.trace({
+          timing
+        }, message);
+        break;
+      case "debug":
+        logger2.debug({
+          timing
+        }, message);
+        break;
+      case "info":
+        logger2.info({
+          timing
+        }, message);
+        break;
+      case "warn":
+        logger2.warn({
+          timing
+        }, message);
+        break;
+      case "error":
+        logger2.error({
+          timing
+        }, message);
+        break;
+      default:
+        logger2.debug({
+          timing
+        }, message);
+        break;
+    }
+  }
+  return {
+    result,
+    timing
+  };
+}
+__name(timeSync, "timeSync");
+async function timeAsync(fn, options = {}) {
+  const { label = fn.name || "anonymous async function", log = false, logLevel = "debug" } = options;
+  const startTime = performance.now();
+  const result = await fn();
+  const endTime = performance.now();
+  const durationMs = endTime - startTime;
+  const durationSec = durationMs / 1e3;
+  const timing = {
+    durationMs,
+    durationSec,
+    startTime,
+    endTime,
+    label
+  };
+  if (log) {
+    const logger2 = getLogger();
+    const message = `${label} completed in ${durationMs.toFixed(2)}ms`;
+    switch (logLevel) {
+      case "trace":
+        logger2.trace({
+          timing
+        }, message);
+        break;
+      case "debug":
+        logger2.debug({
+          timing
+        }, message);
+        break;
+      case "info":
+        logger2.info({
+          timing
+        }, message);
+        break;
+      case "warn":
+        logger2.warn({
+          timing
+        }, message);
+        break;
+      case "error":
+        logger2.error({
+          timing
+        }, message);
+        break;
+      default:
+        logger2.debug({
+          timing
+        }, message);
+        break;
+    }
+  }
+  return {
+    result,
+    timing
+  };
+}
+__name(timeAsync, "timeAsync");
+function timed(options = {}) {
+  return function(target, propertyKeyOrContext, descriptor) {
+    let propertyKey;
+    let actualDescriptor;
+    if (typeof propertyKeyOrContext === "object" && propertyKeyOrContext !== null && "name" in propertyKeyOrContext) {
+      propertyKey = propertyKeyOrContext.name;
+      actualDescriptor = descriptor ?? Object.getOwnPropertyDescriptor(target, propertyKey);
+    } else {
+      propertyKey = propertyKeyOrContext;
+      actualDescriptor = descriptor ?? Object.getOwnPropertyDescriptor(target, propertyKey);
+    }
+    const originalMethod = actualDescriptor.value;
+    actualDescriptor.value = function(...args) {
+      const methodOptions = {
+        ...options,
+        label: options.label || `${target.constructor.name}.${String(propertyKey)}`
+      };
+      if (originalMethod.constructor.name === "AsyncFunction") {
+        return timeAsync(() => originalMethod.apply(this, args), methodOptions).then(({ result }) => result);
+      } else {
+        return timeSync(() => originalMethod.apply(this, args), methodOptions).result;
+      }
+    };
+    if (descriptor) {
+      descriptor.value = actualDescriptor.value;
+    } else {
+      Object.defineProperty(target, propertyKey, actualDescriptor);
+    }
+  };
+}
+__name(timed, "timed");
+function memoize(fn, options = {}) {
+  const { ttl, maxSize, autoCleanupMs, cacheKey = /* @__PURE__ */ __name((...args) => JSON.stringify(args), "cacheKey") } = options;
+  const cache = new TTLCache({
+    ttlMs: ttl,
+    maxSize,
+    autoCleanupMs
+  });
+  return function(...args) {
+    const key = cacheKey(...args);
+    const cachedValue = cache.get(key);
+    if (cachedValue !== void 0) {
+      return cachedValue;
+    }
+    const value = fn(...args);
+    cache.set(key, value);
+    return value;
+  };
+}
+__name(memoize, "memoize");
+function trackMemoryUsage(fn, options = {}) {
+  const { log = false, label = fn.name || "anonymous function" } = options;
+  if (global.gc) {
+    global.gc();
+  }
+  const beforeMemory = process.memoryUsage();
+  const result = fn();
+  const afterMemory = process.memoryUsage();
+  const diff = {};
+  for (const key in afterMemory) {
+    if (Object.prototype.hasOwnProperty.call(afterMemory, key)) {
+      diff[key] = afterMemory[key] - beforeMemory[key];
+    }
+  }
+  if (log) {
+    getLogger().info({
+      label,
+      memoryBefore: beforeMemory,
+      memoryAfter: afterMemory,
+      memoryDiff: diff
+    }, `Memory usage for ${label}`);
+  }
+  return {
+    result,
+    memoryUsage: {
+      before: beforeMemory,
+      after: afterMemory,
+      diff
+    }
+  };
+}
+__name(trackMemoryUsage, "trackMemoryUsage");
+
 // src/utils/request.utils.ts
 var getPaginationParams = /* @__PURE__ */ __name((req) => {
   const query = req.query;
@@ -4417,6 +5160,120 @@ function extractFilterParams(query, allowedFilters) {
   return filters;
 }
 __name(extractFilterParams, "extractFilterParams");
+function bufferToStream(data) {
+  const readable = new stream.Readable();
+  readable.push(data);
+  readable.push(null);
+  return readable;
+}
+__name(bufferToStream, "bufferToStream");
+async function streamToBuffer(stream) {
+  return new Promise((resolve2, reject) => {
+    const chunks = [];
+    stream.on("data", (chunk2) => chunks.push(Buffer.isBuffer(chunk2) ? chunk2 : Buffer.from(chunk2)));
+    stream.on("end", () => resolve2(Buffer.concat(chunks)));
+    stream.on("error", reject);
+  });
+}
+__name(streamToBuffer, "streamToBuffer");
+async function streamToString(stream, encoding = "utf8") {
+  const buffer = await streamToBuffer(stream);
+  return buffer.toString(encoding);
+}
+__name(streamToString, "streamToString");
+function createThrottleStream(bytesPerSecond) {
+  let bytesSent = 0;
+  let startTime = Date.now();
+  return new stream.Transform({
+    transform(chunk2, _encoding, callback) {
+      const elapsedSeconds = (Date.now() - startTime) / 1e3;
+      const targetBytes = bytesPerSecond * elapsedSeconds;
+      const chunkSize = chunk2.length;
+      if (bytesSent + chunkSize <= targetBytes) {
+        bytesSent += chunkSize;
+        callback(null, chunk2);
+        return;
+      }
+      const delay = ((bytesSent + chunkSize) / bytesPerSecond - elapsedSeconds) * 1e3;
+      setTimeout(() => {
+        bytesSent += chunkSize;
+        callback(null, chunk2);
+      }, delay);
+    }
+  });
+}
+__name(createThrottleStream, "createThrottleStream");
+function createBatchStream(size, options = {}) {
+  const objectMode = options.objectMode !== false;
+  let batch = [];
+  let buffers = [];
+  let bufferSize = 0;
+  return new stream.Transform({
+    objectMode,
+    transform(chunk2, _encoding, callback) {
+      if (objectMode) {
+        batch.push(chunk2);
+        if (batch.length >= size) {
+          this.push(batch);
+          batch = [];
+        }
+      } else {
+        const buffer = Buffer.isBuffer(chunk2) ? chunk2 : Buffer.from(chunk2);
+        buffers.push(buffer);
+        bufferSize += buffer.length;
+        let combined = Buffer.concat(buffers, bufferSize);
+        while (combined.length >= size) {
+          this.push(combined.slice(0, size));
+          combined = combined.slice(size);
+        }
+        buffers = combined.length > 0 ? [
+          combined
+        ] : [];
+        bufferSize = combined.length;
+      }
+      callback();
+    },
+    flush(callback) {
+      if (objectMode && batch.length > 0) {
+        this.push(batch);
+      } else if (!objectMode && buffers.length > 0 && bufferSize > 0) {
+        let combined = Buffer.concat(buffers, bufferSize);
+        while (combined.length >= size) {
+          this.push(combined.slice(0, size));
+          combined = combined.slice(size);
+        }
+        if (combined.length > 0) {
+          this.push(combined);
+        }
+      }
+      callback();
+    }
+  });
+}
+__name(createBatchStream, "createBatchStream");
+function createLineStream(options = {}) {
+  const { encoding = "utf8", includeNewlines = false } = options;
+  let buffer = "";
+  return new stream.Transform({
+    objectMode: true,
+    transform(chunk2, _encoding, callback) {
+      const str = buffer + (Buffer.isBuffer(chunk2) ? chunk2.toString(encoding) : chunk2);
+      const lines = str.split(/\r?\n/);
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        this.push(includeNewlines ? line + "\n" : line);
+      }
+      callback();
+    },
+    flush(callback) {
+      if (buffer) {
+        this.push(buffer);
+      }
+      callback();
+    }
+  });
+}
+__name(createLineStream, "createLineStream");
 
 // src/utils/string.utils.ts
 function capitalize(str) {
@@ -4476,6 +5333,84 @@ function countOccurrences(str, substring, caseSensitive = true) {
   return str.split(substring).length - 1;
 }
 __name(countOccurrences, "countOccurrences");
+
+// src/utils/type.utils.ts
+function isPrimitiveType(value, type) {
+  if (type === "array") {
+    return Array.isArray(value);
+  }
+  if (type === "null") {
+    return value === null;
+  }
+  if (type === "undefined") {
+    return value === void 0;
+  }
+  if (type === "object") {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+  return typeof value === type;
+}
+__name(isPrimitiveType, "isPrimitiveType");
+function getTypeOf(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (Array.isArray(value)) return "array";
+  return typeof value;
+}
+__name(getTypeOf, "getTypeOf");
+function isArrayOf(value, itemTypeGuard) {
+  if (!Array.isArray(value)) return false;
+  return value.every((item) => itemTypeGuard(item));
+}
+__name(isArrayOf, "isArrayOf");
+function toStr(value, defaultValue = "") {
+  if (value === null || value === void 0) return defaultValue;
+  try {
+    if (typeof value === "object") {
+      return JSON.stringify(value);
+    }
+    return String(value);
+  } catch {
+    return defaultValue;
+  }
+}
+__name(toStr, "toStr");
+function toNum(value, defaultValue = 0) {
+  if (value === null || value === void 0) return defaultValue;
+  if (typeof value === "number") return value;
+  try {
+    const num = Number(value);
+    return isNaN(num) ? defaultValue : num;
+  } catch {
+    return defaultValue;
+  }
+}
+__name(toNum, "toNum");
+function toBool(value, defaultValue = false) {
+  if (value === null || value === void 0) return defaultValue;
+  if (typeof value === "boolean") return value;
+  if (typeof value === "string") {
+    const lowercased = value.toLowerCase();
+    if (lowercased === "true" || lowercased === "yes" || lowercased === "y" || lowercased === "1") {
+      return true;
+    }
+    if (lowercased === "false" || lowercased === "no" || lowercased === "n" || lowercased === "0") {
+      return false;
+    }
+  }
+  if (typeof value === "number") {
+    return value !== 0;
+  }
+  return defaultValue;
+}
+__name(toBool, "toBool");
+function ensureType(value, expectedType, defaultValue) {
+  if (getTypeOf(value) === expectedType) {
+    return value;
+  }
+  return defaultValue;
+}
+__name(ensureType, "ensureType");
 function appendQueryParams(url$1, params) {
   const urlObj = new url.URL(url$1);
   for (const [key, value] of Object.entries(params)) {
@@ -6380,6 +7315,10 @@ exports.RateLimit = RateLimit;
 exports.Redirect = Redirect;
 exports.RedirectResponse = RedirectResponse;
 exports.Req = Req;
+exports.ReqCookie = ReqCookie;
+exports.ReqHeader = ReqHeader;
+exports.ReqId = ReqId;
+exports.ReqLogger = ReqLogger;
 exports.RequestTimeoutException = RequestTimeoutException;
 exports.Res = Res;
 exports.Roles = Roles;
@@ -6402,8 +7341,10 @@ exports._globalThis = _globalThis;
 exports.abortable = abortable;
 exports.addRedactFields = addRedactFields;
 exports.addSensitiveFields = addSensitiveFields;
+exports.addToDate = addToDate;
 exports.appendQueryParams = appendQueryParams;
 exports.appendTextFile = appendTextFile;
+exports.bufferToStream = bufferToStream;
 exports.capitalize = capitalize;
 exports.chunk = chunk;
 exports.circuitBreaker = circuitBreaker;
@@ -6412,20 +7353,27 @@ exports.copyDir = copyDir;
 exports.copyFile = copyFile;
 exports.countBy = countBy;
 exports.countOccurrences = countOccurrences;
+exports.createBatchStream = createBatchStream;
 exports.createChildLogger = createChildLogger;
 exports.createDeferred = createDeferred;
 exports.createDirectory = createDirectory;
 exports.createErrorResponse = createErrorResponse;
 exports.createFinalErrorResponse = createFinalErrorResponse;
 exports.createHttpError = createHttpError;
+exports.createLineStream = createLineStream;
 exports.createPaginatedResponse = createPaginatedResponse;
+exports.createParamDecorator = createParamDecorator;
+exports.createParamDecoratorWithoutParam = createParamDecoratorWithoutParam;
 exports.createRequestLogger = createRequestLogger;
 exports.createSignedToken = createSignedToken;
 exports.createSuccessResponse = createSuccessResponse;
 exports.createTaskQueue = createTaskQueue;
 exports.createTempDir = createTempDir;
 exports.createTempFile = createTempFile;
+exports.createThrottleStream = createThrottleStream;
 exports.createUrlBuilder = createUrlBuilder;
+exports.dateDiff = dateDiff;
+exports.daysInMonth = daysInMonth;
 exports.debounce = debounce;
 exports.decrypt = decrypt;
 exports.deepFreeze = deepFreeze;
@@ -6436,8 +7384,10 @@ exports.deleteFileIfExists = deleteFileIfExists;
 exports.difference = difference;
 exports.emptyDir = emptyDir;
 exports.encrypt = encrypt;
+exports.endOf = endOf;
 exports.ensureDir = ensureDir;
 exports.ensureEmptyDir = ensureEmptyDir;
+exports.ensureType = ensureType;
 exports.equalsIgnoreCase = equalsIgnoreCase;
 exports.errorHandler = errorHandler;
 exports.extractFilterParams = extractFilterParams;
@@ -6452,6 +7402,8 @@ exports.findNewestFile = findNewestFile;
 exports.findOldestFile = findOldestFile;
 exports.flattenDeep = flattenDeep;
 exports.flattenObject = flattenObject;
+exports.formatDate = formatDate;
+exports.formatRelativeTime = formatRelativeTime;
 exports.generateApiKey = generateApiKey;
 exports.generateRandomBytes = generateRandomBytes;
 exports.generateRandomBytesAsString = generateRandomBytesAsString;
@@ -6470,6 +7422,7 @@ exports.getPaginationParams = getPaginationParams;
 exports.getRedactCensor = getRedactCensor;
 exports.getRequestId = getRequestId;
 exports.getSubdirectories = getSubdirectories;
+exports.getTypeOf = getTypeOf;
 exports.getValueByPath = getValueByPath;
 exports.groupBy = groupBy;
 exports.hasErrorShape = hasErrorShape;
@@ -6477,11 +7430,14 @@ exports.hasRequiredProps = hasRequiredProps;
 exports.hash = hash;
 exports.healthCheck = healthCheck;
 exports.hmac = hmac;
+exports.inject = inject;
 exports.intersect = intersect;
 exports.isAlpha = isAlpha;
 exports.isAlphanumeric = isAlphanumeric;
 exports.isArray = isArray;
+exports.isArrayOf = isArrayOf;
 exports.isBase64 = isBase64;
+exports.isBetween = isBetween;
 exports.isCreditCard = isCreditCard;
 exports.isDateInRange = isDateInRange;
 exports.isDirectory = isDirectory;
@@ -6493,6 +7449,7 @@ exports.isHttpError = isHttpError;
 exports.isIPv4 = isIPv4;
 exports.isIPv6 = isIPv6;
 exports.isISODate = isISODate;
+exports.isLeapYear = isLeapYear;
 exports.isLengthBetween = isLengthBetween;
 exports.isNumberBetween = isNumberBetween;
 exports.isNumeric = isNumeric;
@@ -6501,6 +7458,7 @@ exports.isObject = isObject;
 exports.isPhone = isPhone;
 exports.isPlainObject = isPlainObject;
 exports.isPort = isPort;
+exports.isPrimitiveType = isPrimitiveType;
 exports.isStrongPassword = isStrongPassword;
 exports.isURL = isURL;
 exports.isUUID = isUUID;
@@ -6514,6 +7472,7 @@ exports.mapObject = mapObject;
 exports.mask = mask;
 exports.matchesPattern = matchesPattern;
 exports.md5 = md5;
+exports.memoize = memoize;
 exports.memoizeAsync = memoizeAsync;
 exports.mergeSort = mergeSort;
 exports.moveDir = moveDir;
@@ -6522,6 +7481,7 @@ exports.nanoId = nanoId;
 exports.normalizeUrl = normalizeUrl;
 exports.omit = omit;
 exports.parseBooleanParam = parseBooleanParam;
+exports.parseDate = parseDate;
 exports.parseNumberParam = parseNumberParam;
 exports.parseQueryString = parseQueryString;
 exports.parseTypedQueryParams = parseTypedQueryParams;
@@ -6565,16 +7525,26 @@ exports.shuffle = shuffle;
 exports.singletonAsync = singletonAsync;
 exports.sleep = sleep;
 exports.slugify = slugify;
+exports.startOf = startOf;
 exports.streamFile = streamFile;
+exports.streamToBuffer = streamToBuffer;
+exports.streamToString = streamToString;
 exports.stripHtml = stripHtml;
 exports.take = take;
 exports.takeWhile = takeWhile;
 exports.throttle = throttle;
+exports.timeAsync = timeAsync;
+exports.timeSync = timeSync;
+exports.timed = timed;
 exports.timeout = timeout;
+exports.toBool = toBool;
 exports.toCamelCase = toCamelCase;
 exports.toKebabCase = toKebabCase;
+exports.toNum = toNum;
 exports.toPascalCase = toPascalCase;
 exports.toSnakeCase = toSnakeCase;
+exports.toStr = toStr;
+exports.trackMemoryUsage = trackMemoryUsage;
 exports.truncate = truncate;
 exports.unique = unique;
 exports.uuid = uuid;