@kipicore/dbcore 1.0.7 → 1.0.8

package/dist/helpers/utils.ts

@@ -0,0 +1,738 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import fs from 'fs';
+import * as dateFunction from 'date-fns';
+import { PAGINATION, USER_TYPES } from '../constants/app';
+import Joi from 'joi';
+import { validate, version, v4 as uuidv4 } from 'uuid';
+import crypto from 'crypto';
+import { OrderItem, Sequelize } from 'sequelize';
+import axios from 'axios';
+
+const PASSWORD_REGEX = new RegExp('^(?=.*[a-z])(?=.*[A-Z])(?=.*[0-9])(?=.*[!.@#$%^&*])(?=.{8,})');
+
+export const pick = <T extends object, K extends keyof T>(objOrArray: T | T[], keys: K[]): Pick<T, K> | Pick<T, K>[] => {
+    const pickObject = (obj: T): Pick<T, K> =>
+        keys.reduce(
+            (acc, key) => {
+                if (key in obj) {
+                    acc[key] = obj[key];
+                }
+                return acc;
+            },
+            {} as Pick<T, K>,
+        );
+
+    // 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);
+};
+
+export const isValidMongoDbId = Joi.string()
+    .trim()
+    .pattern(/^[0-9a-fA-F]{24}$/)
+    .messages({
+        'string.pattern.base': `"id" must be a valid MongoDB ObjectId`,
+    });
+
+export const omit = <T extends object, K extends keyof T>(objOrArray: T | T[], keys: K[]): Omit<T, K> | Omit<T, K>[] => {
+    const omitObject = (obj: T): Omit<T, K> =>
+        Object.keys(obj).reduce(
+            (acc, key) => {
+                // Check if the key is not in the list of keys to omit
+                if (!keys.includes(key as K)) {
+                    // Assert the correct key type and assign the value
+                    (acc as any)[key] = obj[key as keyof T];
+                }
+                return acc;
+            },
+            {} as Omit<T, K>,
+        );
+
+    // 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);
+};
+
+export const ensureDirectoryExists = (directory: string) => {
+    if (!fs.existsSync(directory)) {
+        fs.mkdirSync(directory, { recursive: true });
+    }
+};
+
+export const generateOtp = (length: number = 6): string => {
+    const digits = '0123456789';
+    let otp: string = '';
+    for (let i = 0; i < length; i++) {
+        otp += digits[Math.floor(Math.random() * 10)];
+    }
+    return otp;
+};
+
+export const generateAlphaNumericCode = (length = 8): string => {
+    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;
+};
+
+export const generateTempPassword = (length = 8): string => {
+    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 : generateTempPassword();
+};
+
+
+type UniqueByFields<T> = (array: T[], fields: (keyof T)[]) => T[];
+export const getUniqueArrayByFields: UniqueByFields<any> = (array, fields) => {
+    const uniqueMap = new Map<string, any>();
+
+    array.forEach(item => {
+        const key = fields.map(field => item[field]).join('-');
+        if (!uniqueMap.has(key)) {
+            uniqueMap.set(key, item);
+        }
+    });
+
+    return Array.from(uniqueMap.values());
+};
+
+export const keyByFieldOrFields = <T>(array: T[], fields: keyof T | (keyof T)[]): Record<string, T> => {
+    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 as string] = item; // Type assertion to ensure the key is string
+            return result;
+        },
+        {} as Record<string, T>,
+    );
+};
+
+/**
+ * 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.
+ */
+export function groupByFieldOrFields<T>(array: T[], fields: keyof T | (keyof T)[]): Record<string, T[]> {
+    return array.reduce<Record<string, T[]>>((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;
+    }, {});
+}
+
+export const isTimeWithinRange = (time: Date, rangeStart: Date, rangeEnd: Date): boolean => {
+    const getTimeMs = (date: 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;
+};
+
+// 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;
+// };
+
+export const isDateWithinRange = (date: Date | string, rangeStart: Date | string, rangeEnd: Date | string): boolean => {
+    const dateValue = new Date(date).getTime();
+    const startValue = new Date(rangeStart).getTime();
+    const endValue = new Date(rangeEnd).getTime();
+
+    return dateValue >= startValue && dateValue <= endValue;
+};
+
+export const startOfDay = (date: string | Date): Date => {
+    return dateFunction.startOfDay(dateFunction.parseISO(new Date(date).toISOString()));
+};
+export const generateUuidToNumber = (uuid?: string): string => {
+    if (!uuid) uuid = uuidv4();
+    // Remove dashes from the UUID
+    let numericId = uuid.replace(/-/g, '');
+
+    // Convert hex characters to numbers (keeping only digits)
+    numericId = BigInt('0x' + numericId).toString();
+
+    return numericId;
+};
+export const endOfDay = (date: string | Date): Date => {
+    return dateFunction.endOfDay(dateFunction.parseISO(new Date(date).toISOString()));
+};
+
+type GroupByFields<T> = (array: T[], fields: keyof T | (keyof T)[]) => Record<string, T[]>;
+
+export const groupByFields: GroupByFields<any> = (array, fields) => {
+    const groupedObject: Record<string, any[]> = {};
+
+    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;
+};
+
+type SortOrder = 'asc' | 'desc';
+interface SortField<T> {
+    key: keyof T;
+    order?: SortOrder;
+}
+/**
+ * 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.
+ */
+export const sortArray = <T>(array: T[], fields: SortField<T> | SortField<T>[]): T[] => {
+    const fieldArray: SortField<T>[] = 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
+    });
+};
+
+/**
+ * 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.
+ */
+export const getChildrenByParentId = <T extends Record<string, any>>(array: T[], parentIds: string | string[], parentIdKey: keyof T): T[] => {
+    const parentIdList = Array.isArray(parentIds) ? parentIds : [parentIds]; // Normalize parentIds to an array
+    const result: T[] = 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: string[]) => {
+        for (const node of array) {
+            if (currentParentIds.includes(node[parentIdKey] as string)) {
+                if (!includedIds.includes(node.id)) {
+                    result.push(node);
+                    includedIds.push(node.id);
+                }
+                collectChildren([node.id as string]); // Recursively collect children of this node
+            }
+        }
+    };
+
+    collectChildren(parentIdList); // Start collecting from the given parent IDs
+
+    return result;
+};
+
+/**
+ * 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.
+ */
+export const getParentsByChildrenId = <T extends Record<string, any>>(array: T[], childIds: string | string[], parentIdKey: keyof T): T[] => {
+    const childIdList = Array.isArray(childIds) ? childIds : [childIds]; // Normalize childIds to an array
+    const result: T[] = [];
+    const includedIds = new Set<string>(); // 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: string[]) => {
+        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;
+};
+
+/**
+ * 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`.
+ */
+export const buildNestedStructure = <T extends Record<string, any>>(items: T[], parentIdKey: keyof T, nestedListKey: string): T[] => {
+    // Clone the items to avoid modifying the original array
+    const clonedItems = JSON.parse(JSON.stringify(items));
+
+    const map = new Map<string, T>(); // Map to associate items by their `id`
+    const roots: T[] = []; // Array to hold root-level items
+    const orphans: T[] = []; // Array to hold orphaned items
+
+    // Populate the map and initialize the nested list
+    clonedItems.forEach((item: T) => {
+        map.set(item.id, item);
+        (item as any)[nestedListKey] = []; // Initialize children array
+    });
+
+    // Build the nested structure
+    clonedItems.forEach((item: T) => {
+        const parentId = item[parentIdKey] as string | undefined;
+
+        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 as any)[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
+};
+
+
+/**
+ * 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.
+ */
+export const flattenNestedStructure = <T extends Record<string, any>>(
+    items: T[],
+    parentIdKey: keyof T,
+    nestedListKey: string,
+): Omit<T, typeof nestedListKey>[] => {
+    const flatArray: Omit<T, typeof nestedListKey>[] = [];
+
+    const processItems = (items: T[], parentId?: string) => {
+        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 } as Omit<T, typeof nestedListKey>;
+            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;
+};
+
+/**
+ * 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' }
+ */
+export const removeFalsyValues = <T extends Record<string, any>>(obj: T): Partial<T> => {
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    return Object.fromEntries(Object.entries(obj).filter(([_, value]) => Boolean(value))) as Partial<T>;
+};
+
+export const isValidUUID = (id: string, expectedVersion?: 1 | 4): boolean => {
+    if (!validate(id)) return false;
+    if (expectedVersion && version(id) !== expectedVersion) return false;
+    return true;
+};
+
+
+/**
+ * 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']])
+ */
+export const parseOrderOptions = (inputOrder: unknown, defaultOrder: OrderItem[] = [['createdAt', 'DESC']]): OrderItem[] => {
+    const order: OrderItem[] = [];
+
+    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.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;
+};
+
+import { IInstituteAttributes } from '../interfaces/instituteInterface';
+import { IUserAttributes } from '../interfaces/userInterface';
+import { TAeraModelCreationAttributes } from '../types/areaType';
+
+
+export const capitalizeFirst = (str: string) => str.charAt(0).toUpperCase() + str.slice(1).toLowerCase();
+
+export const normalizeToArray = (value: string | string[] | undefined): string[] | undefined =>
+    value ? (Array.isArray(value) ? value : [value]) : undefined;
+/**
+ * Converts a snake_case string to Normal Text
+ * @param {string} input - The snake_case string
+ * @returns {string} - The converted Normal Text
+ */
+export const fromSnakeCaseToNormalText = (input: string): string => {
+    if (typeof input !== 'string') return '';
+
+    return input
+        .toLowerCase()
+        .split('_')
+        .map(word => word.charAt(0).toUpperCase() + word.slice(1))
+        .join(' ');
+};
+
+export function slugify(text: string): string {
+    return text
+        .toLowerCase()
+        .trim()
+        .replace(/[^a-z0-9\s-]/g, '')
+        .replace(/\s+/g, '-')
+        .replace(/-+/g, '-');
+}
+export function assignNonNull<T extends Record<string, any>>(target: T, source: Record<string, any>): void {
+    Object.entries(source).forEach(([key, value]) => {
+        if (value !== null && value !== undefined) {
+            (target as Record<string, any>)[key] = value;
+        }
+    });
+}
+
+export function isUserSchoolInfoUpdate(institute: IInstituteAttributes, reqUser: IUserAttributes & { isAddDetails?: boolean }): boolean {
+    return (
+        !!(institute.type || institute.subType) &&
+        (reqUser.isAddDetails || reqUser.type === USER_TYPES.INSTITUTE_MASTER_ADMIN || reqUser.type === USER_TYPES.INSTITUTE_ADMIN)
+    );
+}
+
+export function chunkArray<T>(array: T[], size: number): T[][] {
+    const chunks: T[][] = [];
+    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: any, path: string): any {
+    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[] }
+ */
+
+export function extractFromObject(
+    data: any[],
+    config: { tableTitle: string; columns: { title: string; field: string }[] },
+): { tableTitle: string; userdata: any[]; columns: string[] } {
+    const columns = config.columns.map(col => col.title);
+
+    const userdata = data.map(item => {
+        const row: Record<string, any> = {};
+        config.columns.forEach(col => {
+            row[col.title] = getNestedValue(item, col.field);
+        });
+        return row;
+    });
+    return { tableTitle: config.tableTitle, userdata, columns };
+}
+
+export const enumAlternatives = (enumObj: Record<string, string>, isRequired = false, allowArray = true) => {
+    const base = Joi.string().valid(...Object.values(enumObj));
+
+    if (allowArray) {
+        const alt: Joi.AlternativesSchema = Joi.alternatives().try(base, Joi.array().items(base));
+        return isRequired ? alt.required() : alt.optional();
+    }
+
+    return isRequired ? base.required() : base.optional();
+};
+
+export const objectIdAlternatives = (isRequired = false, allowArray = true) => {
+    const base = Joi.string()
+        .pattern(/^[0-9a-fA-F]{24}$/)
+        .message('Invalid ObjectId format');
+
+    if (allowArray) {
+        const alt: Joi.AlternativesSchema = Joi.alternatives().try(base, Joi.array().items(base));
+        return isRequired ? alt.required() : alt.optional();
+    }
+};
+export const uuidIdAlternatives = (isRequired = false, allowArray = true) => {
+    const base = Joi.string().uuid().message('Invalid Uuid format');
+
+    if (allowArray) {
+        const alt: Joi.AlternativesSchema = Joi.alternatives().try(base, Joi.array().items(base));
+        return isRequired ? alt.required() : alt.optional();
+    }
+};
+
+export const customPagination = async (data: any[], page: number, limit: number, totalRecords: number) => {
+    page = Math.max(1, page || PAGINATION.PAGE);
+    limit = Math.max(1, limit || 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;
+};
+
+export const generateHmacSHA256 = (data: string, secret: string): string => {
+    return crypto.createHmac('sha256', secret).update(data).digest('hex');
+};
+
+export const verifyHmacSHA256 = (data: string, secret: string, signature: string): boolean => {
+    const generated = generateHmacSHA256(data, secret);
+    return generated === signature;
+};
+
+export const generateVoucherCode = (format = 'XXXX-XXXX-XXXX-XXXX') => {
+    const generateSegment = (length: number): string => {
+        return crypto.randomBytes(length).toString('hex').toUpperCase().slice(0, length);
+    };
+    return format
+        .split('-')
+        .map(part => generateSegment(part.length))
+        .join('-');
+};
+
+export const getCityAreas = async (cityName = ''): Promise<Partial<TAeraModelCreationAttributes>[]> => {
+    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.post(url, `data=${encodeURIComponent(query)}`, {
+            headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        });
+        const elements = response.data.elements;
+        const areas = elements.filter((el: any) => el.tags && el.tags.name).map((el: any) => el.tags.name.trim());
+        return [...new Set(areas)] as TAeraModelCreationAttributes[]; // Remove duplicates
+        // return [...new Set(areas)]; // Remove duplicates
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    } catch (error) {
+        return [];
+    }
+};
+
+export const getNextLetter = (current: string): string => {
+    const code = current.charCodeAt(0);
+    return code >= 90 ? 'A' : String.fromCharCode(code + 1);
+};