@catbee/utils 0.0.8-rc.4 → 1.0.1

package/build/index.cjs

@@ -1660,7 +1660,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 +1674,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 +1694,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 +1713,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);
@@ -2751,338 +2757,761 @@ 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);
-    }
-  };
-}
-__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(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);
-  };
+  /**
+  * @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(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(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(Roles, "Roles");
-function Redirect(url, statusCode = 302) {
-  return (target, propertyKey, descriptor) => {
-    Reflect.defineMetadata(REDIRECT_KEY, {
-      url,
-      statusCode
-    }, target, propertyKey);
-    return descriptor;
-  };
+__name(createHttpError, "createHttpError");
+function hasErrorShape(error) {
+  return typeof error === "object" && error !== null && "message" in error && typeof error.message === "string";
 }
-__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(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(Cache, "Cache");
-function RateLimit(options) {
-  const opts = {
-    standardHeaders: true,
-    legacyHeaders: false,
-    ...options
+__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")
+    });
+    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
+    });
+  }
+  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;
+  }
+  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(normalizeHeaderValue, "normalizeHeaderValue");
+function Injectable() {
+  return (target) => {
+    Reflect.defineMetadata("injectable", true, target);
+    diContainer.register(target);
+  };
+}
+__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
+      });
+      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) => {
     if (typeof propertyKey === "undefined") {
-      Reflect.defineMetadata(RATE_LIMIT_KEY, opts, target);
+      const existing = Reflect.getMetadata(MIDDLEWARE_KEY, target) || [];
+      Reflect.defineMetadata(MIDDLEWARE_KEY, [
+        ...existing,
+        ...middlewares
+      ], target);
     } else {
-      Reflect.defineMetadata(RATE_LIMIT_KEY, opts, target, propertyKey);
+      const existing = Reflect.getMetadata(MIDDLEWARE_KEY, target, propertyKey) || [];
+      Reflect.defineMetadata(MIDDLEWARE_KEY, [
+        ...existing,
+        ...middlewares
+      ], target, propertyKey);
     }
   };
 }
-__name(RateLimit, "RateLimit");
-function ContentType(type) {
-  return (target, propertyKey, _descriptor) => {
-    Reflect.defineMetadata(CONTENT_TYPE_KEY, {
-      type
-    }, target, propertyKey);
+__name(Use, "Use");
+function defineParamMetadata(target, propertyKey, parameterIndex, type, key) {
+  const params = Reflect.getMetadata(PARAMS_KEY, target, propertyKey) || [];
+  params.push({
+    index: parameterIndex,
+    type,
+    key
+  });
+  params.sort((a, b) => a.index - b.index);
+  Reflect.defineMetadata(PARAMS_KEY, params, target, propertyKey);
+}
+__name(defineParamMetadata, "defineParamMetadata");
+function createParamDecorator(type, key) {
+  return (paramKey) => {
+    return (target, propertyKey, parameterIndex) => {
+      defineParamMetadata(target, propertyKey, parameterIndex, type, paramKey ?? key);
+    };
   };
 }
-__name(ContentType, "ContentType");
-function Version(version, options) {
-  const opts = {
-    addPrefix: true,
-    addHeader: true,
-    headerName: "X-API-Version",
-    ...options
+__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
+        };
+      }
+      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(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(HttpCode, "HttpCode");
+function Header(name, value) {
+  return Headers(name, value);
+}
+__name(Header, "Header");
+function Headers(headers, value) {
+  return (target, propertyKey) => {
     if (typeof propertyKey === "undefined") {
-      Reflect.defineMetadata(VERSION_KEY, {
-        version,
-        options: opts
+      const existing = Reflect.getMetadata(HEADER_KEY, target) || {};
+      const newHeaders = typeof headers === "string" ? {
+        [headers]: value
+      } : headers;
+      Reflect.defineMetadata(HEADER_KEY, {
+        ...existing,
+        ...newHeaders
       }, target);
     } else {
-      Reflect.defineMetadata(VERSION_KEY, {
-        version,
-        options: opts
+      const existing = Reflect.getMetadata(HEADER_KEY, target, propertyKey) || {};
+      const newHeaders = typeof headers === "string" ? {
+        [headers]: value
+      } : headers;
+      Reflect.defineMetadata(HEADER_KEY, {
+        ...existing,
+        ...newHeaders
       }, target, propertyKey);
     }
   };
 }
-__name(Version, "Version");
-function Timeout(ms) {
+__name(Headers, "Headers");
+function Before(fn) {
   return (target, propertyKey, _descriptor) => {
     if (typeof propertyKey === "undefined") {
-      Reflect.defineMetadata(TIMEOUT_KEY, {
-        ms
-      }, target);
+      const hooks = Reflect.getMetadata(BEFORE_KEY, target) || [];
+      hooks.push(fn);
+      Reflect.defineMetadata(BEFORE_KEY, hooks, target);
     } else {
-      Reflect.defineMetadata(TIMEOUT_KEY, {
-        ms
-      }, target, propertyKey);
+      const hooks = Reflect.getMetadata(BEFORE_KEY, target, propertyKey) || [];
+      hooks.push(fn);
+      Reflect.defineMetadata(BEFORE_KEY, hooks, target, propertyKey);
     }
   };
 }
-__name(Timeout, "Timeout");
-function Log(options) {
+__name(Before, "Before");
+function After(fn) {
   return (target, propertyKey, _descriptor) => {
-    const config2 = {
-      logEntry: true,
-      logExit: true,
-      logBody: false,
-      logParams: false,
-      logResponse: false,
-      ...options
-    };
+    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);
+    }
+  };
+}
+__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(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) => {
+    if (typeof propertyKey === "undefined") {
+      Reflect.defineMetadata(CONTENT_TYPE_KEY, {
+        type
+      }, target);
+    } else {
+      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 {
@@ -3093,6 +3522,10 @@ function Log(options) {
 __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);
     const basePath = Reflect.getMetadata("basePath", ControllerClass) || "";
     const routes = Reflect.getMetadata(ROUTES_KEY, ControllerClass) || [];
@@ -3103,8 +3536,12 @@ function registerControllers(router, controllers) {
     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);
     routes.forEach(({ path: path3, method, handlerName }) => {
-      const middlewares = Reflect.getMetadata(MIDDLEWARE_KEY, instance, 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) || {};
@@ -3112,10 +3549,23 @@ function registerControllers(router, controllers) {
         ...controllerHeaders,
         ...methodHeaders
       };
-      const beforeHooks = Reflect.getMetadata(BEFORE_KEY, instance, handlerName) || [];
-      const afterHooks = Reflect.getMetadata(AFTER_KEY, instance, handlerName) || [];
+      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 contentType = Reflect.getMetadata(CONTENT_TYPE_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;
@@ -3203,13 +3653,16 @@ function registerControllers(router, controllers) {
           for (const fn of beforeHooks) await fn(req, res);
           const args = [];
           if (params.length) {
-            params.forEach(({ index, type, key }) => {
+            params.forEach(({ index, type, key, options }) => {
+              let rawValue;
               switch (type) {
                 case "query":
-                  args[index] = key ? req.query[key] : req.query;
+                  rawValue = key ? req.query[key] : req.query;
+                  args[index] = options ? applyParamOptions(rawValue, options, key) : rawValue;
                   break;
                 case "param":
-                  args[index] = key ? req.params[key] : req.params;
+                  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;
@@ -3220,6 +3673,18 @@ function registerControllers(router, controllers) {
                 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;
               }
             });
           }
@@ -3264,675 +3729,524 @@ function registerControllers(router, controllers) {
           }
           next(err);
         }
-      }, "handler");
-      router[method](basePath + finalPath, ...middlewares, 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);
-    }
-  }
-  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;
-  }
-}
-__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);
-    }
-  }
-}
-__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);
-    }
-  }
-}
-__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;
-    }
-  }
-  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;
-  }
-  __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()
-    ];
-  }
-  return dirs;
-}
-__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(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(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 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 {
-    }
-  }, "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;
-      }
-    }
-  }
-  __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
-  });
-  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");
-
-// 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");
-  }
-  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;
+      }, "handler");
+      router[method](basePath + finalPath, ...middlewares, handler);
+    });
+  });
+}
+__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}`);
+        }
+      }
+    }
   }
-};
-var NotAcceptableException = class extends ErrorResponse {
-  static {
-    __name(this, "NotAcceptableException");
+  if (options.transform && typeof options.transform === "function") {
+    value = options.transform(value);
   }
-  /**
-  * @param message - Optional custom message. Defaults to "Not Acceptable".
-  */
-  constructor(message = "Not Acceptable") {
-    super(message);
-    this.status = HttpStatusCodes.NOT_ACCEPTABLE;
+  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 RequestTimeoutException = class extends ErrorResponse {
-  static {
-    __name(this, "RequestTimeoutException");
+  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 "Request Timeout".
-  */
-  constructor(message = "Request Timeout") {
-    super(message);
-    this.status = HttpStatusCodes.REQUEST_TIMEOUT;
+  return false;
+}
+__name(isValidBooleanInput, "isValidBooleanInput");
+function convertType(value, type) {
+  if (value === void 0 || value === null) {
+    return value;
   }
-};
-var UnsupportedMediaTypeException = class extends ErrorResponse {
-  static {
-    __name(this, "UnsupportedMediaTypeException");
+  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 "Unsupported Media Type".
-  */
-  constructor(message = "Unsupported Media Type") {
-    super(message);
-    this.status = HttpStatusCodes.UNSUPPORTED_MEDIA_TYPE;
+}
+__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 PayloadTooLargeException = class extends ErrorResponse {
-  static {
-    __name(this, "PayloadTooLargeException");
+  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 "Payload Too Large".
-  */
-  constructor(message = "Payload Too Large") {
-    super(message);
-    this.status = HttpStatusCodes.PAYLOAD_TOO_LARGE;
+}
+__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 InsufficientStorageException = class extends ErrorResponse {
-  static {
-    __name(this, "InsufficientStorageException");
+}
+__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 "Insufficient Storage".
-  */
-  constructor(message = "Insufficient Storage") {
-    super(message);
-    this.status = HttpStatusCodes.INSUFFICIENT_STORAGE;
+}
+__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;
+    }
   }
-};
-function isHttpError(error) {
-  return error instanceof ErrorResponse;
+  return total;
 }
-__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(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;
   }
+  __name(walk, "walk");
+  return walk(cwd, 0);
 }
-__name(createHttpError, "createHttpError");
-function hasErrorShape(error) {
-  return typeof error === "object" && error !== null && "message" in error && typeof error.message === "string";
+__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(hasErrorShape, "hasErrorShape");
-function getErrorMessage(error) {
-  if (typeof error === "string") {
-    return error;
+__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);
   }
-  if (error instanceof Error) {
-    return error.message;
+}
+__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());
+      });
+    }
   }
-  if (hasErrorShape(error)) {
-    return error.message;
+  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(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);
@@ -6380,6 +6694,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;
@@ -6419,6 +6737,8 @@ exports.createErrorResponse = createErrorResponse;
 exports.createFinalErrorResponse = createFinalErrorResponse;
 exports.createHttpError = createHttpError;
 exports.createPaginatedResponse = createPaginatedResponse;
+exports.createParamDecorator = createParamDecorator;
+exports.createParamDecoratorWithoutParam = createParamDecoratorWithoutParam;
 exports.createRequestLogger = createRequestLogger;
 exports.createSignedToken = createSignedToken;
 exports.createSuccessResponse = createSuccessResponse;
@@ -6477,6 +6797,7 @@ exports.hasRequiredProps = hasRequiredProps;
 exports.hash = hash;
 exports.healthCheck = healthCheck;
 exports.hmac = hmac;
+exports.inject = inject;
 exports.intersect = intersect;
 exports.isAlpha = isAlpha;
 exports.isAlphanumeric = isAlphanumeric;