@catbee/utils 1.0.1 → 1.0.3

package/build/index.mjs

@@ -9,6 +9,7 @@ import { rateLimit as rateLimit$1 } from 'express-rate-limit';
 import os, { tmpdir } from 'os';
 import fsp from 'fs/promises';
 import { pipeline } from 'stream/promises';
+import { Readable, Transform } from 'stream';
 import { URL as URL$1, URLSearchParams } from 'url';
 import express from 'express';
 import https from 'https';
@@ -1060,6 +1061,10 @@ var config = {
     */
     pretty: Env.getBoolean("LOGGER_PRETTY", true),
     /**
+    * Enables colorized output for pretty-print (default: true)
+    */
+    colorize: Env.getBoolean("LOGGER_PRETTY_COLORIZE", true),
+    /**
     * Single line output for pretty-print (default: false)
     */
     singleLine: Env.getBoolean("LOGGER_PRETTY_SINGLE_LINE", false)
@@ -1069,6 +1074,20 @@ var config = {
     * Default TTL (time to live) for cache entries in seconds
     */
     defaultTtl: Env.getNumber("CACHE_DEFAULT_TTL_SECONDS", 3600) * 1e3
+  },
+  server: {
+    /**
+    * Skip healthz endpoint even if health checks are configured
+    * Default: false
+    * Set to true to return 200 OK for /healthz without checks
+    * Useful in environments where a simple liveness probe is needed
+    * without performing actual health checks
+    * Example: Kubernetes liveness probe
+    * Note: This does not disable the health check functionality itself
+    *       Health checks can still be performed programmatically
+    *       or via other endpoints if needed
+    */
+    skipHealthz: Env.getBoolean("SERVER_SKIP_HEALTHZ", false)
   }
 };
 var defaultServerConfig = {
@@ -1672,10 +1691,10 @@ function setupLogger(isGlobal = true) {
     },
     timestamp: stdTimeFunctions.isoTime
   };
-  const logger2 = config.logger.pretty && Env.isDev() ? pino(logParams, pino.transport({
+  const logger2 = config.logger.pretty ? pino(logParams, pino.transport({
     target: "pino-pretty",
     options: {
-      colorize: true,
+      colorize: config.logger.colorize,
       translateTime: "SYS:standard",
       ignore: "pid,hostname",
       singleLine: config.logger.singleLine,
@@ -2492,6 +2511,234 @@ function verifySignedToken(token, secret) {
 }
 __name(verifySignedToken, "verifySignedToken");
 
+// src/utils/date.utils.ts
+function formatDate(date, options = {}) {
+  const { format = "yyyy-MM-dd", locale, timeZone } = options;
+  const d = date instanceof Date ? date : new Date(date);
+  if (format === "yyyy-MM-dd") {
+    const yyyy = d.getFullYear();
+    const mm = String(d.getMonth() + 1).padStart(2, "0");
+    const dd = String(d.getDate()).padStart(2, "0");
+    return `${yyyy}-${mm}-${dd}`;
+  }
+  if (format === "yyyy-MM-dd HH:mm:ss") {
+    const yyyy = d.getFullYear();
+    const mm = String(d.getMonth() + 1).padStart(2, "0");
+    const dd = String(d.getDate()).padStart(2, "0");
+    const HH = String(d.getHours()).padStart(2, "0");
+    const MM = String(d.getMinutes()).padStart(2, "0");
+    const SS = String(d.getSeconds()).padStart(2, "0");
+    return `${yyyy}-${mm}-${dd} ${HH}:${MM}:${SS}`;
+  }
+  if (format === "relative") {
+    return formatRelativeTime(date);
+  }
+  return new Intl.DateTimeFormat(locale, {
+    timeZone,
+    year: format.includes("yyyy") || format.includes("y") ? "numeric" : void 0,
+    month: format.includes("MM") || format.includes("M") ? "numeric" : void 0,
+    day: format.includes("dd") || format.includes("d") ? "numeric" : void 0,
+    hour: format.includes("HH") || format.includes("H") ? "numeric" : void 0,
+    minute: format.includes("mm") || format.includes("m") ? "numeric" : void 0,
+    second: format.includes("ss") || format.includes("s") ? "numeric" : void 0,
+    hour12: !format.includes("HH") && !format.includes("H")
+  }).format(d);
+}
+__name(formatDate, "formatDate");
+function formatRelativeTime(date, now = /* @__PURE__ */ new Date(), locale) {
+  const d1 = date instanceof Date ? date : new Date(date);
+  const d2 = now instanceof Date ? now : new Date(now);
+  const diffMs = d1.getTime() - d2.getTime();
+  const diffSecs = Math.round(diffMs / 1e3);
+  const diffMins = Math.round(diffSecs / 60);
+  const diffHours = Math.round(diffMins / 60);
+  const diffDays = Math.round(diffHours / 24);
+  const diffMonths = Math.round(diffDays / 30);
+  const diffYears = Math.round(diffDays / 365);
+  const formatter = new Intl.RelativeTimeFormat(locale, {
+    numeric: "auto"
+  });
+  if (Math.abs(diffSecs) < 60) return formatter.format(diffSecs, "second");
+  if (Math.abs(diffMins) < 60) return formatter.format(diffMins, "minute");
+  if (Math.abs(diffHours) < 24) return formatter.format(diffHours, "hour");
+  if (Math.abs(diffDays) < 30) return formatter.format(diffDays, "day");
+  if (Math.abs(diffMonths) < 12) return formatter.format(diffMonths, "month");
+  return formatter.format(diffYears, "year");
+}
+__name(formatRelativeTime, "formatRelativeTime");
+function parseDate(input, fallback) {
+  if (typeof input === "number") {
+    return new Date(input);
+  }
+  try {
+    const date = new Date(input);
+    if (isNaN(date.getTime())) {
+      return fallback || null;
+    }
+    return date;
+  } catch {
+    return fallback || null;
+  }
+}
+__name(parseDate, "parseDate");
+function dateDiff(date1, date2 = /* @__PURE__ */ new Date(), unit = "days") {
+  const d1 = date1 instanceof Date ? date1 : new Date(date1);
+  const d2 = date2 instanceof Date ? date2 : new Date(date2);
+  const diffMs = d1.getTime() - d2.getTime();
+  switch (unit) {
+    case "milliseconds":
+      return diffMs;
+    case "seconds":
+      return diffMs / 1e3;
+    case "minutes":
+      return diffMs / (1e3 * 60);
+    case "hours":
+      return diffMs / (1e3 * 60 * 60);
+    case "days":
+      return diffMs / (1e3 * 60 * 60 * 24);
+    case "months":
+      return (d1.getFullYear() - d2.getFullYear()) * 12 + d1.getMonth() - d2.getMonth();
+    case "years":
+      return d1.getFullYear() - d2.getFullYear();
+    default:
+      throw new Error(`Unsupported unit: ${unit}`);
+  }
+}
+__name(dateDiff, "dateDiff");
+function addToDate(date, amount, unit) {
+  const d = date instanceof Date ? new Date(date) : new Date(date);
+  switch (unit) {
+    case "milliseconds":
+      d.setMilliseconds(d.getMilliseconds() + amount);
+      break;
+    case "seconds":
+      d.setSeconds(d.getSeconds() + amount);
+      break;
+    case "minutes":
+      d.setMinutes(d.getMinutes() + amount);
+      break;
+    case "hours":
+      d.setHours(d.getHours() + amount);
+      break;
+    case "days":
+      d.setDate(d.getDate() + amount);
+      break;
+    case "months": {
+      const origDate = d.getDate();
+      const origMonth = d.getMonth();
+      d.setDate(1);
+      d.setMonth(origMonth + amount);
+      const lastDay = new Date(d.getFullYear(), d.getMonth() + 1, 0).getDate();
+      d.setDate(Math.min(origDate, lastDay));
+      break;
+    }
+    case "years":
+      d.setFullYear(d.getFullYear() + amount);
+      break;
+    default:
+      throw new Error(`Unsupported unit: ${unit}`);
+  }
+  return d;
+}
+__name(addToDate, "addToDate");
+function startOf(date, unit) {
+  const d = date instanceof Date ? new Date(date) : new Date(date);
+  switch (unit) {
+    case "second":
+      d.setMilliseconds(0);
+      break;
+    case "minute":
+      d.setSeconds(0, 0);
+      break;
+    case "hour":
+      d.setMinutes(0, 0, 0);
+      break;
+    case "day":
+      d.setHours(0, 0, 0, 0);
+      break;
+    case "week":
+      d.setHours(0, 0, 0, 0);
+      d.setDate(d.getDate() - d.getDay());
+      break;
+    case "month":
+      d.setDate(1);
+      d.setHours(0, 0, 0, 0);
+      break;
+    case "quarter":
+      d.setMonth(Math.floor(d.getMonth() / 3) * 3, 1);
+      d.setHours(0, 0, 0, 0);
+      break;
+    case "year":
+      d.setMonth(0, 1);
+      d.setHours(0, 0, 0, 0);
+      break;
+    default:
+      throw new Error(`Unsupported unit: ${unit}`);
+  }
+  return d;
+}
+__name(startOf, "startOf");
+function endOf(date, unit) {
+  const d = date instanceof Date ? new Date(date) : new Date(date);
+  switch (unit) {
+    case "second":
+      d.setMilliseconds(999);
+      break;
+    case "minute":
+      d.setSeconds(59, 999);
+      break;
+    case "hour":
+      d.setMinutes(59, 59, 999);
+      break;
+    case "day":
+      d.setHours(23, 59, 59, 999);
+      break;
+    case "week":
+      d.setDate(d.getDate() - d.getDay() + 6);
+      d.setHours(23, 59, 59, 999);
+      break;
+    case "month":
+      d.setMonth(d.getMonth() + 1, 0);
+      d.setHours(23, 59, 59, 999);
+      break;
+    case "quarter":
+      d.setMonth(Math.floor(d.getMonth() / 3) * 3 + 3, 0);
+      d.setHours(23, 59, 59, 999);
+      break;
+    case "year":
+      d.setMonth(11, 31);
+      d.setHours(23, 59, 59, 999);
+      break;
+    default:
+      throw new Error(`Unsupported unit: ${unit}`);
+  }
+  return d;
+}
+__name(endOf, "endOf");
+function isBetween(date, start, end, inclusive = true) {
+  const d = date instanceof Date ? date.getTime() : date;
+  const s = start instanceof Date ? start.getTime() : start;
+  const e = end instanceof Date ? end.getTime() : end;
+  return inclusive ? d >= s && d <= e : d > s && d < e;
+}
+__name(isBetween, "isBetween");
+function isLeapYear(year) {
+  const y = year instanceof Date ? year.getFullYear() : year;
+  return y % 4 === 0 && y % 100 !== 0 || y % 400 === 0;
+}
+__name(isLeapYear, "isLeapYear");
+function daysInMonth(year, month) {
+  if (year instanceof Date) {
+    month = year.getMonth();
+    year = year.getFullYear();
+  }
+  if (month === void 0) {
+    throw new Error("Month is required when year is a number");
+  }
+  return new Date(year, month + 1, 0).getDate();
+}
+__name(daysInMonth, "daysInMonth");
+
 // src/utils/response.utils.ts
 var SuccessResponse = class {
   static {
@@ -3515,7 +3762,7 @@ function registerControllers(router, controllers) {
       diContainer.register(ControllerClass);
     }
     const instance = diContainer.get(ControllerClass);
-    const basePath = Reflect.getMetadata("basePath", 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);
@@ -3528,6 +3775,9 @@ function registerControllers(router, controllers) {
     const controllerBeforeHooks = Reflect.getMetadata(BEFORE_KEY, ControllerClass) || [];
     const controllerAfterHooks = Reflect.getMetadata(AFTER_KEY, ControllerClass) || [];
     const controllerContentType = Reflect.getMetadata(CONTENT_TYPE_KEY, ControllerClass);
+    if (controllerVersion?.options?.addPrefix) {
+      basePath = `/${controllerVersion.version}${basePath || ""}`;
+    }
     routes.forEach(({ path: path3, method, handlerName }) => {
       const methodMiddlewares = Reflect.getMetadata(MIDDLEWARE_KEY, instance, handlerName) || [];
       const params = Reflect.getMetadata(PARAMS_KEY, instance, handlerName) || [];
@@ -3557,7 +3807,8 @@ function registerControllers(router, controllers) {
       const roles = Reflect.getMetadata(ROLES_KEY, instance, handlerName) || controllerRoles || [];
       const cache = Reflect.getMetadata(CACHE_KEY, instance, handlerName) || controllerCache;
       const rateLimitOptions = Reflect.getMetadata(RATE_LIMIT_KEY, instance, handlerName) || controllerRateLimit;
-      const version = Reflect.getMetadata(VERSION_KEY, instance, handlerName) || controllerVersion;
+      const methodVersion = Reflect.getMetadata(VERSION_KEY, instance, handlerName);
+      const version = methodVersion || controllerVersion;
       const timeout2 = Reflect.getMetadata(TIMEOUT_KEY, instance, handlerName) || controllerTimeout;
       const logConfig = Reflect.getMetadata(LOG_KEY, instance, handlerName) || controllerLogConfig;
       let rateLimiter = null;
@@ -3571,8 +3822,8 @@ function registerControllers(router, controllers) {
         }
       }
       let finalPath = path3;
-      if (version?.options?.addPrefix) {
-        finalPath = `/${version.version}${path3}`;
+      if (methodVersion?.options?.addPrefix && methodVersion.version !== controllerVersion?.version) {
+        finalPath = `/${methodVersion.version}${path3}`;
       }
       const handler = /* @__PURE__ */ __name(async (req, res, next) => {
         req["startTime"] = Date.now();
@@ -4561,6 +4812,202 @@ function healthCheck(options) {
 }
 __name(healthCheck, "healthCheck");
 
+// src/utils/performance.utils.ts
+function timeSync(fn, options = {}) {
+  const { label = fn.name || "anonymous function", log = false, logLevel = "debug" } = options;
+  const startTime = performance.now();
+  const result = fn();
+  const endTime = performance.now();
+  const durationMs = endTime - startTime;
+  const durationSec = durationMs / 1e3;
+  const timing = {
+    durationMs,
+    durationSec,
+    startTime,
+    endTime,
+    label
+  };
+  if (log) {
+    const logger2 = getLogger();
+    const message = `${label} completed in ${durationMs.toFixed(2)}ms`;
+    switch (logLevel) {
+      case "trace":
+        logger2.trace({
+          timing
+        }, message);
+        break;
+      case "debug":
+        logger2.debug({
+          timing
+        }, message);
+        break;
+      case "info":
+        logger2.info({
+          timing
+        }, message);
+        break;
+      case "warn":
+        logger2.warn({
+          timing
+        }, message);
+        break;
+      case "error":
+        logger2.error({
+          timing
+        }, message);
+        break;
+      default:
+        logger2.debug({
+          timing
+        }, message);
+        break;
+    }
+  }
+  return {
+    result,
+    timing
+  };
+}
+__name(timeSync, "timeSync");
+async function timeAsync(fn, options = {}) {
+  const { label = fn.name || "anonymous async function", log = false, logLevel = "debug" } = options;
+  const startTime = performance.now();
+  const result = await fn();
+  const endTime = performance.now();
+  const durationMs = endTime - startTime;
+  const durationSec = durationMs / 1e3;
+  const timing = {
+    durationMs,
+    durationSec,
+    startTime,
+    endTime,
+    label
+  };
+  if (log) {
+    const logger2 = getLogger();
+    const message = `${label} completed in ${durationMs.toFixed(2)}ms`;
+    switch (logLevel) {
+      case "trace":
+        logger2.trace({
+          timing
+        }, message);
+        break;
+      case "debug":
+        logger2.debug({
+          timing
+        }, message);
+        break;
+      case "info":
+        logger2.info({
+          timing
+        }, message);
+        break;
+      case "warn":
+        logger2.warn({
+          timing
+        }, message);
+        break;
+      case "error":
+        logger2.error({
+          timing
+        }, message);
+        break;
+      default:
+        logger2.debug({
+          timing
+        }, message);
+        break;
+    }
+  }
+  return {
+    result,
+    timing
+  };
+}
+__name(timeAsync, "timeAsync");
+function timed(options = {}) {
+  return function(target, propertyKeyOrContext, descriptor) {
+    let propertyKey;
+    let actualDescriptor;
+    if (typeof propertyKeyOrContext === "object" && propertyKeyOrContext !== null && "name" in propertyKeyOrContext) {
+      propertyKey = propertyKeyOrContext.name;
+      actualDescriptor = descriptor ?? Object.getOwnPropertyDescriptor(target, propertyKey);
+    } else {
+      propertyKey = propertyKeyOrContext;
+      actualDescriptor = descriptor ?? Object.getOwnPropertyDescriptor(target, propertyKey);
+    }
+    const originalMethod = actualDescriptor.value;
+    actualDescriptor.value = function(...args) {
+      const methodOptions = {
+        ...options,
+        label: options.label || `${target.constructor.name}.${String(propertyKey)}`
+      };
+      if (originalMethod.constructor.name === "AsyncFunction") {
+        return timeAsync(() => originalMethod.apply(this, args), methodOptions).then(({ result }) => result);
+      } else {
+        return timeSync(() => originalMethod.apply(this, args), methodOptions).result;
+      }
+    };
+    if (descriptor) {
+      descriptor.value = actualDescriptor.value;
+    } else {
+      Object.defineProperty(target, propertyKey, actualDescriptor);
+    }
+  };
+}
+__name(timed, "timed");
+function memoize(fn, options = {}) {
+  const { ttl, maxSize, autoCleanupMs, cacheKey = /* @__PURE__ */ __name((...args) => JSON.stringify(args), "cacheKey") } = options;
+  const cache = new TTLCache({
+    ttlMs: ttl,
+    maxSize,
+    autoCleanupMs
+  });
+  return function(...args) {
+    const key = cacheKey(...args);
+    const cachedValue = cache.get(key);
+    if (cachedValue !== void 0) {
+      return cachedValue;
+    }
+    const value = fn(...args);
+    cache.set(key, value);
+    return value;
+  };
+}
+__name(memoize, "memoize");
+function trackMemoryUsage(fn, options = {}) {
+  const { log = false, label = fn.name || "anonymous function" } = options;
+  if (global.gc) {
+    global.gc();
+  }
+  const beforeMemory = process.memoryUsage();
+  const result = fn();
+  const afterMemory = process.memoryUsage();
+  const diff = {};
+  for (const key in afterMemory) {
+    if (Object.prototype.hasOwnProperty.call(afterMemory, key)) {
+      diff[key] = afterMemory[key] - beforeMemory[key];
+    }
+  }
+  if (log) {
+    getLogger().info({
+      label,
+      memoryBefore: beforeMemory,
+      memoryAfter: afterMemory,
+      memoryDiff: diff
+    }, `Memory usage for ${label}`);
+  }
+  return {
+    result,
+    memoryUsage: {
+      before: beforeMemory,
+      after: afterMemory,
+      diff
+    }
+  };
+}
+__name(trackMemoryUsage, "trackMemoryUsage");
+
 // src/utils/request.utils.ts
 var getPaginationParams = /* @__PURE__ */ __name((req) => {
   const query = req.query;
@@ -4719,6 +5166,120 @@ function extractFilterParams(query, allowedFilters) {
   return filters;
 }
 __name(extractFilterParams, "extractFilterParams");
+function bufferToStream(data) {
+  const readable = new Readable();
+  readable.push(data);
+  readable.push(null);
+  return readable;
+}
+__name(bufferToStream, "bufferToStream");
+async function streamToBuffer(stream) {
+  return new Promise((resolve2, reject) => {
+    const chunks = [];
+    stream.on("data", (chunk2) => chunks.push(Buffer.isBuffer(chunk2) ? chunk2 : Buffer.from(chunk2)));
+    stream.on("end", () => resolve2(Buffer.concat(chunks)));
+    stream.on("error", reject);
+  });
+}
+__name(streamToBuffer, "streamToBuffer");
+async function streamToString(stream, encoding = "utf8") {
+  const buffer = await streamToBuffer(stream);
+  return buffer.toString(encoding);
+}
+__name(streamToString, "streamToString");
+function createThrottleStream(bytesPerSecond) {
+  let bytesSent = 0;
+  let startTime = Date.now();
+  return new Transform({
+    transform(chunk2, _encoding, callback) {
+      const elapsedSeconds = (Date.now() - startTime) / 1e3;
+      const targetBytes = bytesPerSecond * elapsedSeconds;
+      const chunkSize = chunk2.length;
+      if (bytesSent + chunkSize <= targetBytes) {
+        bytesSent += chunkSize;
+        callback(null, chunk2);
+        return;
+      }
+      const delay = ((bytesSent + chunkSize) / bytesPerSecond - elapsedSeconds) * 1e3;
+      setTimeout(() => {
+        bytesSent += chunkSize;
+        callback(null, chunk2);
+      }, delay);
+    }
+  });
+}
+__name(createThrottleStream, "createThrottleStream");
+function createBatchStream(size, options = {}) {
+  const objectMode = options.objectMode !== false;
+  let batch = [];
+  let buffers = [];
+  let bufferSize = 0;
+  return new Transform({
+    objectMode,
+    transform(chunk2, _encoding, callback) {
+      if (objectMode) {
+        batch.push(chunk2);
+        if (batch.length >= size) {
+          this.push(batch);
+          batch = [];
+        }
+      } else {
+        const buffer = Buffer.isBuffer(chunk2) ? chunk2 : Buffer.from(chunk2);
+        buffers.push(buffer);
+        bufferSize += buffer.length;
+        let combined = Buffer.concat(buffers, bufferSize);
+        while (combined.length >= size) {
+          this.push(combined.slice(0, size));
+          combined = combined.slice(size);
+        }
+        buffers = combined.length > 0 ? [
+          combined
+        ] : [];
+        bufferSize = combined.length;
+      }
+      callback();
+    },
+    flush(callback) {
+      if (objectMode && batch.length > 0) {
+        this.push(batch);
+      } else if (!objectMode && buffers.length > 0 && bufferSize > 0) {
+        let combined = Buffer.concat(buffers, bufferSize);
+        while (combined.length >= size) {
+          this.push(combined.slice(0, size));
+          combined = combined.slice(size);
+        }
+        if (combined.length > 0) {
+          this.push(combined);
+        }
+      }
+      callback();
+    }
+  });
+}
+__name(createBatchStream, "createBatchStream");
+function createLineStream(options = {}) {
+  const { encoding = "utf8", includeNewlines = false } = options;
+  let buffer = "";
+  return new Transform({
+    objectMode: true,
+    transform(chunk2, _encoding, callback) {
+      const str = buffer + (Buffer.isBuffer(chunk2) ? chunk2.toString(encoding) : chunk2);
+      const lines = str.split(/\r?\n/);
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        this.push(includeNewlines ? line + "\n" : line);
+      }
+      callback();
+    },
+    flush(callback) {
+      if (buffer) {
+        this.push(buffer);
+      }
+      callback();
+    }
+  });
+}
+__name(createLineStream, "createLineStream");
 
 // src/utils/string.utils.ts
 function capitalize(str) {
@@ -4778,6 +5339,84 @@ function countOccurrences(str, substring, caseSensitive = true) {
   return str.split(substring).length - 1;
 }
 __name(countOccurrences, "countOccurrences");
+
+// src/utils/type.utils.ts
+function isPrimitiveType(value, type) {
+  if (type === "array") {
+    return Array.isArray(value);
+  }
+  if (type === "null") {
+    return value === null;
+  }
+  if (type === "undefined") {
+    return value === void 0;
+  }
+  if (type === "object") {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+  return typeof value === type;
+}
+__name(isPrimitiveType, "isPrimitiveType");
+function getTypeOf(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (Array.isArray(value)) return "array";
+  return typeof value;
+}
+__name(getTypeOf, "getTypeOf");
+function isArrayOf(value, itemTypeGuard) {
+  if (!Array.isArray(value)) return false;
+  return value.every((item) => itemTypeGuard(item));
+}
+__name(isArrayOf, "isArrayOf");
+function toStr(value, defaultValue = "") {
+  if (value === null || value === void 0) return defaultValue;
+  try {
+    if (typeof value === "object") {
+      return JSON.stringify(value);
+    }
+    return String(value);
+  } catch {
+    return defaultValue;
+  }
+}
+__name(toStr, "toStr");
+function toNum(value, defaultValue = 0) {
+  if (value === null || value === void 0) return defaultValue;
+  if (typeof value === "number") return value;
+  try {
+    const num = Number(value);
+    return isNaN(num) ? defaultValue : num;
+  } catch {
+    return defaultValue;
+  }
+}
+__name(toNum, "toNum");
+function toBool(value, defaultValue = false) {
+  if (value === null || value === void 0) return defaultValue;
+  if (typeof value === "boolean") return value;
+  if (typeof value === "string") {
+    const lowercased = value.toLowerCase();
+    if (lowercased === "true" || lowercased === "yes" || lowercased === "y" || lowercased === "1") {
+      return true;
+    }
+    if (lowercased === "false" || lowercased === "no" || lowercased === "n" || lowercased === "0") {
+      return false;
+    }
+  }
+  if (typeof value === "number") {
+    return value !== 0;
+  }
+  return defaultValue;
+}
+__name(toBool, "toBool");
+function ensureType(value, expectedType, defaultValue) {
+  if (getTypeOf(value) === expectedType) {
+    return value;
+  }
+  return defaultValue;
+}
+__name(ensureType, "ensureType");
 function appendQueryParams(url, params) {
   const urlObj = new URL$1(url);
   for (const [key, value] of Object.entries(params)) {
@@ -6167,7 +6806,7 @@ var ExpressServer = class _ExpressServer {
     const healthCheckPath = this.normalizePath(this.config.healthCheck?.path || "/healthz", this.config.healthCheck?.withGlobalPrefix);
     this.app.get(healthCheckPath, async (_req, res) => {
       try {
-        if (!this.healthChecks.length) {
+        if (!this.healthChecks.length || config.server.skipHealthz) {
           return res.status(HttpStatusCodes.OK).json(new SuccessResponse("OK"));
         }
         const checkResults = await Promise.allSettled(this.healthChecks.map(async ({ name, check }) => {
@@ -6632,4 +7271,4 @@ var ExpressServer = class _ExpressServer {
   }
 };
 
-export { After, BUILD_MARKER, BadGatewayException, BadRequestException, Before, Body, Cache, CircuitBreakerOpenError, CircuitBreakerState, ConflictException, Connect, ContentType, ContextStore, Controller, DIContainer, Delete, Env, Environment, ErrorResponse, ExpressServer, ForbiddenException, GatewayTimeoutException, Get, Head, Header, Headers, HttpCode, HttpError, HttpStatusCodes, Inject, Injectable, InsufficientStorageException, InternalServerErrorException, Log, MethodNotAllowedException, NoContentResponse, NotAcceptableException, NotFoundException, Options, PaginatedResponse, Param, Patch, PayloadTooLargeException, Post, Put, Query, RateLimit, Redirect, RedirectResponse, Req, ReqCookie, ReqHeader, ReqId, ReqLogger, RequestTimeoutException, Res, Roles, ServerConfigBuilder, ServiceUnavailableException, SortDirection, StoreKeys, SuccessResponse, TTLCache, Timeout, TooManyRequestsException, Trace, TypedContextKey, UnauthorizedException, UnprocessableEntityException, UnsupportedMediaTypeException, Use, Version, _globalThis, abortable, addRedactFields, addSensitiveFields, appendQueryParams, appendTextFile, capitalize, chunk, circuitBreaker, compact, copyDir, copyFile, countBy, countOccurrences, createChildLogger, createDeferred, createDirectory, createErrorResponse, createFinalErrorResponse, createHttpError, createPaginatedResponse, createParamDecorator, createParamDecoratorWithoutParam, createRequestLogger, createSignedToken, createSuccessResponse, createTaskQueue, createTempDir, createTempFile, createUrlBuilder, debounce, decrypt, deepFreeze, deepObjMerge, defaultSensitiveFields, deleteDirRecursive, deleteFileIfExists, difference, emptyDir, encrypt, ensureDir, ensureEmptyDir, equalsIgnoreCase, errorHandler, extractFilterParams, extractPaginationParams, extractQueryParams, extractSortParams, fileExists, filterObject, findFilesByPattern, findInDir, findNewestFile, findOldestFile, flattenDeep, flattenObject, generateApiKey, generateRandomBytes, generateRandomBytesAsString, getAllPaths, getConfig, getDirSize, getDirStats, getDomain, getErrorMessage, getExtension, getFileSize, getFileStats, getFromContext, getLogger, getPaginationParams, getRedactCensor, getRequestId, getSubdirectories, getValueByPath, groupBy, hasErrorShape, hasRequiredProps, hash, healthCheck, hmac, inject, intersect, isAlpha, isAlphanumeric, isArray, isBase64, isCreditCard, isDateInRange, isDirectory, isEmail, isEqual, isFile, isHexColor, isHttpError, isIPv4, isIPv6, isISODate, isLengthBetween, isNumberBetween, isNumeric, isObjEmpty, isObject, isPhone, isPlainObject, isPort, isStrongPassword, isURL, isUUID, isValidJSON, isValidUrl, joinPaths, listFiles, logError, logger, mapObject, mask, matchesPattern, md5, memoizeAsync, mergeSort, moveDir, moveFile, nanoId, normalizeUrl, omit, parseBooleanParam, parseNumberParam, parseQueryString, parseTypedQueryParams, partition, pick, pluck, random, randomBase64, randomHex, randomInt, randomString, range, rateLimit, readDirectory, readFileBuffer, readJsonFile, readTextFile, redact, registerControllers, removeQueryParams, requestId, responseTime, retry, reverse, runInBatches, runInSeries, runWithConcurrency, safeCompare, safeReadJsonFile, sendResponse, setConfig, setRedactCensor, setSensitiveFields, setValueByPath, settleAll, setupRequestContext, sha1, sha256, sha256Hmac, shuffle, singletonAsync, sleep, slugify, streamFile, stripHtml, take, takeWhile, throttle, timeout, toCamelCase, toKebabCase, toPascalCase, toSnakeCase, truncate, unique, uuid, validateAll, verifySignedToken, walkDir, watchDir, watchDirRecursive, waterfall, withErrorHandling, withTimeout, writeJsonFile, writeTextFile, zip };
+export { After, BUILD_MARKER, BadGatewayException, BadRequestException, Before, Body, Cache, CircuitBreakerOpenError, CircuitBreakerState, ConflictException, Connect, ContentType, ContextStore, Controller, DIContainer, Delete, Env, Environment, ErrorResponse, ExpressServer, ForbiddenException, GatewayTimeoutException, Get, Head, Header, Headers, HttpCode, HttpError, HttpStatusCodes, Inject, Injectable, InsufficientStorageException, InternalServerErrorException, Log, MethodNotAllowedException, NoContentResponse, NotAcceptableException, NotFoundException, Options, PaginatedResponse, Param, Patch, PayloadTooLargeException, Post, Put, Query, RateLimit, Redirect, RedirectResponse, Req, ReqCookie, ReqHeader, ReqId, ReqLogger, RequestTimeoutException, Res, Roles, ServerConfigBuilder, ServiceUnavailableException, SortDirection, StoreKeys, SuccessResponse, TTLCache, Timeout, TooManyRequestsException, Trace, TypedContextKey, UnauthorizedException, UnprocessableEntityException, UnsupportedMediaTypeException, Use, Version, _globalThis, abortable, addRedactFields, addSensitiveFields, addToDate, appendQueryParams, appendTextFile, bufferToStream, capitalize, chunk, circuitBreaker, compact, copyDir, copyFile, countBy, countOccurrences, createBatchStream, createChildLogger, createDeferred, createDirectory, createErrorResponse, createFinalErrorResponse, createHttpError, createLineStream, createPaginatedResponse, createParamDecorator, createParamDecoratorWithoutParam, createRequestLogger, createSignedToken, createSuccessResponse, createTaskQueue, createTempDir, createTempFile, createThrottleStream, createUrlBuilder, dateDiff, daysInMonth, debounce, decrypt, deepFreeze, deepObjMerge, defaultSensitiveFields, deleteDirRecursive, deleteFileIfExists, difference, emptyDir, encrypt, endOf, ensureDir, ensureEmptyDir, ensureType, equalsIgnoreCase, errorHandler, extractFilterParams, extractPaginationParams, extractQueryParams, extractSortParams, fileExists, filterObject, findFilesByPattern, findInDir, findNewestFile, findOldestFile, flattenDeep, flattenObject, formatDate, formatRelativeTime, generateApiKey, generateRandomBytes, generateRandomBytesAsString, getAllPaths, getConfig, getDirSize, getDirStats, getDomain, getErrorMessage, getExtension, getFileSize, getFileStats, getFromContext, getLogger, getPaginationParams, getRedactCensor, getRequestId, getSubdirectories, getTypeOf, getValueByPath, groupBy, hasErrorShape, hasRequiredProps, hash, healthCheck, hmac, inject, intersect, isAlpha, isAlphanumeric, isArray, isArrayOf, isBase64, isBetween, isCreditCard, isDateInRange, isDirectory, isEmail, isEqual, isFile, isHexColor, isHttpError, isIPv4, isIPv6, isISODate, isLeapYear, isLengthBetween, isNumberBetween, isNumeric, isObjEmpty, isObject, isPhone, isPlainObject, isPort, isPrimitiveType, isStrongPassword, isURL, isUUID, isValidJSON, isValidUrl, joinPaths, listFiles, logError, logger, mapObject, mask, matchesPattern, md5, memoize, memoizeAsync, mergeSort, moveDir, moveFile, nanoId, normalizeUrl, omit, parseBooleanParam, parseDate, parseNumberParam, parseQueryString, parseTypedQueryParams, partition, pick, pluck, random, randomBase64, randomHex, randomInt, randomString, range, rateLimit, readDirectory, readFileBuffer, readJsonFile, readTextFile, redact, registerControllers, removeQueryParams, requestId, responseTime, retry, reverse, runInBatches, runInSeries, runWithConcurrency, safeCompare, safeReadJsonFile, sendResponse, setConfig, setRedactCensor, setSensitiveFields, setValueByPath, settleAll, setupRequestContext, sha1, sha256, sha256Hmac, shuffle, singletonAsync, sleep, slugify, startOf, streamFile, streamToBuffer, streamToString, stripHtml, take, takeWhile, throttle, timeAsync, timeSync, timed, timeout, toBool, toCamelCase, toKebabCase, toNum, toPascalCase, toSnakeCase, toStr, trackMemoryUsage, truncate, unique, uuid, validateAll, verifySignedToken, walkDir, watchDir, watchDirRecursive, waterfall, withErrorHandling, withTimeout, writeJsonFile, writeTextFile, zip };