@catbee/utils 2.0.0-next.1 → 2.0.1

package/{decorators → decorator}/index.mjs

@@ -1,7 +1,7 @@
 /*
  * The MIT License
  * 
- * Copyright (c) 2025 Catbee Technologies. https://catbee.in/license
+ * Copyright (c) 2026 Catbee Technologies. https://catbee.in/license
  * 
  * Permission is hereby granted, free of charge, to any person obtaining a copy
  * of this software and associated documentation files (the "Software"), to deal
@@ -1150,7 +1150,7 @@ var require_Reflect = __commonJS({
   }
 });
 
-// src/decorators/decorators.utils.ts
+// src/decorator/decorator.utils.ts
 __toESM(require_Reflect());
 var ROUTES_KEY = Symbol("routes");
 var MIDDLEWARE_KEY = Symbol("middlewares");
@@ -1274,7 +1274,7 @@ var DIContainer = class {
 };
 var diContainer = new DIContainer();
 function normalizeHeaderValue(value) {
-  if (typeof value === "undefined") return void 0;
+  if (value === void 0) return void 0;
   if (typeof value === "string") return value;
   if (Array.isArray(value) && value.every((item) => typeof item === "string")) {
     return value;
@@ -1613,223 +1613,309 @@ 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);
-    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 || ""}`;
+    registerSingleController(router, ControllerClass);
+  });
+}
+__name(registerControllers, "registerControllers");
+function registerSingleController(router, ControllerClass) {
+  if (!Reflect.getMetadata("injectable", ControllerClass)) {
+    Reflect.defineMetadata("injectable", true, ControllerClass);
+    diContainer.register(ControllerClass);
+  }
+  const instance = diContainer.get(ControllerClass);
+  const controllerMetadata = getControllerMetadata(ControllerClass);
+  const routes = Reflect.getMetadata(ROUTES_KEY, ControllerClass) || [];
+  routes.forEach((routeDef) => {
+    registerRoute(router, instance, controllerMetadata, routeDef);
+  });
+}
+__name(registerSingleController, "registerSingleController");
+function getControllerMetadata(ControllerClass) {
+  let basePath = Reflect.getMetadata("basePath", ControllerClass) || "";
+  const controllerVersion = Reflect.getMetadata(VERSION_KEY, ControllerClass);
+  if (controllerVersion?.options?.addPrefix) {
+    basePath = `/${controllerVersion.version}${basePath || ""}`;
+  }
+  return {
+    basePath,
+    rateLimit: Reflect.getMetadata(RATE_LIMIT_KEY, ControllerClass),
+    cache: Reflect.getMetadata(CACHE_KEY, ControllerClass),
+    timeout: Reflect.getMetadata(TIMEOUT_KEY, ControllerClass),
+    version: controllerVersion,
+    roles: Reflect.getMetadata(ROLES_KEY, ControllerClass),
+    logConfig: Reflect.getMetadata(LOG_KEY, ControllerClass),
+    headers: Reflect.getMetadata(HEADER_KEY, ControllerClass) || {},
+    middlewares: Reflect.getMetadata(MIDDLEWARE_KEY, ControllerClass) || [],
+    beforeHooks: Reflect.getMetadata(BEFORE_KEY, ControllerClass) || [],
+    afterHooks: Reflect.getMetadata(AFTER_KEY, ControllerClass) || [],
+    contentType: Reflect.getMetadata(CONTENT_TYPE_KEY, ControllerClass)
+  };
+}
+__name(getControllerMetadata, "getControllerMetadata");
+function registerRoute(router, instance, controllerMetadata, routeDef) {
+  const { path, method, handlerName } = routeDef;
+  const routeMetadata = getRouteMetadata(instance, handlerName, controllerMetadata);
+  const handler = createRouteHandler(instance, handlerName, routeMetadata);
+  const finalPath = calculateFinalPath(path, routeMetadata, controllerMetadata);
+  router[method](controllerMetadata.basePath + finalPath, ...routeMetadata.middlewares, handler);
+}
+__name(registerRoute, "registerRoute");
+function getRouteMetadata(instance, handlerName, controllerMetadata) {
+  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 methodBeforeHooks = Reflect.getMetadata(BEFORE_KEY, instance, handlerName) || [];
+  const methodAfterHooks = Reflect.getMetadata(AFTER_KEY, instance, handlerName) || [];
+  const redirect = Reflect.getMetadata(REDIRECT_KEY, instance, handlerName);
+  const methodContentType = Reflect.getMetadata(CONTENT_TYPE_KEY, instance, handlerName);
+  const methodVersion = Reflect.getMetadata(VERSION_KEY, instance, handlerName);
+  const headers = {
+    ...controllerMetadata.headers,
+    ...methodHeaders
+  };
+  const middlewares = [
+    ...controllerMetadata.middlewares,
+    ...methodMiddlewares
+  ];
+  const beforeHooks = [
+    ...controllerMetadata.beforeHooks,
+    ...methodBeforeHooks
+  ];
+  const afterHooks = [
+    ...methodAfterHooks,
+    ...controllerMetadata.afterHooks
+  ];
+  const contentType = methodContentType || controllerMetadata.contentType;
+  const roles = Reflect.getMetadata(ROLES_KEY, instance, handlerName) || controllerMetadata.roles || [];
+  const cache = Reflect.getMetadata(CACHE_KEY, instance, handlerName) || controllerMetadata.cache;
+  const rateLimitOptions = Reflect.getMetadata(RATE_LIMIT_KEY, instance, handlerName) || controllerMetadata.rateLimit;
+  const version = methodVersion || controllerMetadata.version;
+  const timeout = Reflect.getMetadata(TIMEOUT_KEY, instance, handlerName) || controllerMetadata.timeout;
+  const logConfig = Reflect.getMetadata(LOG_KEY, instance, handlerName) || controllerMetadata.logConfig;
+  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");
     }
-    routes.forEach(({ path, 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 timeout = 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");
-        }
+  }
+  return {
+    params,
+    httpCode,
+    headers,
+    middlewares,
+    beforeHooks,
+    afterHooks,
+    redirect,
+    contentType,
+    roles,
+    cache,
+    rateLimiter,
+    version,
+    methodVersion,
+    timeout,
+    logConfig
+  };
+}
+__name(getRouteMetadata, "getRouteMetadata");
+function calculateFinalPath(path, routeMetadata, controllerMetadata) {
+  let finalPath = path;
+  if (routeMetadata.methodVersion?.options?.addPrefix && routeMetadata.methodVersion.version !== controllerMetadata.version?.version) {
+    finalPath = `/${routeMetadata.methodVersion.version}${path}`;
+  }
+  return finalPath;
+}
+__name(calculateFinalPath, "calculateFinalPath");
+function createRouteHandler(instance, handlerName, routeMetadata) {
+  return async (req, res, next) => {
+    req["startTime"] = Date.now();
+    const timeoutState = setupTimeout(req, res, routeMetadata.timeout);
+    try {
+      if (timeoutState.timedOut) return;
+      if (routeMetadata.rateLimiter) {
+        await applyRateLimiting(req, res, routeMetadata.rateLimiter);
       }
-      let finalPath = path;
-      if (methodVersion?.options?.addPrefix && methodVersion.version !== controllerVersion?.version) {
-        finalPath = `/${methodVersion.version}${path}`;
+      applyResponseHeaders(res, routeMetadata);
+      logRouteEntry(req, routeMetadata.logConfig);
+      if (!checkRoles(req, res, routeMetadata.roles, timeoutState)) {
+        return;
       }
-      const handler = /* @__PURE__ */ __name(async (req, res, next) => {
-        req["startTime"] = Date.now();
-        let timeoutId;
-        let timedOut = false;
-        try {
-          if (timeout) {
-            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);
-              }
-            }, timeout.ms);
-          }
-          if (timedOut) return;
-          if (rateLimiter) {
-            await new Promise((resolve, reject) => {
-              rateLimiter(req, res, (err) => {
-                if (err) reject(err);
-                else resolve();
-              });
-            });
-          }
-          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 logger = 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;
-            logger.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?.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 logger = 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;
-            logger.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);
+      if (routeMetadata.redirect?.url) {
+        clearTimeout(timeoutState.timeoutId);
+        return res.redirect(routeMetadata.redirect.statusCode, routeMetadata.redirect.url);
+      }
+      for (const fn of routeMetadata.beforeHooks) await fn(req, res);
+      const args = extractHandlerArgs(req, res, routeMetadata.params);
+      const result = instance[handlerName](...args);
+      const awaited = result instanceof Promise ? await result : result;
+      clearTimeout(timeoutState.timeoutId);
+      if (timeoutState.timedOut) return;
+      if (handleDynamicRedirect(res, routeMetadata.redirect, awaited)) {
+        return;
+      }
+      sendResponse(res, awaited, routeMetadata.httpCode, routeMetadata.headers);
+      logRouteExit(req, res, awaited, routeMetadata.logConfig);
+      for (const fn of routeMetadata.afterHooks) await fn(req, res, awaited);
+    } catch (err) {
+      clearTimeout(timeoutState.timeoutId);
+      next(err);
+    }
+  };
+}
+__name(createRouteHandler, "createRouteHandler");
+function setupTimeout(req, res, timeout) {
+  const state = {
+    timeoutId: void 0,
+    timedOut: false
+  };
+  if (timeout) {
+    state.timeoutId = setTimeout(() => {
+      if (!res.headersSent && !state.timedOut) {
+        state.timedOut = true;
+        const errorResponse = createFinalErrorResponse(req, HttpStatusCodes.REQUEST_TIMEOUT, "Request timed out");
+        res.status(HttpStatusCodes.REQUEST_TIMEOUT).json(errorResponse);
+      }
+    }, timeout.ms);
+  }
+  return state;
+}
+__name(setupTimeout, "setupTimeout");
+async function applyRateLimiting(req, res, rateLimiter) {
+  await new Promise((resolve, reject) => {
+    rateLimiter(req, res, (err) => {
+      if (err) reject(err);
+      else resolve();
     });
   });
 }
-__name(registerControllers, "registerControllers");
+__name(applyRateLimiting, "applyRateLimiting");
+function applyResponseHeaders(res, routeMetadata) {
+  if (!res.headersSent && routeMetadata.contentType) {
+    res.setHeader("Content-Type", routeMetadata.contentType.type);
+  }
+  if (routeMetadata.version?.options?.addHeader && routeMetadata.version?.options?.headerName && routeMetadata.version?.version) {
+    if (!res.headersSent) {
+      res.setHeader(routeMetadata.version.options.headerName, routeMetadata.version.version);
+    }
+  }
+  if (routeMetadata.cache && !res.headersSent) {
+    res.setHeader("Cache-Control", `public, max-age=${routeMetadata.cache.ttlSeconds}`);
+  }
+}
+__name(applyResponseHeaders, "applyResponseHeaders");
+function logRouteEntry(req, logConfig) {
+  if (logConfig?.logEntry) {
+    const logger = 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;
+    logger.info({
+      entry: logData
+    }, "Route Entry:");
+  }
+}
+__name(logRouteEntry, "logRouteEntry");
+function logRouteExit(req, res, result, logConfig) {
+  if (logConfig?.logExit) {
+    const logger = 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 = result;
+    logger.info({
+      exit: logData
+    }, "Route Exit:");
+  }
+}
+__name(logRouteExit, "logRouteExit");
+function checkRoles(req, res, roles, timeoutState) {
+  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);
+    clearTimeout(timeoutState.timeoutId);
+    return false;
+  }
+  return true;
+}
+__name(checkRoles, "checkRoles");
+function extractHandlerArgs(req, res, params) {
+  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;
+      }
+    });
+  }
+  return args;
+}
+__name(extractHandlerArgs, "extractHandlerArgs");
+function handleDynamicRedirect(res, redirect, result) {
+  if (redirect && result && typeof result === "object" && "url" in result) {
+    const redirectUrl = result.url;
+    const redirectStatus = result.statusCode || redirect.statusCode;
+    res.redirect(redirectStatus, redirectUrl);
+    return true;
+  }
+  return false;
+}
+__name(handleDynamicRedirect, "handleDynamicRedirect");
+function sendResponse(res, result, httpCode, headers) {
+  if (!res.headersSent && result !== void 0) {
+    if (httpCode) res.status(httpCode);
+    for (const [k, v] of Object.entries(headers)) {
+      const normalized = normalizeHeaderValue(v);
+      if (normalized !== void 0) {
+        res.set(k, normalized);
+      }
+    }
+    res.json(result);
+  }
+}
+__name(sendResponse, "sendResponse");
 function applyParamOptions(rawValue, options, key) {
   if (!options) return rawValue;
   let value = rawValue;
@@ -1844,98 +1930,11 @@ function applyParamOptions(rawValue, options, key) {
   }
   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) => Number.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"));
-      }
+      value = handleArrayParam(value, options, key);
     } 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}`);
-          }
-        }
-      }
+      value = handleObjectParam(value, options, key);
     } 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;
-          }
-        }
-      }
-      const paramNotMatchMsg = `Parameter '${key}' does not match pattern: ${options.patternName || options.pattern}`;
-      if (options.type === "string" && options.pattern && typeof value === "string" && !options.pattern.test(value)) {
-        throw new BadRequestException(paramNotMatchMsg);
-      } else if (options.type === "number" && options.pattern && typeof value === "number" && !options.pattern.test(String(value))) {
-        throw new BadRequestException(paramNotMatchMsg);
-      }
-      if (options.throwError !== false) {
-        if (options.type === "number" && typeof value === "number" && 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}`);
-        }
-      }
+      value = handleSingleParam(value, options, key);
     }
   }
   if (options.transform && typeof options.transform === "function") {
@@ -1952,6 +1951,128 @@ function applyParamOptions(rawValue, options, key) {
   return value;
 }
 __name(applyParamOptions, "applyParamOptions");
+function handleArrayParam(value, options, key) {
+  const delimiter = options.delimiter || ",";
+  if (typeof value === "string") {
+    value = value.split(delimiter).map((v) => v.trim());
+  } else if (!Array.isArray(value)) {
+    value = [
+      value
+    ];
+  }
+  validateArrayPattern(value, options, key);
+  validateArrayElements(value, options, key);
+  if (options.type) {
+    value = value.map((v) => convertType(v, options.type || "string"));
+  }
+  return value;
+}
+__name(handleArrayParam, "handleArrayParam");
+function validateArrayPattern(value, options, key) {
+  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}`);
+    }
+  }
+}
+__name(validateArrayPattern, "validateArrayPattern");
+function validateArrayElements(value, options, key) {
+  const paramName = key ? `: ${key}` : "";
+  if (options.type === "number" && options.throwError !== false) {
+    const hasInvalidNumber = value.some((v) => Number.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}`);
+    }
+  }
+}
+__name(validateArrayElements, "validateArrayElements");
+function handleObjectParam(value, options, key) {
+  const paramName = key ? `: ${key}` : "";
+  if (typeof value === "string") {
+    try {
+      value = JSON.parse(value);
+    } catch (_e) {
+      if (options.throwError !== false) {
+        throw new BadRequestException(`Invalid JSON object${paramName}`);
+      }
+    }
+  }
+  return value;
+}
+__name(handleObjectParam, "handleObjectParam");
+function handleSingleParam(value, options, key) {
+  const paramName = key ? `: ${key}` : "";
+  const originalValue = value;
+  const targetType = options.type ?? "string";
+  value = convertType(value, targetType);
+  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;
+      }
+    }
+  }
+  validateSinglePattern(value, options, key);
+  validateSingleType(value, originalValue, options, paramName);
+  return value;
+}
+__name(handleSingleParam, "handleSingleParam");
+function validateSinglePattern(value, options, key) {
+  const paramNotMatchMsg = `Parameter '${key}' does not match pattern: ${options.patternName || options.pattern}`;
+  if (options.type === "string" && options.pattern && typeof value === "string" && !options.pattern.test(value)) {
+    throw new BadRequestException(paramNotMatchMsg);
+  } else if (options.type === "number" && options.pattern && typeof value === "number" && !options.pattern.test(String(value))) {
+    throw new BadRequestException(paramNotMatchMsg);
+  }
+}
+__name(validateSinglePattern, "validateSinglePattern");
+function validateSingleType(value, originalValue, options, paramName) {
+  if (options.throwError !== false) {
+    if (options.type === "number" && typeof value === "number" && 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}`);
+    }
+  }
+}
+__name(validateSingleType, "validateSingleType");
 function isValidBooleanInput(value) {
   if (typeof value === "boolean") return true;
   if (typeof value === "number") return value === 0 || value === 1;