@catbee/utils 1.0.1 → 1.0.3

package/build/index.cjs

@@ -11,6 +11,7 @@ var expressRateLimit = require('express-rate-limit');
 var os = require('os');
 var fsp = require('fs/promises');
 var promises = require('stream/promises');
+var stream = require('stream');
 var url = require('url');
 var express = require('express');
 var https = require('https');
@@ -1072,6 +1073,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)
@@ -1081,6 +1086,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 = {
@@ -1684,10 +1703,10 @@ function setupLogger(isGlobal = true) {
     },
     timestamp: pino.stdTimeFunctions.isoTime
   };
-  const logger2 = config.logger.pretty && Env.isDev() ? pino__default.default(logParams, pino__default.default.transport({
+  const logger2 = config.logger.pretty ? pino__default.default(logParams, pino__default.default.transport({
     target: "pino-pretty",
     options: {
-      colorize: true,
+      colorize: config.logger.colorize,
       translateTime: "SYS:standard",
       ignore: "pid,hostname",
       singleLine: config.logger.singleLine,
@@ -2504,6 +2523,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 {
@@ -3527,7 +3774,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);
@@ -3540,6 +3787,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) || [];
@@ -3569,7 +3819,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;
@@ -3583,8 +3834,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();
@@ -4573,6 +4824,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;
@@ -4731,6 +5178,120 @@ function extractFilterParams(query, allowedFilters) {
   return filters;
 }
 __name(extractFilterParams, "extractFilterParams");
+function bufferToStream(data) {
+  const readable = new stream.Readable();
+  readable.push(data);
+  readable.push(null);
+  return readable;
+}
+__name(bufferToStream, "bufferToStream");
+async function streamToBuffer(stream) {
+  return new Promise((resolve2, reject) => {
+    const chunks = [];
+    stream.on("data", (chunk2) => chunks.push(Buffer.isBuffer(chunk2) ? chunk2 : Buffer.from(chunk2)));
+    stream.on("end", () => resolve2(Buffer.concat(chunks)));
+    stream.on("error", reject);
+  });
+}
+__name(streamToBuffer, "streamToBuffer");
+async function streamToString(stream, encoding = "utf8") {
+  const buffer = await streamToBuffer(stream);
+  return buffer.toString(encoding);
+}
+__name(streamToString, "streamToString");
+function createThrottleStream(bytesPerSecond) {
+  let bytesSent = 0;
+  let startTime = Date.now();
+  return new stream.Transform({
+    transform(chunk2, _encoding, callback) {
+      const elapsedSeconds = (Date.now() - startTime) / 1e3;
+      const targetBytes = bytesPerSecond * elapsedSeconds;
+      const chunkSize = chunk2.length;
+      if (bytesSent + chunkSize <= targetBytes) {
+        bytesSent += chunkSize;
+        callback(null, chunk2);
+        return;
+      }
+      const delay = ((bytesSent + chunkSize) / bytesPerSecond - elapsedSeconds) * 1e3;
+      setTimeout(() => {
+        bytesSent += chunkSize;
+        callback(null, chunk2);
+      }, delay);
+    }
+  });
+}
+__name(createThrottleStream, "createThrottleStream");
+function createBatchStream(size, options = {}) {
+  const objectMode = options.objectMode !== false;
+  let batch = [];
+  let buffers = [];
+  let bufferSize = 0;
+  return new stream.Transform({
+    objectMode,
+    transform(chunk2, _encoding, callback) {
+      if (objectMode) {
+        batch.push(chunk2);
+        if (batch.length >= size) {
+          this.push(batch);
+          batch = [];
+        }
+      } else {
+        const buffer = Buffer.isBuffer(chunk2) ? chunk2 : Buffer.from(chunk2);
+        buffers.push(buffer);
+        bufferSize += buffer.length;
+        let combined = Buffer.concat(buffers, bufferSize);
+        while (combined.length >= size) {
+          this.push(combined.slice(0, size));
+          combined = combined.slice(size);
+        }
+        buffers = combined.length > 0 ? [
+          combined
+        ] : [];
+        bufferSize = combined.length;
+      }
+      callback();
+    },
+    flush(callback) {
+      if (objectMode && batch.length > 0) {
+        this.push(batch);
+      } else if (!objectMode && buffers.length > 0 && bufferSize > 0) {
+        let combined = Buffer.concat(buffers, bufferSize);
+        while (combined.length >= size) {
+          this.push(combined.slice(0, size));
+          combined = combined.slice(size);
+        }
+        if (combined.length > 0) {
+          this.push(combined);
+        }
+      }
+      callback();
+    }
+  });
+}
+__name(createBatchStream, "createBatchStream");
+function createLineStream(options = {}) {
+  const { encoding = "utf8", includeNewlines = false } = options;
+  let buffer = "";
+  return new stream.Transform({
+    objectMode: true,
+    transform(chunk2, _encoding, callback) {
+      const str = buffer + (Buffer.isBuffer(chunk2) ? chunk2.toString(encoding) : chunk2);
+      const lines = str.split(/\r?\n/);
+      buffer = lines.pop() || "";
+      for (const line of lines) {
+        this.push(includeNewlines ? line + "\n" : line);
+      }
+      callback();
+    },
+    flush(callback) {
+      if (buffer) {
+        this.push(buffer);
+      }
+      callback();
+    }
+  });
+}
+__name(createLineStream, "createLineStream");
 
 // src/utils/string.utils.ts
 function capitalize(str) {
@@ -4790,6 +5351,84 @@ function countOccurrences(str, substring, caseSensitive = true) {
   return str.split(substring).length - 1;
 }
 __name(countOccurrences, "countOccurrences");
+
+// src/utils/type.utils.ts
+function isPrimitiveType(value, type) {
+  if (type === "array") {
+    return Array.isArray(value);
+  }
+  if (type === "null") {
+    return value === null;
+  }
+  if (type === "undefined") {
+    return value === void 0;
+  }
+  if (type === "object") {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+  }
+  return typeof value === type;
+}
+__name(isPrimitiveType, "isPrimitiveType");
+function getTypeOf(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  if (Array.isArray(value)) return "array";
+  return typeof value;
+}
+__name(getTypeOf, "getTypeOf");
+function isArrayOf(value, itemTypeGuard) {
+  if (!Array.isArray(value)) return false;
+  return value.every((item) => itemTypeGuard(item));
+}
+__name(isArrayOf, "isArrayOf");
+function toStr(value, defaultValue = "") {
+  if (value === null || value === void 0) return defaultValue;
+  try {
+    if (typeof value === "object") {
+      return JSON.stringify(value);
+    }
+    return String(value);
+  } catch {
+    return defaultValue;
+  }
+}
+__name(toStr, "toStr");
+function toNum(value, defaultValue = 0) {
+  if (value === null || value === void 0) return defaultValue;
+  if (typeof value === "number") return value;
+  try {
+    const num = Number(value);
+    return isNaN(num) ? defaultValue : num;
+  } catch {
+    return defaultValue;
+  }
+}
+__name(toNum, "toNum");
+function toBool(value, defaultValue = false) {
+  if (value === null || value === void 0) return defaultValue;
+  if (typeof value === "boolean") return value;
+  if (typeof value === "string") {
+    const lowercased = value.toLowerCase();
+    if (lowercased === "true" || lowercased === "yes" || lowercased === "y" || lowercased === "1") {
+      return true;
+    }
+    if (lowercased === "false" || lowercased === "no" || lowercased === "n" || lowercased === "0") {
+      return false;
+    }
+  }
+  if (typeof value === "number") {
+    return value !== 0;
+  }
+  return defaultValue;
+}
+__name(toBool, "toBool");
+function ensureType(value, expectedType, defaultValue) {
+  if (getTypeOf(value) === expectedType) {
+    return value;
+  }
+  return defaultValue;
+}
+__name(ensureType, "ensureType");
 function appendQueryParams(url$1, params) {
   const urlObj = new url.URL(url$1);
   for (const [key, value] of Object.entries(params)) {
@@ -6179,7 +6818,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 }) => {
@@ -6720,8 +7359,10 @@ exports._globalThis = _globalThis;
 exports.abortable = abortable;
 exports.addRedactFields = addRedactFields;
 exports.addSensitiveFields = addSensitiveFields;
+exports.addToDate = addToDate;
 exports.appendQueryParams = appendQueryParams;
 exports.appendTextFile = appendTextFile;
+exports.bufferToStream = bufferToStream;
 exports.capitalize = capitalize;
 exports.chunk = chunk;
 exports.circuitBreaker = circuitBreaker;
@@ -6730,12 +7371,14 @@ exports.copyDir = copyDir;
 exports.copyFile = copyFile;
 exports.countBy = countBy;
 exports.countOccurrences = countOccurrences;
+exports.createBatchStream = createBatchStream;
 exports.createChildLogger = createChildLogger;
 exports.createDeferred = createDeferred;
 exports.createDirectory = createDirectory;
 exports.createErrorResponse = createErrorResponse;
 exports.createFinalErrorResponse = createFinalErrorResponse;
 exports.createHttpError = createHttpError;
+exports.createLineStream = createLineStream;
 exports.createPaginatedResponse = createPaginatedResponse;
 exports.createParamDecorator = createParamDecorator;
 exports.createParamDecoratorWithoutParam = createParamDecoratorWithoutParam;
@@ -6745,7 +7388,10 @@ exports.createSuccessResponse = createSuccessResponse;
 exports.createTaskQueue = createTaskQueue;
 exports.createTempDir = createTempDir;
 exports.createTempFile = createTempFile;
+exports.createThrottleStream = createThrottleStream;
 exports.createUrlBuilder = createUrlBuilder;
+exports.dateDiff = dateDiff;
+exports.daysInMonth = daysInMonth;
 exports.debounce = debounce;
 exports.decrypt = decrypt;
 exports.deepFreeze = deepFreeze;
@@ -6756,8 +7402,10 @@ exports.deleteFileIfExists = deleteFileIfExists;
 exports.difference = difference;
 exports.emptyDir = emptyDir;
 exports.encrypt = encrypt;
+exports.endOf = endOf;
 exports.ensureDir = ensureDir;
 exports.ensureEmptyDir = ensureEmptyDir;
+exports.ensureType = ensureType;
 exports.equalsIgnoreCase = equalsIgnoreCase;
 exports.errorHandler = errorHandler;
 exports.extractFilterParams = extractFilterParams;
@@ -6772,6 +7420,8 @@ exports.findNewestFile = findNewestFile;
 exports.findOldestFile = findOldestFile;
 exports.flattenDeep = flattenDeep;
 exports.flattenObject = flattenObject;
+exports.formatDate = formatDate;
+exports.formatRelativeTime = formatRelativeTime;
 exports.generateApiKey = generateApiKey;
 exports.generateRandomBytes = generateRandomBytes;
 exports.generateRandomBytesAsString = generateRandomBytesAsString;
@@ -6790,6 +7440,7 @@ exports.getPaginationParams = getPaginationParams;
 exports.getRedactCensor = getRedactCensor;
 exports.getRequestId = getRequestId;
 exports.getSubdirectories = getSubdirectories;
+exports.getTypeOf = getTypeOf;
 exports.getValueByPath = getValueByPath;
 exports.groupBy = groupBy;
 exports.hasErrorShape = hasErrorShape;
@@ -6802,7 +7453,9 @@ exports.intersect = intersect;
 exports.isAlpha = isAlpha;
 exports.isAlphanumeric = isAlphanumeric;
 exports.isArray = isArray;
+exports.isArrayOf = isArrayOf;
 exports.isBase64 = isBase64;
+exports.isBetween = isBetween;
 exports.isCreditCard = isCreditCard;
 exports.isDateInRange = isDateInRange;
 exports.isDirectory = isDirectory;
@@ -6814,6 +7467,7 @@ exports.isHttpError = isHttpError;
 exports.isIPv4 = isIPv4;
 exports.isIPv6 = isIPv6;
 exports.isISODate = isISODate;
+exports.isLeapYear = isLeapYear;
 exports.isLengthBetween = isLengthBetween;
 exports.isNumberBetween = isNumberBetween;
 exports.isNumeric = isNumeric;
@@ -6822,6 +7476,7 @@ exports.isObject = isObject;
 exports.isPhone = isPhone;
 exports.isPlainObject = isPlainObject;
 exports.isPort = isPort;
+exports.isPrimitiveType = isPrimitiveType;
 exports.isStrongPassword = isStrongPassword;
 exports.isURL = isURL;
 exports.isUUID = isUUID;
@@ -6835,6 +7490,7 @@ exports.mapObject = mapObject;
 exports.mask = mask;
 exports.matchesPattern = matchesPattern;
 exports.md5 = md5;
+exports.memoize = memoize;
 exports.memoizeAsync = memoizeAsync;
 exports.mergeSort = mergeSort;
 exports.moveDir = moveDir;
@@ -6843,6 +7499,7 @@ exports.nanoId = nanoId;
 exports.normalizeUrl = normalizeUrl;
 exports.omit = omit;
 exports.parseBooleanParam = parseBooleanParam;
+exports.parseDate = parseDate;
 exports.parseNumberParam = parseNumberParam;
 exports.parseQueryString = parseQueryString;
 exports.parseTypedQueryParams = parseTypedQueryParams;
@@ -6886,16 +7543,26 @@ exports.shuffle = shuffle;
 exports.singletonAsync = singletonAsync;
 exports.sleep = sleep;
 exports.slugify = slugify;
+exports.startOf = startOf;
 exports.streamFile = streamFile;
+exports.streamToBuffer = streamToBuffer;
+exports.streamToString = streamToString;
 exports.stripHtml = stripHtml;
 exports.take = take;
 exports.takeWhile = takeWhile;
 exports.throttle = throttle;
+exports.timeAsync = timeAsync;
+exports.timeSync = timeSync;
+exports.timed = timed;
 exports.timeout = timeout;
+exports.toBool = toBool;
 exports.toCamelCase = toCamelCase;
 exports.toKebabCase = toKebabCase;
+exports.toNum = toNum;
 exports.toPascalCase = toPascalCase;
 exports.toSnakeCase = toSnakeCase;
+exports.toStr = toStr;
+exports.trackMemoryUsage = trackMemoryUsage;
 exports.truncate = truncate;
 exports.unique = unique;
 exports.uuid = uuid;