ts-prorm-orm 1.1.0

package/dist/utils/index.js

@@ -0,0 +1,1079 @@
+"use strict";
+/**
+ * Utility functions for the ORM
+ * Includes string converters, pluralization, object utilities, UUID generation, and SQL formatting
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.camelToSnake = camelToSnake;
+exports.camelize = camelize;
+exports.snakeToCamel = snakeToCamel;
+exports.snakeCase = snakeCase;
+exports.camelToKebab = camelToKebab;
+exports.kebabToCamel = kebabToCamel;
+exports.pluralize = pluralize;
+exports.singularize = singularize;
+exports.cloneDeep = cloneDeep;
+exports.merge = merge;
+exports.pick = pick;
+exports.omit = omit;
+exports.generateUUID = generateUUID;
+exports.generateShortUUID = generateShortUUID;
+exports.isValidUUID = isValidUUID;
+exports.formatValues = formatValues;
+exports.formatValue = formatValue;
+exports.escapeString = escapeString;
+exports.escapeId = escapeId;
+exports.formatWhere = formatWhere;
+exports.isEmpty = isEmpty;
+exports.coalesce = coalesce;
+exports.escapeLike = escapeLike;
+exports.addTicks = addTicks;
+exports.removeTicks = removeTicks;
+exports.toDefaultValue = toDefaultValue;
+exports.formatDefaultValue = formatDefaultValue;
+exports.spliceStr = spliceStr;
+exports.formatDateString = formatDateString;
+exports.randomString = randomString;
+exports.randomAlphaNumeric = randomAlphaNumeric;
+exports.randomNumeric = randomNumeric;
+exports.randomHex = randomHex;
+exports.timestamp = timestamp;
+exports.nowDate = nowDate;
+exports.defaultValue = defaultValue;
+exports.defaultIfEmpty = defaultIfEmpty;
+exports.retry = retry;
+exports.retryWithBackoff = retryWithBackoff;
+exports.unique = unique;
+exports.flatten = flatten;
+exports.groupBy = groupBy;
+exports.sortBy = sortBy;
+exports.sum = sum;
+exports.underscore = underscore;
+exports.includes = includes;
+exports.startsWith = startsWith;
+exports.endsWith = endsWith;
+exports.repeat = repeat;
+exports.reverse = reverse;
+exports.clone = clone;
+exports.get = get;
+exports.set = set;
+exports.has = has;
+exports.isString = isString;
+exports.isNumber = isNumber;
+exports.isBoolean = isBoolean;
+exports.isDate = isDate;
+exports.isArray = isArray;
+exports.isObject = isObject;
+exports.formatCurrency = formatCurrency;
+exports.format = format;
+const string_1 = require("./string");
+// ==================== String Case Converters ====================
+/**
+ * Convert camelCase to snake_case
+ */
+function camelToSnake(str) {
+    return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+/**
+ * Convert snake_case to camelCase
+ * Alias for snakeToCamel
+ */
+function camelize(str) {
+    return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+/**
+ * Convert snake_case to camelCase
+ */
+function snakeToCamel(str) {
+    return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+/**
+ * Convert camelCase to snake_case
+ * Alias for camelToSnake
+ */
+function snakeCase(str) {
+    return str.replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+}
+/**
+ * Convert camelCase to kebab-case
+ */
+function camelToKebab(str) {
+    return str.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
+}
+/**
+ * Convert kebab-case to camelCase
+ */
+function kebabToCamel(str) {
+    return str.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+// ==================== Pluralization ====================
+// Common irregular plurals
+const irregularPlurals = {
+    person: 'people',
+    man: 'men',
+    woman: 'women',
+    child: 'children',
+    tooth: 'teeth',
+    foot: 'feet',
+    mouse: 'mice',
+    goose: 'geese',
+    ox: 'oxen',
+    quiz: 'quizzes',
+    matrix: 'matrices',
+    vertex: 'vertices',
+    index: 'indices',
+    appendix: 'appendices',
+    bacterium: 'bacteria',
+    criterion: 'criteria',
+    phenomenon: 'phenomena',
+    analysis: 'analyses',
+    diagnosis: 'diagnoses',
+    hypothesis: 'hypotheses',
+    synthesis: 'syntheses',
+    crisis: 'crises',
+    basis: 'bases',
+};
+// Words that are the same in singular and plural
+const uncountableWords = new Set([
+    'equipment',
+    'information',
+    'rice',
+    'money',
+    'species',
+    'series',
+    'fish',
+    'sheep',
+    'deer',
+    'moose',
+    'aircraft',
+    'offspring',
+    'news',
+    'media',
+    'status',
+]);
+/**
+ * Pluralize a word
+ */
+function pluralize(word, count) {
+    // If count is 1, return singular form
+    if (count !== undefined && count === 1) {
+        return singularize(word);
+    }
+    // Handle uncountable words
+    const lowerWord = word.toLowerCase();
+    if (uncountableWords.has(lowerWord)) {
+        return word;
+    }
+    // Handle irregular plurals
+    if (irregularPlurals[lowerWord]) {
+        return irregularPlurals[lowerWord];
+    }
+    // Handle words ending in 'y' (consonant + y -> ies)
+    if (lowerWord.endsWith('y') && !isVowel(lowerWord[lowerWord.length - 2])) {
+        return word.slice(0, -1) + 'ies';
+    }
+    // Handle words ending in 'f' or 'fe' (fe -> ves)
+    if (lowerWord.endsWith('fe')) {
+        return word.slice(0, -2) + 'ves';
+    }
+    if (lowerWord.endsWith('f')) {
+        return word.slice(0, -1) + 'ves';
+    }
+    // Handle words ending in 'o' (sometimes -> es)
+    if (lowerWord.endsWith('o') && !isVowel(lowerWord[lowerWord.length - 2])) {
+        // Common exceptions
+        const exceptions = ['photo', 'piano', 'halo', 'logo', 'mango', 'cargo', 'hero', ' veto'];
+        if (exceptions.some((ex) => lowerWord === ex)) {
+            return word + 'es';
+        }
+    }
+    // Handle words ending in 's', 'ss', 'sh', 'ch', 'x', 'z'
+    const esEndings = ['s', 'ss', 'sh', 'ch', 'x', 'z', 'o'];
+    if (esEndings.some((ending) => lowerWord.endsWith(ending))) {
+        return word + 'es';
+    }
+    // Default: add 's'
+    return word + 's';
+}
+/**
+ * Singularize a word
+ */
+function singularize(word) {
+    const lowerWord = word.toLowerCase();
+    // Handle uncountable words
+    if (uncountableWords.has(lowerWord)) {
+        return word;
+    }
+    // Handle irregular plurals (reverse lookup)
+    for (const [singular, plural] of Object.entries(irregularPlurals)) {
+        if (plural === lowerWord) {
+            // Preserve original case
+            if (word[0] === word[0].toUpperCase()) {
+                return singular.charAt(0).toUpperCase() + singular.slice(1);
+            }
+            return singular;
+        }
+    }
+    // Handle words ending in 'ies'
+    if (lowerWord.endsWith('ies') && lowerWord.length > 3) {
+        return word.slice(0, -3) + 'y';
+    }
+    // Handle words ending in 'ves'
+    if (lowerWord.endsWith('ves')) {
+        if (lowerWord.endsWith('lves')) {
+            return word.slice(0, -3) + 'fe';
+        }
+        if (lowerWord.endsWith('ives')) {
+            return word.slice(0, -3) + 'fe';
+        }
+        if (lowerWord.endsWith('oves')) {
+            return word.slice(0, -3) + 'fe';
+        }
+        return word.slice(0, -3) + 'f';
+    }
+    // Handle words ending in 'es'
+    if (lowerWord.endsWith('es') && lowerWord.length > 2) {
+        // Check for words ending in 'ses', 'shes', 'ches', 'xes', 'zes'
+        if (lowerWord.length > 3 && /[sz]es$/.test(lowerWord)) {
+            return word.slice(0, -2);
+        }
+        // Check for words like 'heroes', 'vetoes'
+        if (/[aeiou]oes$/.test(lowerWord)) {
+            return word.slice(0, -2);
+        }
+    }
+    // Handle words ending in 's' (but not 'ss')
+    if (lowerWord.endsWith('s') && !lowerWord.endsWith('ss') && lowerWord.length > 1) {
+        return word.slice(0, -1);
+    }
+    return word;
+}
+/**
+ * Helper function to check if a character is a vowel
+ */
+function isVowel(char) {
+    return 'aeiou'.includes(char.toLowerCase());
+}
+// ==================== Object Utilities ====================
+/**
+ * Deep clone an object
+ */
+function cloneDeep(obj) {
+    if (obj === null || typeof obj !== 'object') {
+        return obj;
+    }
+    if (obj instanceof Date) {
+        return new Date(obj.getTime());
+    }
+    if (obj instanceof Array) {
+        return obj.map((item) => cloneDeep(item));
+    }
+    if (obj instanceof Set) {
+        return new Set(Array.from(obj).map((item) => cloneDeep(item)));
+    }
+    if (obj instanceof Map) {
+        return new Map(Array.from(obj.entries()).map(([key, value]) => [cloneDeep(key), cloneDeep(value)]));
+    }
+    if (typeof obj === 'object') {
+        const cloned = {};
+        for (const key of Object.keys(obj)) {
+            cloned[key] = cloneDeep(obj[key]);
+        }
+        return cloned;
+    }
+    return obj;
+}
+/**
+ * Deep merge objects
+ */
+function merge(target, ...sources) {
+    if (!sources.length) {
+        return target;
+    }
+    const source = sources.shift();
+    if (isPlainObject(target) && isPlainObject(source)) {
+        const sourceObj = source;
+        const sourceKeys = Object.keys(sourceObj);
+        for (const key of sourceKeys) {
+            const sourceValue = sourceObj[key];
+            if (isPlainObject(sourceValue)) {
+                if (!target[key]) {
+                    Object.assign(target, { [key]: {} });
+                }
+                merge(target[key], sourceValue);
+            }
+            else if (sourceValue !== undefined) {
+                Object.assign(target, { [key]: sourceValue });
+            }
+        }
+    }
+    return merge(target, ...sources);
+}
+/**
+ * Check if value is a plain object
+ */
+function isPlainObject(item) {
+    return item && typeof item === 'object' && !Array.isArray(item);
+}
+/**
+ * Pick properties from an object
+ */
+function pick(obj, keys) {
+    const result = {};
+    for (const key of keys) {
+        if (key in obj) {
+            result[key] = obj[key];
+        }
+    }
+    return result;
+}
+/**
+ * Omit properties from an object
+ */
+function omit(obj, keys) {
+    const result = { ...obj };
+    for (const key of keys) {
+        delete result[key];
+    }
+    return result;
+}
+// ==================== UUID Generation ====================
+/**
+ * Generate a UUID v4
+ */
+function generateUUID() {
+    // Use crypto.randomUUID if available
+    if (typeof crypto !== 'undefined' && crypto.randomUUID) {
+        return crypto.randomUUID();
+    }
+    // Fallback implementation
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+        const r = (Math.random() * 16) | 0;
+        const v = c === 'x' ? r : (r & 0x3) | 0x8;
+        return v.toString(16);
+    });
+}
+/**
+ * Generate a short UUID (8 characters)
+ */
+function generateShortUUID() {
+    return generateUUID().replace(/-/g, '').substring(0, 8);
+}
+/**
+ * Validate UUID format
+ */
+function isValidUUID(uuid) {
+    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+    return uuidRegex.test(uuid);
+}
+// ==================== SQL Formatting ====================
+/**
+ * Format values for SQL query
+ */
+function formatValues(values) {
+    const formatted = {};
+    for (const [key, value] of Object.entries(values)) {
+        formatted[key] = formatValue(value);
+    }
+    return formatted;
+}
+/**
+ * Format a single value for SQL
+ */
+function formatValue(value) {
+    if (value === null || value === undefined) {
+        return null;
+    }
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => formatValue(item));
+    }
+    if (typeof value === 'object') {
+        // Handle special objects
+        if (value instanceof Set) {
+            return Array.from(value).map((item) => formatValue(item));
+        }
+        if (value instanceof Map) {
+            const obj = {};
+            value.forEach((v, k) => {
+                obj[k] = formatValue(v);
+            });
+            return JSON.stringify(obj);
+        }
+        return JSON.stringify(value);
+    }
+    return value;
+}
+/**
+ * Escape a string for SQL
+ */
+function escapeString(value) {
+    if (typeof value !== 'string') {
+        return String(value);
+    }
+    // Escape single quotes by doubling them
+    return value.replace(/'/g, "''");
+}
+/**
+ * Escape an identifier (table/column name)
+ */
+function escapeId(identifier) {
+    // Escape backticks and wrap in backticks
+    return `\`${identifier.replace(/`/g, '``')}\``;
+}
+/**
+ * Format a where condition for SQL
+ */
+function formatWhere(where) {
+    const conditions = [];
+    for (const [key, value] of Object.entries(where)) {
+        if (key.startsWith('$')) {
+            // Logical operators
+            continue;
+        }
+        if (typeof value === 'object' && value !== null) {
+            // Operator conditions
+            for (const [op, opValue] of Object.entries(value)) {
+                conditions.push(`${escapeId(key)} ${formatOperator(op)} ${formatValue(opValue)}`);
+            }
+        }
+        else {
+            // Simple equality
+            conditions.push(`${escapeId(key)} = ${formatValue(value)}`);
+        }
+    }
+    return conditions.join(' AND ');
+}
+/**
+ * Format an operator
+ */
+function formatOperator(op) {
+    const operators = {
+        $eq: '=',
+        $ne: '!=',
+        $gt: '>',
+        $gte: '>=',
+        $lt: '<',
+        $lte: '<=',
+        $like: 'LIKE',
+        $notLike: 'NOT LIKE',
+        $in: 'IN',
+        $notIn: 'NOT IN',
+        $between: 'BETWEEN',
+        $notBetween: 'NOT BETWEEN',
+        $isNull: 'IS NULL',
+        $isNotNull: 'IS NOT NULL',
+    };
+    return operators[op] || op;
+}
+// ==================== Other Utilities ====================
+/**
+ * Check if value is empty (null, undefined, empty string, empty array, empty object)
+ */
+function isEmpty(value) {
+    if (value === null || value === undefined) {
+        return true;
+    }
+    if (typeof value === 'string') {
+        return value.trim() === '';
+    }
+    if (Array.isArray(value)) {
+        return value.length === 0;
+    }
+    if (typeof value === 'object') {
+        return Object.keys(value).length === 0;
+    }
+    return false;
+}
+/**
+ * Get the first defined value from arguments
+ */
+function coalesce(...values) {
+    return values.find((value) => value !== null && value !== undefined);
+}
+// Note: `truncate` and `pad` are defined once in './string' and re-exported
+// via `export * from './string'` below. Duplicate definitions used to live
+// here with a different (and inconsistent) default `pad` direction, which
+// silently shadowed the './string' implementation because local exports
+// take precedence over `export *` re-exports for the same name.
+/**
+ * Convert a value to a string suitable for use in SQL LIKE
+ */
+function escapeLike(value) {
+    return value.replace(/[%_]/g, (match) => `\\${match}`);
+}
+// ==================== Tick/Backtick Utilities ====================
+/**
+ * Wrap a string in backticks (for SQL identifiers)
+ */
+function addTicks(str) {
+    return `\`${str}\``;
+}
+/**
+ * Remove backticks from a string
+ */
+function removeTicks(str) {
+    return str.replace(/^`|`$/g, '');
+}
+/**
+ * Convert a value to its default JavaScript value
+ */
+function toDefaultValue(value) {
+    if (value === null) {
+        return null;
+    }
+    if (value === undefined) {
+        return undefined;
+    }
+    const defaultValues = {
+        // String types
+        STRING: () => '',
+        TEXT: () => '',
+        CITEXT: () => '',
+        CHAR: () => '',
+        UUID: () => undefined,
+        // Number types
+        INTEGER: () => 0,
+        BIGINT: () => 0,
+        FLOAT: () => 0.0,
+        DOUBLE: () => 0.0,
+        DECIMAL: () => 0,
+        // Boolean
+        BOOLEAN: () => false,
+        // Date types
+        DATE: () => null,
+        DATEONLY: () => null,
+        NOW: () => null,
+        TIME: () => null,
+        // Other
+        JSON: () => null,
+        JSONB: () => null,
+        BLOB: () => null,
+        ENUM: () => null,
+        ARRAY: () => [],
+        GEOMETRY: () => null,
+        GEOGRAPHY: () => null,
+    };
+    // If value is a DataType instance or string type name
+    if (typeof value === 'string' && defaultValues[value]) {
+        return defaultValues[value]();
+    }
+    // If value is an object with a type property
+    if (typeof value === 'object' && value !== null) {
+        const typeName = value.type?.toUpperCase?.() || value.typeName?.toUpperCase?.();
+        if (typeName && defaultValues[typeName]) {
+            return defaultValues[typeName]();
+        }
+    }
+    return value;
+}
+/**
+ * Format a value for SQL based on dialect
+ */
+function formatDefaultValue(value, dialect) {
+    if (value === null || value === undefined) {
+        return 'NULL';
+    }
+    if (typeof value === 'boolean') {
+        // Handle PostgreSQL boolean format
+        if (dialect === 'postgres') {
+            return value ? 'TRUE' : 'FALSE';
+        }
+        return value ? '1' : '0';
+    }
+    if (typeof value === 'number') {
+        return String(value);
+    }
+    if (typeof value === 'string') {
+        // Escape single quotes by doubling them
+        const escaped = value.replace(/'/g, "''");
+        return `'${escaped}'`;
+    }
+    if (value instanceof Date) {
+        const dateStr = value.toISOString();
+        // Handle different dialect date formats
+        if (dialect === 'postgres') {
+            return `'${dateStr}'`;
+        }
+        if (dialect === 'mysql') {
+            return `'${dateStr.slice(0, 19).replace('T', ' ')}'`;
+        }
+        return `'${dateStr}'`;
+    }
+    if (Array.isArray(value)) {
+        if (dialect === 'postgres' || dialect === 'mysql') {
+            return `'${JSON.stringify(value)}'::jsonb`;
+        }
+        return `'${JSON.stringify(value)}'`;
+    }
+    if (typeof value === 'object') {
+        return `'${JSON.stringify(value)}'`;
+    }
+    return String(value);
+}
+// ==================== String Splicing ====================
+/**
+ * Insert a string at a specific position, optionally replacing characters
+ * @param str The original string
+ * @param index Position to insert/replace at (0-indexed)
+ * @param count Number of characters to replace (0 for insert only)
+ * @param insert String to insert
+ */
+function spliceStr(str, index, count, insert) {
+    if (index < 0) {
+        index = str.length + index;
+    }
+    if (index < 0) {
+        index = 0;
+    }
+    if (index > str.length) {
+        index = str.length;
+    }
+    return str.slice(0, index) + insert + str.slice(index + count);
+}
+// ==================== Date Formatting ====================
+/**
+ * Format a date to a string
+ * @param date - Date to format
+ * @param formatStr - Format string (YYYY-MM-DD, etc.)
+ */
+function formatDateString(date, formatStr = 'YYYY-MM-DD') {
+    const d = date instanceof Date ? date : new Date(date);
+    if (isNaN(d.getTime())) {
+        throw new Error('Invalid date');
+    }
+    const year = d.getFullYear();
+    const month = String(d.getMonth() + 1).padStart(2, '0');
+    const day = String(d.getDate()).padStart(2, '0');
+    const hours = String(d.getHours()).padStart(2, '0');
+    const minutes = String(d.getMinutes()).padStart(2, '0');
+    const seconds = String(d.getSeconds()).padStart(2, '0');
+    return formatStr
+        .replace('YYYY', String(year))
+        .replace('YY', String(year).slice(-2))
+        .replace('MM', month)
+        .replace('DD', day)
+        .replace('HH', hours)
+        .replace('mm', minutes)
+        .replace('ss', seconds);
+}
+// ==================== Random String Generation ====================
+/**
+ * Generate a random string of specified length
+ */
+function randomString(length = 16, chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789') {
+    let result = '';
+    const charsLength = chars.length;
+    for (let i = 0; i < length; i++) {
+        result += chars.charAt(Math.floor(Math.random() * charsLength));
+    }
+    return result;
+}
+/**
+ * Generate a random alphanumeric string
+ */
+function randomAlphaNumeric(length = 16) {
+    return randomString(length, 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789');
+}
+/**
+ * Generate a random numeric string
+ */
+function randomNumeric(length = 8) {
+    return randomString(length, '0123456789');
+}
+/**
+ * Generate a random hex string
+ */
+function randomHex(length = 16) {
+    return randomString(length, '0123456789abcdef');
+}
+// ==================== Current Timestamp ====================
+/**
+ * Get current timestamp in milliseconds
+ *
+ * Note: named `timestamp` (not `now`) to avoid colliding with the
+ * `now(): Date` export from './date', which is re-exported via
+ * `export * from './date'` below and is the canonical `utils.now()`.
+ */
+function timestamp() {
+    return Date.now();
+}
+/**
+ * Get current timestamp as Date object
+ */
+function nowDate() {
+    return new Date();
+}
+// ==================== Default Value ====================
+/**
+ * Return default value if value is null or undefined
+ */
+function defaultValue(value, defaultVal) {
+    return value !== null && value !== undefined ? value : defaultVal;
+}
+/**
+ * Return default value if value is empty
+ */
+function defaultIfEmpty(value, defaultVal) {
+    if (value === null || value === undefined)
+        return defaultVal;
+    if (typeof value === 'string' && value.trim() === '')
+        return defaultVal;
+    if (Array.isArray(value) && value.length === 0)
+        return defaultVal;
+    if (typeof value === 'object' && Object.keys(value).length === 0)
+        return defaultVal;
+    return value;
+}
+// Default error patterns to retry on
+const DEFAULT_RETRY_PATTERNS = [
+    'Connection timeout',
+    'ETIMEDOUT',
+    'ECONNREFUSED',
+    'ECONNRESET',
+    'EHOSTUNREACH',
+    'ENOTFOUND',
+    'timeout',
+    'connecting',
+    'connection',
+    'database',
+];
+/**
+ * Sleep for the specified duration
+ */
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * Check if an error matches any of the retry patterns
+ */
+function shouldRetry(error, matchPatterns) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    const patterns = matchPatterns || DEFAULT_RETRY_PATTERNS;
+    return patterns.some((pattern) => errorMessage.toLowerCase().includes(pattern.toLowerCase()));
+}
+/**
+ * Calculate the delay for the next retry using exponential backoff
+ */
+function calculateBackoffDelay(attempt, baseTimeout, backoffMultiplier, maxDelay) {
+    const delay = baseTimeout * Math.pow(backoffMultiplier, attempt);
+    return Math.min(delay, maxDelay);
+}
+/**
+ * Retry a function with configurable options
+ *
+ * @param fn - The async function to retry
+ * @param options - Retry options
+ * @returns The result of the function
+ */
+async function retry(fn, options = {}) {
+    const { max = 3, timeout = 1000, match, backoff = false, backoffMultiplier = 2, backoffMax = 10000, } = options;
+    let lastError = 'Unknown error';
+    let attempt = 0;
+    while (attempt < max) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error;
+            // Check if we should retry this error
+            if (!shouldRetry(lastError, match)) {
+                throw lastError;
+            }
+            attempt++;
+            // If we've reached max attempts, throw the last error
+            if (attempt >= max) {
+                throw lastError;
+            }
+            // Calculate delay for next retry
+            let delay;
+            if (backoff) {
+                delay = calculateBackoffDelay(attempt, timeout, backoffMultiplier, backoffMax);
+            }
+            else {
+                delay = timeout;
+            }
+            // Add some jitter to avoid thundering herd
+            const jitter = Math.random() * 100;
+            await sleep(delay + jitter);
+        }
+    }
+    throw lastError;
+}
+/**
+ * Retry a function with exponential backoff
+ *
+ * @param fn - The async function to retry
+ * @param maxRetries - Maximum number of retries (default: 3)
+ * @param baseTimeout - Base timeout in ms (default: 1000)
+ * @param maxTimeout - Maximum timeout in ms (default: 10000)
+ * @returns The result of the function
+ */
+async function retryWithBackoff(fn, maxRetries = 3, baseTimeout = 1000, maxTimeout = 10000) {
+    return retry(fn, {
+        max: maxRetries,
+        timeout: baseTimeout,
+        backoff: true,
+        backoffMultiplier: 2,
+        backoffMax: maxTimeout,
+    });
+}
+// ==================== Array Utils ====================
+/**
+ * Get unique values from an array
+ */
+function unique(arr) {
+    return Array.from(new Set(arr));
+}
+/**
+ * Flatten an array of arrays
+ */
+function flatten(arr) {
+    return arr.flat();
+}
+/**
+ * Group array items by a key
+ */
+function groupBy(arr, key) {
+    return arr.reduce((result, item) => {
+        const groupKey = String(item[key]);
+        if (!result[groupKey]) {
+            result[groupKey] = [];
+        }
+        result[groupKey].push(item);
+        return result;
+    }, {});
+}
+/**
+ * Sort array by a key or function
+ */
+function sortBy(arr, iteratee) {
+    return [...arr].sort((a, b) => {
+        const aVal = typeof iteratee === 'function' ? iteratee(a) : a[iteratee];
+        const bVal = typeof iteratee === 'function' ? iteratee(b) : b[iteratee];
+        if (aVal < bVal)
+            return -1;
+        if (aVal > bVal)
+            return 1;
+        return 0;
+    });
+}
+/**
+ * Sum array values
+ */
+function sum(arr) {
+    return arr.reduce((total, n) => total + n, 0);
+}
+// ==================== Additional String Utilities ====================
+/**
+ * Convert string to snake_case (alias for snakeCase)
+ */
+function underscore(str) {
+    return snakeCase(str);
+}
+/**
+ * String includes method
+ */
+function includes(str, searchString) {
+    return str.includes(searchString);
+}
+/**
+ * String startsWith method
+ */
+function startsWith(str, searchString) {
+    return str.startsWith(searchString);
+}
+/**
+ * String endsWith method
+ */
+function endsWith(str, searchString) {
+    return str.endsWith(searchString);
+}
+/**
+ * String repeat method
+ */
+function repeat(str, count) {
+    return str.repeat(count);
+}
+function reverse(input) {
+    if (typeof input === 'string') {
+        return [...input].reverse().join('');
+    }
+    return [...input].reverse();
+}
+// ==================== Object Utilities ====================
+/**
+ * Deep clone an object
+ */
+function clone(obj) {
+    return JSON.parse(JSON.stringify(obj));
+}
+/**
+ * Get property from object
+ */
+function get(obj, path) {
+    return path.split('.').reduce((acc, part) => acc && acc[part], obj);
+}
+/**
+ * Set property on object
+ */
+function set(obj, path, value) {
+    const parts = path.split('.');
+    let current = obj;
+    for (let i = 0; i < parts.length - 1; i++) {
+        if (!current[parts[i]]) {
+            current[parts[i]] = {};
+        }
+        current = current[parts[i]];
+    }
+    current[parts[parts.length - 1]] = value;
+}
+/**
+ * Check if object has property
+ */
+function has(obj, path) {
+    const parts = path.split('.');
+    let current = obj;
+    for (const part of parts) {
+        if (current == null || !(part in current)) {
+            return false;
+        }
+        current = current[part];
+    }
+    return true;
+}
+// ==================== Type Check Utilities ====================
+/**
+ * Check if value is a string
+ */
+function isString(value) {
+    return typeof value === 'string';
+}
+/**
+ * Check if value is a number
+ */
+function isNumber(value) {
+    return typeof value === 'number' && !isNaN(value);
+}
+/**
+ * Check if value is a boolean
+ */
+function isBoolean(value) {
+    return typeof value === 'boolean';
+}
+/**
+ * Check if value is a date
+ */
+function isDate(value) {
+    return value instanceof Date;
+}
+/**
+ * Check if value is an array
+ */
+function isArray(value) {
+    return Array.isArray(value);
+}
+/**
+ * Check if value is an object
+ */
+function isObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+// ==================== Format Utilities ====================
+/**
+ * Format a number as currency
+ */
+function formatCurrency(amount, currency = 'USD') {
+    // useGrouping: false so callers can reliably find the raw numeric
+    // substring (e.g. '1234.56') in the output without thousands separators
+    // breaking it up (e.g. '1,234.56').
+    return new Intl.NumberFormat('en-US', {
+        style: 'currency',
+        currency,
+        useGrouping: false,
+    }).format(amount);
+}
+/**
+ * Format a number to a fixed number of decimal places.
+ *
+ * Named `format` (not re-exported by './date', see note there) so this is
+ * the canonical `utils.format` for numeric formatting.
+ */
+function format(value, decimals = 2) {
+    return value.toFixed(decimals);
+}
+// Export from string utils
+__exportStar(require("./string"), exports);
+// Export from date utils
+__exportStar(require("./date"), exports);
+exports.default = {
+    camelToSnake,
+    snakeToCamel,
+    camelToKebab,
+    kebabToCamel,
+    camelize,
+    snakeCase,
+    pluralize,
+    singularize,
+    cloneDeep,
+    merge,
+    pick,
+    omit,
+    generateUUID,
+    generateShortUUID,
+    isValidUUID,
+    formatValues,
+    formatValue,
+    escapeString,
+    escapeId,
+    formatWhere,
+    isEmpty,
+    coalesce,
+    truncate: string_1.truncate,
+    pad: string_1.pad,
+    escapeLike,
+    addTicks,
+    removeTicks,
+    toDefaultValue,
+    formatDefaultValue,
+    spliceStr,
+    unique,
+    flatten,
+    groupBy,
+    sortBy,
+    sum,
+    underscore,
+    includes,
+    startsWith,
+    endsWith,
+    repeat,
+    reverse,
+    clone,
+    get,
+    set,
+    has,
+    isString,
+    isNumber,
+    isBoolean,
+    isDate,
+    isArray,
+    isObject,
+    formatCurrency,
+    formatDateString,
+};