@kipicore/dbcore 1.1.13 → 1.1.14

package/dist/cjs/helpers/utils.js

@@ -0,0 +1,682 @@
+"use strict";
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNextLetter = exports.getCityAreas = exports.generateVoucherCode = exports.verifyHmacSHA256 = exports.generateHmacSHA256 = exports.customPagination = exports.uuidIdAlternatives = exports.objectIdAlternatives = exports.enumAlternatives = exports.fromSnakeCaseToNormalText = exports.normalizeToArray = exports.capitalizeFirst = exports.parseOrderOptions = exports.isValidUUID = exports.removeFalsyValues = exports.flattenNestedStructure = exports.buildNestedStructure = exports.getParentsByChildrenId = exports.getChildrenByParentId = exports.sortArray = exports.groupByFields = exports.endOfDay = exports.generateUuidToNumber = exports.startOfDay = exports.isDateWithinRange = exports.isTimeWithinRange = exports.keyByFieldOrFields = exports.getUniqueArrayByFields = exports.generateTempPassword = exports.generateAlphaNumericCode = exports.generateOtp = exports.ensureDirectoryExists = exports.omit = exports.isValidMongoDbId = exports.pick = void 0;
+exports.groupByFieldOrFields = groupByFieldOrFields;
+exports.slugify = slugify;
+exports.assignNonNull = assignNonNull;
+exports.isUserSchoolInfoUpdate = isUserSchoolInfoUpdate;
+exports.chunkArray = chunkArray;
+exports.extractFromObject = extractFromObject;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const fs_1 = __importDefault(require("fs"));
+const dateFunction = __importStar(require("date-fns"));
+const app_js_1 = require("../constants/app.js");
+const joi_1 = __importDefault(require("joi"));
+const uuid = require('uuid');
+const crypto_1 = __importDefault(require("crypto"));
+const sequelize_1 = require("sequelize");
+const axios_1 = __importDefault(require("axios"));
+const PASSWORD_REGEX = new RegExp('^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[!.@#$%^&*])(?=.{8,})');
+const pick = (objOrArray, keys) => {
+    const pickObject = (obj) => keys.reduce((acc, key) => {
+        if (key in obj) {
+            acc[key] = obj[key];
+        }
+        return acc;
+    }, {});
+    // Check if input is an array
+    if (Array.isArray(objOrArray)) {
+        return objOrArray.map(obj => pickObject(obj));
+    }
+    // Otherwise, it's a single object
+    return pickObject(objOrArray);
+};
+exports.pick = pick;
+exports.isValidMongoDbId = joi_1.default.string()
+    .trim()
+    .pattern(/^[0-9a-fA-F]{24}$/)
+    .messages({
+    'string.pattern.base': `"id" must be a valid MongoDB ObjectId`,
+});
+const omit = (objOrArray, keys) => {
+    const omitObject = (obj) => Object.keys(obj).reduce((acc, key) => {
+        // Check if the key is not in the list of keys to omit
+        if (!keys.includes(key)) {
+            // Assert the correct key type and assign the value
+            acc[key] = obj[key];
+        }
+        return acc;
+    }, {});
+    // Check if the input is an array
+    if (Array.isArray(objOrArray)) {
+        return objOrArray.map(item => omitObject(item));
+    }
+    // Otherwise, it's a single object
+    return omitObject(objOrArray);
+};
+exports.omit = omit;
+const ensureDirectoryExists = (directory) => {
+    if (!fs_1.default.existsSync(directory)) {
+        fs_1.default.mkdirSync(directory, { recursive: true });
+    }
+};
+exports.ensureDirectoryExists = ensureDirectoryExists;
+const generateOtp = (length = 6) => {
+    const digits = '0123456789';
+    let otp = '';
+    for (let i = 0; i < length; i++) {
+        otp += digits[Math.floor(Math.random() * 10)];
+    }
+    return otp;
+};
+exports.generateOtp = generateOtp;
+const generateAlphaNumericCode = (length = 8) => {
+    const chars = {
+        lowercase: 'abcdefghijklmnopqrstuvwxyz',
+        uppercase: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
+        numbers: '0123456789',
+    };
+    // Ensure password contains at least one character from each required group
+    let password = [
+        chars.lowercase[Math.floor(Math.random() * chars.lowercase.length)],
+        chars.uppercase[Math.floor(Math.random() * chars.uppercase.length)],
+        chars.numbers[Math.floor(Math.random() * chars.numbers.length)],
+    ];
+    // Fill the rest of the password to reach the minimum length of 8
+    const allChars = chars.lowercase + chars.uppercase + chars.numbers;
+    while (password.length < length) {
+        password.push(allChars[Math.floor(Math.random() * allChars.length)]);
+    }
+    // Shuffle password array and join it as a string
+    password = password.sort(() => 0.5 - Math.random());
+    const tempPassword = password.join('');
+    return tempPassword;
+};
+exports.generateAlphaNumericCode = generateAlphaNumericCode;
+const generateTempPassword = (length = 8) => {
+    const chars = {
+        lowercase: 'abcdefghijklmnopqrstuvwxyz',
+        uppercase: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ',
+        numbers: '0123456789',
+        symbols: '.@#',
+    };
+    // Ensure password contains at least one character from each required group
+    let password = [
+        chars.lowercase[Math.floor(Math.random() * chars.lowercase.length)],
+        chars.uppercase[Math.floor(Math.random() * chars.uppercase.length)],
+        chars.numbers[Math.floor(Math.random() * chars.numbers.length)],
+        chars.symbols[Math.floor(Math.random() * chars.symbols.length)],
+    ];
+    // Fill the rest of the password to reach the minimum length of 8
+    const allChars = chars.lowercase + chars.uppercase + chars.numbers + chars.symbols;
+    while (password.length < length) {
+        password.push(allChars[Math.floor(Math.random() * allChars.length)]);
+    }
+    // Shuffle password array and join it as a string
+    password = password.sort(() => 0.5 - Math.random());
+    const tempPassword = password.join('');
+    // Verify if the password meets the regex requirement
+    return PASSWORD_REGEX.test(tempPassword) ? tempPassword : (0, exports.generateTempPassword)();
+};
+exports.generateTempPassword = generateTempPassword;
+const getUniqueArrayByFields = (array, fields) => {
+    const uniqueMap = new Map();
+    array.forEach(item => {
+        const key = fields.map(field => item[field]).join('-');
+        if (!uniqueMap.has(key)) {
+            uniqueMap.set(key, item);
+        }
+    });
+    return Array.from(uniqueMap.values());
+};
+exports.getUniqueArrayByFields = getUniqueArrayByFields;
+const keyByFieldOrFields = (array, fields) => {
+    return array.reduce((result, item) => {
+        const key = Array.isArray(fields)
+            ? fields.map(field => item[field]).join('-') // Composite key for multiple fields
+            : item[fields]; // Single field key
+        result[key] = item; // Type assertion to ensure the key is string
+        return result;
+    }, {});
+};
+exports.keyByFieldOrFields = keyByFieldOrFields;
+/**
+ * Groups an array of objects by a specified field or multiple fields.
+ *
+ * @param array - The array of objects to group.
+ * @param fields - A single field or an array of fields to group by.
+ * @returns An object where keys are the grouped field values and values are arrays of grouped objects.
+ */
+function groupByFieldOrFields(array, fields) {
+    return array.reduce((result, item) => {
+        const key = Array.isArray(fields)
+            ? fields.map(field => item[field]).join('-') // Composite key for multiple fields
+            : item[fields]; // Single field key
+        const groupKey = String(key); // Ensuring the key is always a string
+        if (!result[groupKey]) {
+            result[groupKey] = [];
+        }
+        result[groupKey].push(item);
+        return result;
+    }, {});
+}
+const isTimeWithinRange = (time, rangeStart, rangeEnd) => {
+    const getTimeMs = (date) => date.getUTCHours() * 3600000 + date.getUTCMinutes() * 60000 + date.getUTCSeconds() * 1000 + date.getUTCMilliseconds();
+    const timeMs = getTimeMs(time);
+    const startMs = getTimeMs(rangeStart);
+    const endMs = getTimeMs(rangeEnd);
+    // If the time range does not cross midnight
+    if (startMs <= endMs) {
+        return timeMs >= startMs && timeMs <= endMs;
+    }
+    // If the time range crosses midnight
+    return timeMs >= startMs || timeMs <= endMs;
+};
+exports.isTimeWithinRange = isTimeWithinRange;
+// export const isTimeWithinRange = (time: string | Date, rangeStart: string | Date, rangeEnd: string | Date): boolean => {
+//     const extractTime = (isoString: string) => {
+//         const date = parseISO(new Date(isoString).toISOString());
+//         return getHours(date) * 3600 + getMinutes(date) * 60 + getSeconds(date); // Convert to total seconds
+//     };
+//     const timeSeconds = extractTime(time as string);
+//     const startSeconds = extractTime(rangeStart as string);
+//     const endSeconds = extractTime(rangeEnd as string);
+//     return timeSeconds >= startSeconds && timeSeconds <= endSeconds;
+// };
+const isDateWithinRange = (date, rangeStart, rangeEnd) => {
+    const dateValue = new Date(date).getTime();
+    const startValue = new Date(rangeStart).getTime();
+    const endValue = new Date(rangeEnd).getTime();
+    return dateValue >= startValue && dateValue <= endValue;
+};
+exports.isDateWithinRange = isDateWithinRange;
+const startOfDay = (date) => {
+    return dateFunction.startOfDay(dateFunction.parseISO(new Date(date).toISOString()));
+};
+exports.startOfDay = startOfDay;
+const generateUuidToNumber = (uuid1) => {
+    if (!uuid1)
+        uuid1 = crypto_1.default.randomUUID();
+    // Remove dashes from the UUID
+    let numericId = uuid1.replace(/-/g, '');
+    // Convert hex characters to numbers (keeping only digits)
+    numericId = BigInt('0x' + numericId).toString();
+    return numericId;
+};
+exports.generateUuidToNumber = generateUuidToNumber;
+const endOfDay = (date) => {
+    return dateFunction.endOfDay(dateFunction.parseISO(new Date(date).toISOString()));
+};
+exports.endOfDay = endOfDay;
+const groupByFields = (array, fields) => {
+    const groupedObject = {};
+    array.forEach(item => {
+        // Normalize `fields` to always be an array
+        const fieldArray = Array.isArray(fields) ? fields : [fields];
+        // Create a key based on the specified fields
+        const key = fieldArray.map(field => item[field]).join('-');
+        // If the key doesn't exist, initialize it with an empty array
+        if (!groupedObject[key]) {
+            groupedObject[key] = [];
+        }
+        // Add the current item to the corresponding group
+        groupedObject[key].push(item);
+    });
+    return groupedObject;
+};
+exports.groupByFields = groupByFields;
+/**
+ * Sorts an array of objects based on specified fields and order.
+ *
+ * @param array - The array to be sorted.
+ * @param fields - A single sort field or an array of sort fields.
+ * @returns A new sorted array.
+ */
+const sortArray = (array, fields) => {
+    const fieldArray = Array.isArray(fields) ? fields : [fields]; // Normalize to an array
+    return [...array].sort((a, b) => {
+        for (const { key, order = 'asc' } of fieldArray) {
+            const valueA = a[key];
+            const valueB = b[key];
+            // Handle undefined or null values safely
+            if (valueA == null && valueB == null)
+                continue;
+            if (valueA == null)
+                return order === 'asc' ? 1 : -1;
+            if (valueB == null)
+                return order === 'asc' ? -1 : 1;
+            // Compare values (handling numbers and strings properly)
+            const comparison = typeof valueA === 'string' && typeof valueB === 'string' ? valueA.localeCompare(valueB) : valueA > valueB ? 1 : -1;
+            if (comparison !== 0)
+                return order === 'asc' ? comparison : -comparison;
+        }
+        return 0; // All fields are equal
+    });
+};
+exports.sortArray = sortArray;
+/**
+ * Gets all nested children for a given parent ID.
+ *
+ * @param array - Array of nodes representing the flat hierarchy.
+ * @param parentIds - The ID of the parent node.
+ * @param parentIdKey - The key used to reference the parent ID.
+ * @returns A flattened list of all children.
+ */
+const getChildrenByParentId = (array, parentIds, parentIdKey) => {
+    const parentIdList = Array.isArray(parentIds) ? parentIds : [parentIds]; // Normalize parentIds to an array
+    const result = array.filter(one => parentIds.includes(one.id));
+    //all id list that are included in result array
+    const includedIds = [...parentIdList];
+    /**
+     * Recursively collects all children for the given parent IDs.
+     *
+     * @param currentParentIds - The current parent IDs being processed.
+     */
+    const collectChildren = (currentParentIds) => {
+        for (const node of array) {
+            if (currentParentIds.includes(node[parentIdKey])) {
+                if (!includedIds.includes(node.id)) {
+                    result.push(node);
+                    includedIds.push(node.id);
+                }
+                collectChildren([node.id]); // Recursively collect children of this node
+            }
+        }
+    };
+    collectChildren(parentIdList); // Start collecting from the given parent IDs
+    return result;
+};
+exports.getChildrenByParentId = getChildrenByParentId;
+/**
+ * Gets all nested children for a given parent ID.
+ *
+ * @param array - Array of nodes representing the flat hierarchy.
+ * @param childIds - The ID of the parent node.
+ * @param parentIdKey - The key used to reference the parent ID..
+ * @returns A flattened list of all parents.
+ */
+const getParentsByChildrenId = (array, childIds, parentIdKey) => {
+    const childIdList = Array.isArray(childIds) ? childIds : [childIds]; // Normalize childIds to an array
+    const result = [];
+    const includedIds = new Set(); // Track included IDs to avoid duplicates
+    /**
+     * Recursively collects all parent nodes for the given child IDs.
+     *
+     * @param currentChildIds - The current child IDs being processed.
+     */
+    const collectParents = (currentChildIds) => {
+        for (const childId of currentChildIds) {
+            const childNode = array.find(node => node.id === childId);
+            if (childNode && !includedIds.has(childNode.id)) {
+                result.push(childNode); // Add the current child node to the result
+                includedIds.add(childNode.id);
+                // Recursively find parents if `parentIdKey` exists
+                if (childNode[parentIdKey]) {
+                    collectParents([childNode[parentIdKey]]);
+                }
+            }
+        }
+    };
+    collectParents(childIdList); // Start collecting from the provided child IDs
+    return result;
+};
+exports.getParentsByChildrenId = getParentsByChildrenId;
+/**
+ * Builds a nested structure from a flat array of items based on a parent-child relationship.
+ *
+ * @param items - The array of items that need to be organized.
+ * @param parentIdKey - The key that refers to the parent ID in each item.
+ * @param nestedListKey - The key that will store the nested child items for each parent.
+ *
+ * @returns An array of root-level items, each containing its nested children in the `nestedListKey`.
+ */
+const buildNestedStructure = (items, parentIdKey, nestedListKey) => {
+    // Clone the items to avoid modifying the original array
+    const clonedItems = JSON.parse(JSON.stringify(items));
+    const map = new Map(); // Map to associate items by their `id`
+    const roots = []; // Array to hold root-level items
+    const orphans = []; // Array to hold orphaned items
+    // Populate the map and initialize the nested list
+    clonedItems.forEach((item) => {
+        map.set(item.id, item);
+        item[nestedListKey] = []; // Initialize children array
+    });
+    // Build the nested structure
+    clonedItems.forEach((item) => {
+        const parentId = item[parentIdKey];
+        if (!parentId) {
+            // Root-level item (no parentId)
+            roots.push(item);
+        }
+        else {
+            // Find parent and add this item as a child
+            const parent = map.get(parentId);
+            if (parent) {
+                parent[nestedListKey].push(item);
+            }
+            else {
+                orphans.push(item); // Add to orphaned items if parent is missing
+            }
+        }
+    });
+    // Append orphaned items to the roots array or process them differently if required
+    if (orphans.length > 0) {
+        roots.push(...orphans); // Add orphaned items to the roots array
+    }
+    return roots; // Return the root-level items, each containing its nested children
+};
+exports.buildNestedStructure = buildNestedStructure;
+/**
+ * Flattens a nested structure into a flat array while preserving the parent-child relationship.
+ *
+ * @param items - The nested array of items to be flattened.
+ * @param parentIdKey - The key that will store the parent ID in each flattened item.
+ * @param nestedListKey - The key that contains the nested child items.
+ *
+ * @returns A flat array of items, each containing a reference to its parent ID.
+ */
+const flattenNestedStructure = (items, parentIdKey, nestedListKey) => {
+    const flatArray = [];
+    const processItems = (items, parentId) => {
+        items.forEach(item => {
+            // Create a shallow copy without the nested list key
+            const { [nestedListKey]: children, ...rest } = item;
+            // Assign the parent ID
+            const flattenedItem = { ...rest, [parentIdKey]: parentId };
+            flatArray.push(flattenedItem);
+            // Recursively process children if they exist
+            if (Array.isArray(children) && children.length > 0) {
+                processItems(children, String(item.id));
+            }
+        });
+    };
+    processItems(items);
+    return flatArray;
+};
+exports.flattenNestedStructure = flattenNestedStructure;
+/**
+ * Removes all falsy values from an object.
+ *
+ * A falsy value in JavaScript/TypeScript includes:
+ * - false
+ * - 0 (zero)
+ * - "" (empty string)
+ * - null
+ * - undefined
+ * - NaN (Not-a-Number)
+ *
+ * This function iterates through the object's properties and removes any key-value pairs
+ * where the value is falsy. Only truthy values remain in the final object.
+ *
+ * @param obj - The input object containing key-value pairs.
+ * @returns A new object with all falsy values removed.
+ *
+ * @example
+ * const data = {
+ *   name: "Alice",
+ *   age: 25,
+ *   isAdmin: false,
+ *   score: 0,
+ *   city: "",
+ *   country: "USA",
+ *   email: null,
+ *   phone: undefined,
+ *   balance: NaN,
+ * };
+ *
+ * const cleanedData = removeFalsyValues(data);
+ * console.log(cleanedData);
+ * // Output: { name: 'Alice', age: 25, country: 'USA' }
+ */
+const removeFalsyValues = (obj) => {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    return Object.fromEntries(Object.entries(obj).filter(([_, value]) => Boolean(value)));
+};
+exports.removeFalsyValues = removeFalsyValues;
+const isValidUUID = (id, expectedVersion) => {
+    if (!uuid.validate(id))
+        return false;
+    if (expectedVersion && uuid.version(id) !== expectedVersion)
+        return false;
+    return true;
+};
+exports.isValidUUID = isValidUUID;
+/**
+ * Parses ordering input and returns Sequelize-compatible order array.
+ *
+ * @param inputOrder - Array like [["columnName", "ASC"], ...]
+ * @param defaultOrder - Fallback or additional default order (e.g. [['createdAt', 'DESC']])
+ */
+const parseOrderOptions = (inputOrder, defaultOrder = [['createdAt', 'DESC']]) => {
+    const order = [];
+    if (Array.isArray(inputOrder)) {
+        for (const item of inputOrder) {
+            if (Array.isArray(item) && item.length === 2) {
+                const [column, direction] = item;
+                if (typeof column === 'string' && typeof direction === 'string' && ['ASC', 'DESC'].includes(direction.toUpperCase())) {
+                    // const normalizedColumn = toSnakeCase(column);
+                    // order.push([Sequelize.literal(`"${normalizedColumn}"`), direction.toUpperCase()]);
+                    // order.push([Sequelize.literal(`"${column}"`), direction.toUpperCase()]);
+                    order.push([sequelize_1.Sequelize.literal(`"${column}"`), direction.toUpperCase()]);
+                }
+            }
+        }
+    }
+    // Ensure defaultOrder is always applied at the end if not already present
+    const defaultKey = JSON.stringify(defaultOrder[0]);
+    const hasDefault = order.some(o => JSON.stringify(o) === defaultKey);
+    if (!hasDefault) {
+        order.push(...defaultOrder);
+    }
+    return order;
+};
+exports.parseOrderOptions = parseOrderOptions;
+const capitalizeFirst = (str) => str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+exports.capitalizeFirst = capitalizeFirst;
+const normalizeToArray = (value) => value ? (Array.isArray(value) ? value : [value]) : undefined;
+exports.normalizeToArray = normalizeToArray;
+/**
+ * Converts a snake_case string to Normal Text
+ * @param {string} input - The snake_case string
+ * @returns {string} - The converted Normal Text
+ */
+const fromSnakeCaseToNormalText = (input) => {
+    if (typeof input !== 'string')
+        return '';
+    return input
+        .toLowerCase()
+        .split('_')
+        .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+        .join(' ');
+};
+exports.fromSnakeCaseToNormalText = fromSnakeCaseToNormalText;
+function slugify(text) {
+    return text
+        .toLowerCase()
+        .trim()
+        .replace(/[^a-z0-9\s-]/g, '')
+        .replace(/\s+/g, '-')
+        .replace(/-+/g, '-');
+}
+function assignNonNull(target, source) {
+    Object.entries(source).forEach(([key, value]) => {
+        if (value !== null && value !== undefined) {
+            target[key] = value;
+        }
+    });
+}
+function isUserSchoolInfoUpdate(institute, reqUser) {
+    return (!!(institute.type || institute.subType) &&
+        (reqUser.isAddDetails || reqUser.type === app_js_1.USER_TYPES.INSTITUTE_MASTER_ADMIN || reqUser.type === app_js_1.USER_TYPES.INSTITUTE_ADMIN));
+}
+function chunkArray(array, size) {
+    const chunks = [];
+    for (let i = 0; i < array.length; i += size) {
+        chunks.push(array.slice(i, i + size));
+    }
+    return chunks;
+}
+/**
+ * Safely gets a nested value from an object using a dot-separated path.
+ */
+function getNestedValue(obj, path) {
+    return path.split('.').reduce((acc, part) => (acc && acc[part] !== undefined ? acc[part] : '-'), obj);
+}
+/**
+ * Prepares userdata for EJS template based on dynamic columns config.
+ * @param data Array of objects
+ * @param columnsConfig Array of columns with { title, field }
+ * @returns { userdata: any[], columns: string[] }
+ */
+function extractFromObject(data, config) {
+    const columns = config.columns.map(col => col.title);
+    const userdata = data.map(item => {
+        const row = {};
+        config.columns.forEach(col => {
+            row[col.title] = getNestedValue(item, col.field);
+        });
+        return row;
+    });
+    return { tableTitle: config.tableTitle, userdata, columns };
+}
+const enumAlternatives = (enumObj, isRequired = false, allowArray = true) => {
+    const base = joi_1.default.string().valid(...Object.values(enumObj));
+    if (allowArray) {
+        const alt = joi_1.default.alternatives().try(base, joi_1.default.array().items(base));
+        return isRequired ? alt.required() : alt.optional();
+    }
+    return isRequired ? base.required() : base.optional();
+};
+exports.enumAlternatives = enumAlternatives;
+const objectIdAlternatives = (isRequired = false, allowArray = true) => {
+    const base = joi_1.default.string()
+        .pattern(/^[0-9a-fA-F]{24}$/)
+        .message('Invalid ObjectId format');
+    if (allowArray) {
+        const alt = joi_1.default.alternatives().try(base, joi_1.default.array().items(base));
+        return isRequired ? alt.required() : alt.optional();
+    }
+};
+exports.objectIdAlternatives = objectIdAlternatives;
+const uuidIdAlternatives = (isRequired = false, allowArray = true) => {
+    const base = joi_1.default.string().uuid().message('Invalid Uuid format');
+    if (allowArray) {
+        const alt = joi_1.default.alternatives().try(base, joi_1.default.array().items(base));
+        return isRequired ? alt.required() : alt.optional();
+    }
+};
+exports.uuidIdAlternatives = uuidIdAlternatives;
+const customPagination = async (data, page, limit, totalRecords) => {
+    page = Math.max(1, page || app_js_1.PAGINATION.PAGE);
+    limit = Math.max(1, limit || app_js_1.PAGINATION.LIMIT);
+    const startIndex = (page - 1) * limit;
+    const endIndex = page * limit;
+    const paginatedData = data.slice(startIndex, endIndex);
+    const totalPages = Math.ceil(totalRecords / limit);
+    const currentPage = page;
+    const hasPreviousPage = page > 1;
+    const hasNextPage = page < totalPages;
+    const recordList = paginatedData;
+    const paginatedDataWithPagination = {
+        limit,
+        totalRecords,
+        totalPages,
+        hasPreviousPage,
+        currentPage,
+        hasNextPage,
+        recordList,
+    };
+    return paginatedDataWithPagination;
+};
+exports.customPagination = customPagination;
+const generateHmacSHA256 = (data, secret) => {
+    return crypto_1.default.createHmac('sha256', secret).update(data).digest('hex');
+};
+exports.generateHmacSHA256 = generateHmacSHA256;
+const verifyHmacSHA256 = (data, secret, signature) => {
+    const generated = (0, exports.generateHmacSHA256)(data, secret);
+    return generated === signature;
+};
+exports.verifyHmacSHA256 = verifyHmacSHA256;
+const generateVoucherCode = (format = 'XXXX-XXXX-XXXX-XXXX') => {
+    const generateSegment = (length) => {
+        return crypto_1.default.randomBytes(length).toString('hex').toUpperCase().slice(0, length);
+    };
+    return format
+        .split('-')
+        .map(part => generateSegment(part.length))
+        .join('-');
+};
+exports.generateVoucherCode = generateVoucherCode;
+const getCityAreas = async (cityName = '') => {
+    if (!cityName)
+        throw new Error('City name is required.');
+    const query = `
+    [out:json];
+    area["name"="${cityName}"]["boundary"="administrative"]->.searchArea;
+    (
+      node["place"~"suburb|neighbourhood"](area.searchArea);
+      way["place"~"suburb|neighbourhood"](area.searchArea);
+      relation["place"~"suburb|neighbourhood"](area.searchArea);
+    );
+    out body;
+    >;
+    out skel qt;
+  `;
+    const url = 'https://overpass-api.de/api/interpreter';
+    try {
+        const response = await axios_1.default.post(url, `data=${encodeURIComponent(query)}`, {
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        });
+        const elements = response.data.elements;
+        const areas = elements.filter((el) => el.tags && el.tags.name).map((el) => el.tags.name.trim());
+        return [...new Set(areas)]; // Remove duplicates
+        // return [...new Set(areas)]; // Remove duplicates
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    }
+    catch (error) {
+        return [];
+    }
+};
+exports.getCityAreas = getCityAreas;
+const getNextLetter = (current) => {
+    const code = current.charCodeAt(0);
+    return code >= 90 ? 'A' : String.fromCharCode(code + 1);
+};
+exports.getNextLetter = getNextLetter;