@rudderstack/integrations-lib 0.2.31 → 0.2.33

package/build/utils/batch-processing.d.ts

@@ -0,0 +1,205 @@
+/**
+ * Configuration options for batch processing operations
+ */
+export interface BatchProcessingDefaults {
+    /**
+     * Default number of items to process in each batch
+     */
+    batchSize?: number;
+    /**
+     * Default time threshold in milliseconds before yielding control back to the event loop
+     */
+    yieldThreshold?: number;
+}
+/**
+ * Configure global defaults for batch processing operations
+ *
+ * @param config - Configuration options for batch processing
+ * @returns The current configuration after applying changes
+ *
+ * @example
+ * ```typescript
+ * // Set both defaults
+ * configureBatchProcessingDefaults({ batchSize: 20, yieldThreshold: 5 });
+ *
+ * // Set only batch size
+ * configureBatchProcessingDefaults({ batchSize: 50 });
+ *
+ * // Get current configuration
+ * const currentConfig = configureBatchProcessingDefaults();
+ * ```
+ */
+export declare function configureBatchProcessingDefaults(config?: BatchProcessingDefaults): BatchProcessingDefaults;
+/**
+ * Maps over an array in batches to avoid blocking the event loop.
+ * Processes items in chunks and yields control back to the event loop between batches
+ * when the processing time exceeds the threshold.
+ *
+ * @template T - The type of items in the input array
+ * @template R - The type of items in the result array
+ * @param items - The array to map over
+ * @param mapFn - The mapping function to apply to each item. Receives the item and its index.
+ * @param batchSize - The number of items to process in each batch (default: @see defaultBatchSize)
+ * @param yieldThreshold - Time threshold in milliseconds before yielding control (default: @see defaultYieldThreshold)
+ * @returns A promise that resolves to the mapped array
+ * @throws {Error} When batchSize is not a positive integer
+ *
+ * @example
+ * ```typescript
+ * // Synchronous mapping
+ * const doubled = await mapInBatches([1, 2, 3, 4], (x) => x * 2, 2);
+ * // Result: [2, 4, 6, 8]
+ *
+ * // Asynchronous mapping
+ * const fetched = await mapInBatches(urls, async (url) => fetch(url), 3);
+ *
+ * // With index
+ * const indexed = await mapInBatches(['a', 'b'], (item, index) => `${item}-${index}`);
+ * // Result: ['a-0', 'b-1']
+ * ```
+ */
+export declare function mapInBatches<T, R>(items: T[], mapFn: (item: T, index: number) => R | Promise<R>, batchSize?: number, yieldThreshold?: number): Promise<R[]>;
+/**
+ * Filters an array in batches to avoid blocking the event loop.
+ * Processes items in chunks and yields control back to the event loop between batches
+ * when the processing time exceeds the threshold.
+ *
+ * @template T - The type of items in the array
+ * @param items - The array to filter
+ * @param predicate - The predicate function to test each item. Receives the item and its index.
+ * @param batchSize - The number of items to process in each batch (default: @see defaultBatchSize)
+ * @param yieldThreshold - Time threshold in milliseconds before yielding control (default: @see defaultYieldThreshold)
+ * @returns A promise that resolves to the filtered array
+ * @throws {Error} When batchSize is not a positive integer
+ *
+ * @example
+ * ```typescript
+ * // Synchronous filtering
+ * const evens = await filterInBatches([1, 2, 3, 4, 5], (x) => x % 2 === 0, 2);
+ * // Result: [2, 4]
+ *
+ * // Asynchronous filtering
+ * const valid = await filterInBatches(urls, async (url) => {
+ *   const response = await fetch(url);
+ *   return response.ok;
+ * }, 3);
+ *
+ * // With index
+ * const evenIndices = await filterInBatches(['a', 'b', 'c'], (_, index) => index % 2 === 0);
+ * // Result: ['a', 'c']
+ * ```
+ */
+export declare function filterInBatches<T>(items: T[], predicate: (item: T, index: number) => boolean | Promise<boolean>, batchSize?: number, yieldThreshold?: number): Promise<T[]>;
+/**
+ * Groups an array by a key function in batches to avoid blocking the event loop.
+ * Processes items in chunks and yields control back to the event loop between batches
+ * when the processing time exceeds the threshold.
+ *
+ * @template T - The type of items in the array
+ * @template K - The type of the grouping key (must extend PropertyKey)
+ * @param items - The array to group
+ * @param keyFn - The function to extract the grouping key from each item. Receives the item and its index.
+ * @param batchSize - The number of items to process in each batch (default: @see defaultBatchSize)
+ * @param yieldThreshold - Time threshold in milliseconds before yielding control (default: @see defaultYieldThreshold)
+ * @returns A promise that resolves to an object with grouped items
+ * @throws {Error} When batchSize is not a positive integer
+ *
+ * @example
+ * ```typescript
+ * // Group by property
+ * const byType = await groupByInBatches(
+ *   [{type: 'A', value: 1}, {type: 'B', value: 2}, {type: 'A', value: 3}],
+ *   (item) => item.type,
+ *   2
+ * );
+ * // Result: {A: [{type: 'A', value: 1}, {type: 'A', value: 3}], B: [{type: 'B', value: 2}]}
+ *
+ * // Group by computed value
+ * const byParity = await groupByInBatches([1, 2, 3, 4], (x) => x % 2 === 0 ? 'even' : 'odd');
+ * // Result: {odd: [1, 3], even: [2, 4]}
+ *
+ * // Asynchronous key function
+ * const byCategory = await groupByInBatches(items, async (item) => {
+ *   return await getCategoryForItem(item);
+ * });
+ * ```
+ */
+export declare function groupByInBatches<T, K extends PropertyKey>(items: T[], keyFn: (item: T, index: number) => K | Promise<K>, batchSize?: number, yieldThreshold?: number): Promise<Record<K, T[]>>;
+/**
+ * Reduces an array in batches to avoid blocking the event loop.
+ * Processes items in chunks and yields control back to the event loop between batches
+ * when the processing time exceeds the threshold.
+ *
+ * @template T - The type of items in the array
+ * @template R - The type of the accumulator/result
+ * @param items - The array to reduce
+ * @param reducer - The reducer function. Receives the accumulator, current item, and index.
+ * @param initialValue - The initial value for the accumulator
+ * @param batchSize - The number of items to process in each batch (default: @see defaultBatchSize)
+ * @param yieldThreshold - Time threshold in milliseconds before yielding control (default: @see defaultYieldThreshold)
+ * @returns A promise that resolves to the reduced value
+ * @throws {Error} When batchSize is not a positive integer
+ *
+ * @example
+ * ```typescript
+ * // Sum numbers
+ * const sum = await reduceInBatches([1, 2, 3, 4], (acc, x) => acc + x, 0, 2);
+ * // Result: 10
+ *
+ * // Concatenate strings
+ * const joined = await reduceInBatches(['a', 'b', 'c'], (acc, x) => acc + x, '');
+ * // Result: 'abc'
+ *
+ * // Build object with index
+ * const indexed = await reduceInBatches(
+ *   ['x', 'y'],
+ *   (acc, item, index) => ({ ...acc, [index]: item }),
+ *   {}
+ * );
+ * // Result: {0: 'x', 1: 'y'}
+ *
+ * // Asynchronous reducer
+ * const processed = await reduceInBatches(urls, async (acc, url) => {
+ *   const data = await fetch(url).then(r => r.json());
+ *   return [...acc, data];
+ * }, []);
+ * ```
+ */
+export declare function reduceInBatches<T, R>(items: T[], reducer: (acc: R, item: T, index: number) => R | Promise<R>, initialValue: R, batchSize?: number, yieldThreshold?: number): Promise<R>;
+/**
+ * FlatMaps an array in batches to avoid blocking the event loop.
+ * Processes items in chunks, flattens the results, and yields control back to the event loop between batches
+ * when the processing time exceeds the threshold.
+ *
+ * @template T - The type of items in the input array
+ * @template R - The type of items in the flattened result array
+ * @param items - The array to flatMap over
+ * @param mapFn - The mapping function that returns an array for each item. Receives the item and its index.
+ * @param batchSize - The number of items to process in each batch (default: @see defaultBatchSize)
+ * @param yieldThreshold - Time threshold in milliseconds before yielding control (default: @see defaultYieldThreshold)
+ * @returns A promise that resolves to the flattened mapped array
+ * @throws {Error} When batchSize is not a positive integer
+ *
+ * @example
+ * ```typescript
+ * // Duplicate each item
+ * const duplicated = await flatMapInBatches([1, 2, 3], (x) => [x, x], 2);
+ * // Result: [1, 1, 2, 2, 3, 3]
+ *
+ * // Variable length results
+ * const repeated = await flatMapInBatches([1, 2, 3], (x) => Array(x).fill(x));
+ * // Result: [1, 2, 2, 3, 3, 3]
+ *
+ * // Split strings into characters
+ * const chars = await flatMapInBatches(['ab', 'cd'], (str) => str.split(''));
+ * // Result: ['a', 'b', 'c', 'd']
+ *
+ * // Asynchronous mapping
+ * const expanded = await flatMapInBatches(categories, async (category) => {
+ *   const items = await fetchItemsForCategory(category);
+ *   return items;
+ * });
+ * ```
+ */
+export declare function flatMapInBatches<T, R>(items: T[], mapFn: (item: T, index: number) => R[] | Promise<R[]>, batchSize?: number, yieldThreshold?: number): Promise<R[]>;
+//# sourceMappingURL=batch-processing.d.ts.map

package/build/utils/batch-processing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch-processing.d.ts","sourceRoot":"","sources":["../../src/utils/batch-processing.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,uBAAuB;IACtC;;OAEG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AAMD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,gCAAgC,CAC9C,MAAM,CAAC,EAAE,uBAAuB,GAC/B,uBAAuB,CAqBzB;AA0BD;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,CAAC,EAC/B,KAAK,EAAE,CAAC,EAAE,EACV,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,EACjD,SAAS,SAAmB,EAC5B,cAAc,SAAwB,GACrC,OAAO,CAAC,CAAC,EAAE,CAAC,CAmBd;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAC/B,KAAK,EAAE,CAAC,EAAE,EACV,SAAS,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,EACjE,SAAS,SAAmB,EAC5B,cAAc,SAAwB,GACrC,OAAO,CAAC,CAAC,EAAE,CAAC,CAqBd;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,CAAC,SAAS,WAAW,EACvD,KAAK,EAAE,CAAC,EAAE,EACV,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,EACjD,SAAS,SAAmB,EAC5B,cAAc,SAAwB,GACrC,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CAiCzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,CAAC,EAClC,KAAK,EAAE,CAAC,EAAE,EACV,OAAO,EAAE,CAAC,GAAG,EAAE,CAAC,EAAE,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,EAC3D,YAAY,EAAE,CAAC,EACf,SAAS,SAAmB,EAC5B,cAAc,SAAwB,GACrC,OAAO,CAAC,CAAC,CAAC,CAsBZ;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAAE,CAAC,EACnC,KAAK,EAAE,CAAC,EAAE,EACV,KAAK,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,CAAC,EAAE,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC,EACrD,SAAS,SAAmB,EAC5B,cAAc,SAAwB,GACrC,OAAO,CAAC,CAAC,EAAE,CAAC,CAoBd"}

package/build/utils/batch-processing.js

@@ -0,0 +1,330 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configureBatchProcessingDefaults = configureBatchProcessingDefaults;
+exports.mapInBatches = mapInBatches;
+exports.filterInBatches = filterInBatches;
+exports.groupByInBatches = groupByInBatches;
+exports.reduceInBatches = reduceInBatches;
+exports.flatMapInBatches = flatMapInBatches;
+// Default configuration values (internal)
+let defaultBatchSize = 10;
+let defaultYieldThreshold = 10;
+/**
+ * Configure global defaults for batch processing operations
+ *
+ * @param config - Configuration options for batch processing
+ * @returns The current configuration after applying changes
+ *
+ * @example
+ * ```typescript
+ * // Set both defaults
+ * configureBatchProcessingDefaults({ batchSize: 20, yieldThreshold: 5 });
+ *
+ * // Set only batch size
+ * configureBatchProcessingDefaults({ batchSize: 50 });
+ *
+ * // Get current configuration
+ * const currentConfig = configureBatchProcessingDefaults();
+ * ```
+ */
+function configureBatchProcessingDefaults(config) {
+    if (config) {
+        if (config.batchSize !== undefined) {
+            if (!Number.isInteger(config.batchSize) || config.batchSize <= 0) {
+                throw new Error('batchSize must be a positive integer');
+            }
+            defaultBatchSize = config.batchSize;
+        }
+        if (config.yieldThreshold !== undefined) {
+            if (!Number.isInteger(config.yieldThreshold) || config.yieldThreshold < 0) {
+                throw new Error('yieldThreshold must be a non-negative integer');
+            }
+            defaultYieldThreshold = config.yieldThreshold;
+        }
+    }
+    return {
+        batchSize: defaultBatchSize,
+        yieldThreshold: defaultYieldThreshold,
+    };
+}
+/**
+ * Utility function to defer execution to the next tick of the event loop.
+ * This prevents blocking the event loop during heavy batch operations by
+ * yielding control back to the event loop using setImmediate.
+ *
+ * @param startTime - The timestamp when the current batch processing started
+ * @param yieldThreshold - Time threshold in milliseconds before yielding control
+ * @returns A promise that resolves to a boolean indicating whether a yield occurred
+ * @internal
+ */
+function defer(startTime, yieldThreshold) {
+    const elapsed = Date.now() - startTime;
+    // Only yield if we've exceeded the threshold
+    if (elapsed >= yieldThreshold) {
+        return new Promise((resolve) => {
+            setImmediate(() => resolve(true));
+        });
+    }
+    // Otherwise continue immediately
+    return Promise.resolve(false);
+}
+/**
+ * Maps over an array in batches to avoid blocking the event loop.
+ * Processes items in chunks and yields control back to the event loop between batches
+ * when the processing time exceeds the threshold.
+ *
+ * @template T - The type of items in the input array
+ * @template R - The type of items in the result array
+ * @param items - The array to map over
+ * @param mapFn - The mapping function to apply to each item. Receives the item and its index.
+ * @param batchSize - The number of items to process in each batch (default: @see defaultBatchSize)
+ * @param yieldThreshold - Time threshold in milliseconds before yielding control (default: @see defaultYieldThreshold)
+ * @returns A promise that resolves to the mapped array
+ * @throws {Error} When batchSize is not a positive integer
+ *
+ * @example
+ * ```typescript
+ * // Synchronous mapping
+ * const doubled = await mapInBatches([1, 2, 3, 4], (x) => x * 2, 2);
+ * // Result: [2, 4, 6, 8]
+ *
+ * // Asynchronous mapping
+ * const fetched = await mapInBatches(urls, async (url) => fetch(url), 3);
+ *
+ * // With index
+ * const indexed = await mapInBatches(['a', 'b'], (item, index) => `${item}-${index}`);
+ * // Result: ['a-0', 'b-1']
+ * ```
+ */
+function mapInBatches(items, mapFn, batchSize = defaultBatchSize, yieldThreshold = defaultYieldThreshold) {
+    if (!Number.isInteger(batchSize) || batchSize <= 0) {
+        throw new Error('batchSize must be a positive integer');
+    }
+    if (!Number.isInteger(yieldThreshold) || yieldThreshold < 0) {
+        throw new Error('yieldThreshold must be a non-negative integer');
+    }
+    const process = async (i = 0, acc = [], startTime = Date.now()) => {
+        if (i >= items.length)
+            return acc;
+        const batch = items.slice(i, i + batchSize);
+        const mapped = await Promise.all(batch.map((item, j) => mapFn(item, i + j)));
+        return defer(startTime, yieldThreshold).then((didYield) => process(i + batchSize, acc.concat(mapped), didYield ? Date.now() : startTime));
+    };
+    return process();
+}
+/**
+ * Filters an array in batches to avoid blocking the event loop.
+ * Processes items in chunks and yields control back to the event loop between batches
+ * when the processing time exceeds the threshold.
+ *
+ * @template T - The type of items in the array
+ * @param items - The array to filter
+ * @param predicate - The predicate function to test each item. Receives the item and its index.
+ * @param batchSize - The number of items to process in each batch (default: @see defaultBatchSize)
+ * @param yieldThreshold - Time threshold in milliseconds before yielding control (default: @see defaultYieldThreshold)
+ * @returns A promise that resolves to the filtered array
+ * @throws {Error} When batchSize is not a positive integer
+ *
+ * @example
+ * ```typescript
+ * // Synchronous filtering
+ * const evens = await filterInBatches([1, 2, 3, 4, 5], (x) => x % 2 === 0, 2);
+ * // Result: [2, 4]
+ *
+ * // Asynchronous filtering
+ * const valid = await filterInBatches(urls, async (url) => {
+ *   const response = await fetch(url);
+ *   return response.ok;
+ * }, 3);
+ *
+ * // With index
+ * const evenIndices = await filterInBatches(['a', 'b', 'c'], (_, index) => index % 2 === 0);
+ * // Result: ['a', 'c']
+ * ```
+ */
+function filterInBatches(items, predicate, batchSize = defaultBatchSize, yieldThreshold = defaultYieldThreshold) {
+    if (!Number.isInteger(batchSize) || batchSize <= 0) {
+        throw new Error('batchSize must be a positive integer');
+    }
+    if (!Number.isInteger(yieldThreshold) || yieldThreshold < 0) {
+        throw new Error('yieldThreshold must be a non-negative integer');
+    }
+    const process = async (i = 0, acc = [], startTime = Date.now()) => {
+        if (i >= items.length)
+            return acc;
+        const batch = items.slice(i, i + batchSize);
+        const flags = await Promise.all(batch.map((item, j) => predicate(item, i + j)));
+        const filtered = batch.filter((_, j) => flags[j]);
+        return defer(startTime, yieldThreshold).then((didYield) => process(i + batchSize, acc.concat(filtered), didYield ? Date.now() : startTime));
+    };
+    return process();
+}
+/**
+ * Groups an array by a key function in batches to avoid blocking the event loop.
+ * Processes items in chunks and yields control back to the event loop between batches
+ * when the processing time exceeds the threshold.
+ *
+ * @template T - The type of items in the array
+ * @template K - The type of the grouping key (must extend PropertyKey)
+ * @param items - The array to group
+ * @param keyFn - The function to extract the grouping key from each item. Receives the item and its index.
+ * @param batchSize - The number of items to process in each batch (default: @see defaultBatchSize)
+ * @param yieldThreshold - Time threshold in milliseconds before yielding control (default: @see defaultYieldThreshold)
+ * @returns A promise that resolves to an object with grouped items
+ * @throws {Error} When batchSize is not a positive integer
+ *
+ * @example
+ * ```typescript
+ * // Group by property
+ * const byType = await groupByInBatches(
+ *   [{type: 'A', value: 1}, {type: 'B', value: 2}, {type: 'A', value: 3}],
+ *   (item) => item.type,
+ *   2
+ * );
+ * // Result: {A: [{type: 'A', value: 1}, {type: 'A', value: 3}], B: [{type: 'B', value: 2}]}
+ *
+ * // Group by computed value
+ * const byParity = await groupByInBatches([1, 2, 3, 4], (x) => x % 2 === 0 ? 'even' : 'odd');
+ * // Result: {odd: [1, 3], even: [2, 4]}
+ *
+ * // Asynchronous key function
+ * const byCategory = await groupByInBatches(items, async (item) => {
+ *   return await getCategoryForItem(item);
+ * });
+ * ```
+ */
+function groupByInBatches(items, keyFn, batchSize = defaultBatchSize, yieldThreshold = defaultYieldThreshold) {
+    if (!Number.isInteger(batchSize) || batchSize <= 0) {
+        throw new Error('batchSize must be a positive integer');
+    }
+    if (!Number.isInteger(yieldThreshold) || yieldThreshold < 0) {
+        throw new Error('yieldThreshold must be a non-negative integer');
+    }
+    const process = async (i = 0, acc = {}, startTime = Date.now()) => {
+        if (i >= items.length)
+            return acc;
+        const batch = items.slice(i, i + batchSize);
+        const keys = await Promise.all(batch.map((item, j) => keyFn(item, i + j)));
+        const updated = keys.reduce((res, key, j) => {
+            const item = batch[j];
+            if (!res[key])
+                res[key] = [];
+            res[key] = res[key].concat(item);
+            return res;
+        }, { ...acc });
+        return defer(startTime, yieldThreshold).then((didYield) => process(i + batchSize, updated, didYield ? Date.now() : startTime));
+    };
+    return process();
+}
+/**
+ * Reduces an array in batches to avoid blocking the event loop.
+ * Processes items in chunks and yields control back to the event loop between batches
+ * when the processing time exceeds the threshold.
+ *
+ * @template T - The type of items in the array
+ * @template R - The type of the accumulator/result
+ * @param items - The array to reduce
+ * @param reducer - The reducer function. Receives the accumulator, current item, and index.
+ * @param initialValue - The initial value for the accumulator
+ * @param batchSize - The number of items to process in each batch (default: @see defaultBatchSize)
+ * @param yieldThreshold - Time threshold in milliseconds before yielding control (default: @see defaultYieldThreshold)
+ * @returns A promise that resolves to the reduced value
+ * @throws {Error} When batchSize is not a positive integer
+ *
+ * @example
+ * ```typescript
+ * // Sum numbers
+ * const sum = await reduceInBatches([1, 2, 3, 4], (acc, x) => acc + x, 0, 2);
+ * // Result: 10
+ *
+ * // Concatenate strings
+ * const joined = await reduceInBatches(['a', 'b', 'c'], (acc, x) => acc + x, '');
+ * // Result: 'abc'
+ *
+ * // Build object with index
+ * const indexed = await reduceInBatches(
+ *   ['x', 'y'],
+ *   (acc, item, index) => ({ ...acc, [index]: item }),
+ *   {}
+ * );
+ * // Result: {0: 'x', 1: 'y'}
+ *
+ * // Asynchronous reducer
+ * const processed = await reduceInBatches(urls, async (acc, url) => {
+ *   const data = await fetch(url).then(r => r.json());
+ *   return [...acc, data];
+ * }, []);
+ * ```
+ */
+function reduceInBatches(items, reducer, initialValue, batchSize = defaultBatchSize, yieldThreshold = defaultYieldThreshold) {
+    if (!Number.isInteger(batchSize) || batchSize <= 0) {
+        throw new Error('batchSize must be a positive integer');
+    }
+    if (!Number.isInteger(yieldThreshold) || yieldThreshold < 0) {
+        throw new Error('yieldThreshold must be a non-negative integer');
+    }
+    const process = async (i = 0, acc = initialValue, startTime = Date.now()) => {
+        if (i >= items.length)
+            return acc;
+        const batch = items.slice(i, i + batchSize);
+        const reduced = await batch.reduce(async (prevAcc, item, j) => {
+            const resolvedAcc = await prevAcc;
+            return reducer(resolvedAcc, item, i + j);
+        }, Promise.resolve(acc));
+        return defer(startTime, yieldThreshold).then((didYield) => process(i + batchSize, reduced, didYield ? Date.now() : startTime));
+    };
+    return process();
+}
+/**
+ * FlatMaps an array in batches to avoid blocking the event loop.
+ * Processes items in chunks, flattens the results, and yields control back to the event loop between batches
+ * when the processing time exceeds the threshold.
+ *
+ * @template T - The type of items in the input array
+ * @template R - The type of items in the flattened result array
+ * @param items - The array to flatMap over
+ * @param mapFn - The mapping function that returns an array for each item. Receives the item and its index.
+ * @param batchSize - The number of items to process in each batch (default: @see defaultBatchSize)
+ * @param yieldThreshold - Time threshold in milliseconds before yielding control (default: @see defaultYieldThreshold)
+ * @returns A promise that resolves to the flattened mapped array
+ * @throws {Error} When batchSize is not a positive integer
+ *
+ * @example
+ * ```typescript
+ * // Duplicate each item
+ * const duplicated = await flatMapInBatches([1, 2, 3], (x) => [x, x], 2);
+ * // Result: [1, 1, 2, 2, 3, 3]
+ *
+ * // Variable length results
+ * const repeated = await flatMapInBatches([1, 2, 3], (x) => Array(x).fill(x));
+ * // Result: [1, 2, 2, 3, 3, 3]
+ *
+ * // Split strings into characters
+ * const chars = await flatMapInBatches(['ab', 'cd'], (str) => str.split(''));
+ * // Result: ['a', 'b', 'c', 'd']
+ *
+ * // Asynchronous mapping
+ * const expanded = await flatMapInBatches(categories, async (category) => {
+ *   const items = await fetchItemsForCategory(category);
+ *   return items;
+ * });
+ * ```
+ */
+function flatMapInBatches(items, mapFn, batchSize = defaultBatchSize, yieldThreshold = defaultYieldThreshold) {
+    if (!Number.isInteger(batchSize) || batchSize <= 0) {
+        throw new Error('batchSize must be a positive integer');
+    }
+    if (!Number.isInteger(yieldThreshold) || yieldThreshold < 0) {
+        throw new Error('yieldThreshold must be a non-negative integer');
+    }
+    const process = async (i = 0, acc = [], startTime = Date.now()) => {
+        if (i >= items.length)
+            return acc;
+        const batch = items.slice(i, i + batchSize);
+        const mapped = await Promise.all(batch.map((item, j) => mapFn(item, i + j)));
+        const flattened = mapped.reduce((all, arr) => all.concat(arr), []);
+        return defer(startTime, yieldThreshold).then((didYield) => process(i + batchSize, acc.concat(flattened), didYield ? Date.now() : startTime));
+    };
+    return process();
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"batch-processing.js","sourceRoot":"","sources":["../../src/utils/batch-processing.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Configuration options for batch processing operations\n */\nexport interface BatchProcessingDefaults {\n  /**\n   * Default number of items to process in each batch\n   */\n  batchSize?: number;\n\n  /**\n   * Default time threshold in milliseconds before yielding control back to the event loop\n   */\n  yieldThreshold?: number;\n}\n\n// Default configuration values (internal)\nlet defaultBatchSize = 10;\nlet defaultYieldThreshold = 10;\n\n/**\n * Configure global defaults for batch processing operations\n *\n * @param config - Configuration options for batch processing\n * @returns The current configuration after applying changes\n *\n * @example\n * ```typescript\n * // Set both defaults\n * configureBatchProcessingDefaults({ batchSize: 20, yieldThreshold: 5 });\n *\n * // Set only batch size\n * configureBatchProcessingDefaults({ batchSize: 50 });\n *\n * // Get current configuration\n * const currentConfig = configureBatchProcessingDefaults();\n * ```\n */\nexport function configureBatchProcessingDefaults(\n  config?: BatchProcessingDefaults,\n): BatchProcessingDefaults {\n  if (config) {\n    if (config.batchSize !== undefined) {\n      if (!Number.isInteger(config.batchSize) || config.batchSize <= 0) {\n        throw new Error('batchSize must be a positive integer');\n      }\n      defaultBatchSize = config.batchSize;\n    }\n\n    if (config.yieldThreshold !== undefined) {\n      if (!Number.isInteger(config.yieldThreshold) || config.yieldThreshold < 0) {\n        throw new Error('yieldThreshold must be a non-negative integer');\n      }\n      defaultYieldThreshold = config.yieldThreshold;\n    }\n  }\n\n  return {\n    batchSize: defaultBatchSize,\n    yieldThreshold: defaultYieldThreshold,\n  };\n}\n\n/**\n * Utility function to defer execution to the next tick of the event loop.\n * This prevents blocking the event loop during heavy batch operations by\n * yielding control back to the event loop using setImmediate.\n *\n * @param startTime - The timestamp when the current batch processing started\n * @param yieldThreshold - Time threshold in milliseconds before yielding control\n * @returns A promise that resolves to a boolean indicating whether a yield occurred\n * @internal\n */\nfunction defer(startTime: number, yieldThreshold: number): Promise<boolean> {\n  const elapsed = Date.now() - startTime;\n\n  // Only yield if we've exceeded the threshold\n  if (elapsed >= yieldThreshold) {\n    return new Promise((resolve) => {\n      setImmediate(() => resolve(true));\n    });\n  }\n\n  // Otherwise continue immediately\n  return Promise.resolve(false);\n}\n\n/**\n * Maps over an array in batches to avoid blocking the event loop.\n * Processes items in chunks and yields control back to the event loop between batches\n * when the processing time exceeds the threshold.\n *\n * @template T - The type of items in the input array\n * @template R - The type of items in the result array\n * @param items - The array to map over\n * @param mapFn - The mapping function to apply to each item. Receives the item and its index.\n * @param batchSize - The number of items to process in each batch (default: @see defaultBatchSize)\n * @param yieldThreshold - Time threshold in milliseconds before yielding control (default: @see defaultYieldThreshold)\n * @returns A promise that resolves to the mapped array\n * @throws {Error} When batchSize is not a positive integer\n *\n * @example\n * ```typescript\n * // Synchronous mapping\n * const doubled = await mapInBatches([1, 2, 3, 4], (x) => x * 2, 2);\n * // Result: [2, 4, 6, 8]\n *\n * // Asynchronous mapping\n * const fetched = await mapInBatches(urls, async (url) => fetch(url), 3);\n *\n * // With index\n * const indexed = await mapInBatches(['a', 'b'], (item, index) => `${item}-${index}`);\n * // Result: ['a-0', 'b-1']\n * ```\n */\nexport function mapInBatches<T, R>(\n  items: T[],\n  mapFn: (item: T, index: number) => R | Promise<R>,\n  batchSize = defaultBatchSize,\n  yieldThreshold = defaultYieldThreshold,\n): Promise<R[]> {\n  if (!Number.isInteger(batchSize) || batchSize <= 0) {\n    throw new Error('batchSize must be a positive integer');\n  }\n  if (!Number.isInteger(yieldThreshold) || yieldThreshold < 0) {\n    throw new Error('yieldThreshold must be a non-negative integer');\n  }\n  const process = async (i = 0, acc: R[] = [], startTime = Date.now()): Promise<R[]> => {\n    if (i >= items.length) return acc;\n\n    const batch = items.slice(i, i + batchSize);\n    const mapped = await Promise.all(batch.map((item, j) => mapFn(item, i + j)));\n\n    return defer(startTime, yieldThreshold).then((didYield) =>\n      process(i + batchSize, acc.concat(mapped), didYield ? Date.now() : startTime),\n    );\n  };\n\n  return process();\n}\n\n/**\n * Filters an array in batches to avoid blocking the event loop.\n * Processes items in chunks and yields control back to the event loop between batches\n * when the processing time exceeds the threshold.\n *\n * @template T - The type of items in the array\n * @param items - The array to filter\n * @param predicate - The predicate function to test each item. Receives the item and its index.\n * @param batchSize - The number of items to process in each batch (default: @see defaultBatchSize)\n * @param yieldThreshold - Time threshold in milliseconds before yielding control (default: @see defaultYieldThreshold)\n * @returns A promise that resolves to the filtered array\n * @throws {Error} When batchSize is not a positive integer\n *\n * @example\n * ```typescript\n * // Synchronous filtering\n * const evens = await filterInBatches([1, 2, 3, 4, 5], (x) => x % 2 === 0, 2);\n * // Result: [2, 4]\n *\n * // Asynchronous filtering\n * const valid = await filterInBatches(urls, async (url) => {\n *   const response = await fetch(url);\n *   return response.ok;\n * }, 3);\n *\n * // With index\n * const evenIndices = await filterInBatches(['a', 'b', 'c'], (_, index) => index % 2 === 0);\n * // Result: ['a', 'c']\n * ```\n */\nexport function filterInBatches<T>(\n  items: T[],\n  predicate: (item: T, index: number) => boolean | Promise<boolean>,\n  batchSize = defaultBatchSize,\n  yieldThreshold = defaultYieldThreshold,\n): Promise<T[]> {\n  if (!Number.isInteger(batchSize) || batchSize <= 0) {\n    throw new Error('batchSize must be a positive integer');\n  }\n  if (!Number.isInteger(yieldThreshold) || yieldThreshold < 0) {\n    throw new Error('yieldThreshold must be a non-negative integer');\n  }\n  const process = async (i = 0, acc: T[] = [], startTime = Date.now()): Promise<T[]> => {\n    if (i >= items.length) return acc;\n\n    const batch = items.slice(i, i + batchSize);\n    const flags = await Promise.all(batch.map((item, j) => predicate(item, i + j)));\n\n    const filtered = batch.filter((_, j) => flags[j]);\n\n    return defer(startTime, yieldThreshold).then((didYield) =>\n      process(i + batchSize, acc.concat(filtered), didYield ? Date.now() : startTime),\n    );\n  };\n\n  return process();\n}\n\n/**\n * Groups an array by a key function in batches to avoid blocking the event loop.\n * Processes items in chunks and yields control back to the event loop between batches\n * when the processing time exceeds the threshold.\n *\n * @template T - The type of items in the array\n * @template K - The type of the grouping key (must extend PropertyKey)\n * @param items - The array to group\n * @param keyFn - The function to extract the grouping key from each item. Receives the item and its index.\n * @param batchSize - The number of items to process in each batch (default: @see defaultBatchSize)\n * @param yieldThreshold - Time threshold in milliseconds before yielding control (default: @see defaultYieldThreshold)\n * @returns A promise that resolves to an object with grouped items\n * @throws {Error} When batchSize is not a positive integer\n *\n * @example\n * ```typescript\n * // Group by property\n * const byType = await groupByInBatches(\n *   [{type: 'A', value: 1}, {type: 'B', value: 2}, {type: 'A', value: 3}],\n *   (item) => item.type,\n *   2\n * );\n * // Result: {A: [{type: 'A', value: 1}, {type: 'A', value: 3}], B: [{type: 'B', value: 2}]}\n *\n * // Group by computed value\n * const byParity = await groupByInBatches([1, 2, 3, 4], (x) => x % 2 === 0 ? 'even' : 'odd');\n * // Result: {odd: [1, 3], even: [2, 4]}\n *\n * // Asynchronous key function\n * const byCategory = await groupByInBatches(items, async (item) => {\n *   return await getCategoryForItem(item);\n * });\n * ```\n */\nexport function groupByInBatches<T, K extends PropertyKey>(\n  items: T[],\n  keyFn: (item: T, index: number) => K | Promise<K>,\n  batchSize = defaultBatchSize,\n  yieldThreshold = defaultYieldThreshold,\n): Promise<Record<K, T[]>> {\n  if (!Number.isInteger(batchSize) || batchSize <= 0) {\n    throw new Error('batchSize must be a positive integer');\n  }\n  if (!Number.isInteger(yieldThreshold) || yieldThreshold < 0) {\n    throw new Error('yieldThreshold must be a non-negative integer');\n  }\n  const process = async (\n    i = 0,\n    acc: Record<K, T[]> = {} as Record<K, T[]>,\n    startTime = Date.now(),\n  ): Promise<Record<K, T[]>> => {\n    if (i >= items.length) return acc;\n\n    const batch = items.slice(i, i + batchSize);\n    const keys = await Promise.all(batch.map((item, j) => keyFn(item, i + j)));\n\n    const updated = keys.reduce(\n      (res, key, j) => {\n        const item = batch[j];\n        if (!res[key]) res[key] = [];\n        res[key] = res[key].concat(item);\n        return res;\n      },\n      { ...acc },\n    );\n\n    return defer(startTime, yieldThreshold).then((didYield) =>\n      process(i + batchSize, updated, didYield ? Date.now() : startTime),\n    );\n  };\n\n  return process();\n}\n\n/**\n * Reduces an array in batches to avoid blocking the event loop.\n * Processes items in chunks and yields control back to the event loop between batches\n * when the processing time exceeds the threshold.\n *\n * @template T - The type of items in the array\n * @template R - The type of the accumulator/result\n * @param items - The array to reduce\n * @param reducer - The reducer function. Receives the accumulator, current item, and index.\n * @param initialValue - The initial value for the accumulator\n * @param batchSize - The number of items to process in each batch (default: @see defaultBatchSize)\n * @param yieldThreshold - Time threshold in milliseconds before yielding control (default: @see defaultYieldThreshold)\n * @returns A promise that resolves to the reduced value\n * @throws {Error} When batchSize is not a positive integer\n *\n * @example\n * ```typescript\n * // Sum numbers\n * const sum = await reduceInBatches([1, 2, 3, 4], (acc, x) => acc + x, 0, 2);\n * // Result: 10\n *\n * // Concatenate strings\n * const joined = await reduceInBatches(['a', 'b', 'c'], (acc, x) => acc + x, '');\n * // Result: 'abc'\n *\n * // Build object with index\n * const indexed = await reduceInBatches(\n *   ['x', 'y'],\n *   (acc, item, index) => ({ ...acc, [index]: item }),\n *   {}\n * );\n * // Result: {0: 'x', 1: 'y'}\n *\n * // Asynchronous reducer\n * const processed = await reduceInBatches(urls, async (acc, url) => {\n *   const data = await fetch(url).then(r => r.json());\n *   return [...acc, data];\n * }, []);\n * ```\n */\nexport function reduceInBatches<T, R>(\n  items: T[],\n  reducer: (acc: R, item: T, index: number) => R | Promise<R>,\n  initialValue: R,\n  batchSize = defaultBatchSize,\n  yieldThreshold = defaultYieldThreshold,\n): Promise<R> {\n  if (!Number.isInteger(batchSize) || batchSize <= 0) {\n    throw new Error('batchSize must be a positive integer');\n  }\n  if (!Number.isInteger(yieldThreshold) || yieldThreshold < 0) {\n    throw new Error('yieldThreshold must be a non-negative integer');\n  }\n  const process = async (i = 0, acc: R = initialValue, startTime = Date.now()): Promise<R> => {\n    if (i >= items.length) return acc;\n\n    const batch = items.slice(i, i + batchSize);\n    const reduced = await batch.reduce<Promise<R>>(async (prevAcc, item, j) => {\n      const resolvedAcc = await prevAcc;\n      return reducer(resolvedAcc, item, i + j);\n    }, Promise.resolve(acc));\n\n    return defer(startTime, yieldThreshold).then((didYield) =>\n      process(i + batchSize, reduced, didYield ? Date.now() : startTime),\n    );\n  };\n\n  return process();\n}\n\n/**\n * FlatMaps an array in batches to avoid blocking the event loop.\n * Processes items in chunks, flattens the results, and yields control back to the event loop between batches\n * when the processing time exceeds the threshold.\n *\n * @template T - The type of items in the input array\n * @template R - The type of items in the flattened result array\n * @param items - The array to flatMap over\n * @param mapFn - The mapping function that returns an array for each item. Receives the item and its index.\n * @param batchSize - The number of items to process in each batch (default: @see defaultBatchSize)\n * @param yieldThreshold - Time threshold in milliseconds before yielding control (default: @see defaultYieldThreshold)\n * @returns A promise that resolves to the flattened mapped array\n * @throws {Error} When batchSize is not a positive integer\n *\n * @example\n * ```typescript\n * // Duplicate each item\n * const duplicated = await flatMapInBatches([1, 2, 3], (x) => [x, x], 2);\n * // Result: [1, 1, 2, 2, 3, 3]\n *\n * // Variable length results\n * const repeated = await flatMapInBatches([1, 2, 3], (x) => Array(x).fill(x));\n * // Result: [1, 2, 2, 3, 3, 3]\n *\n * // Split strings into characters\n * const chars = await flatMapInBatches(['ab', 'cd'], (str) => str.split(''));\n * // Result: ['a', 'b', 'c', 'd']\n *\n * // Asynchronous mapping\n * const expanded = await flatMapInBatches(categories, async (category) => {\n *   const items = await fetchItemsForCategory(category);\n *   return items;\n * });\n * ```\n */\nexport function flatMapInBatches<T, R>(\n  items: T[],\n  mapFn: (item: T, index: number) => R[] | Promise<R[]>,\n  batchSize = defaultBatchSize,\n  yieldThreshold = defaultYieldThreshold,\n): Promise<R[]> {\n  if (!Number.isInteger(batchSize) || batchSize <= 0) {\n    throw new Error('batchSize must be a positive integer');\n  }\n  if (!Number.isInteger(yieldThreshold) || yieldThreshold < 0) {\n    throw new Error('yieldThreshold must be a non-negative integer');\n  }\n  const process = async (i = 0, acc: R[] = [], startTime = Date.now()): Promise<R[]> => {\n    if (i >= items.length) return acc;\n\n    const batch = items.slice(i, i + batchSize);\n    const mapped = await Promise.all(batch.map((item, j) => mapFn(item, i + j)));\n    const flattened = mapped.reduce((all, arr) => all.concat(arr), []);\n\n    return defer(startTime, yieldThreshold).then((didYield) =>\n      process(i + batchSize, acc.concat(flattened), didYield ? Date.now() : startTime),\n    );\n  };\n\n  return process();\n}\n"]}

package/build/utils/index.d.ts

@@ -1,3 +1,4 @@
+export * from './batch-processing';
 export * from './json-schema-generator';
 export * from './misc';
 export * from './request';

package/build/utils/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC;AACxC,cAAc,QAAQ,CAAC;AACvB,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC;AACxB,cAAc,OAAO,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,yBAAyB,CAAC;AACxC,cAAc,QAAQ,CAAC;AACvB,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC;AACxB,cAAc,OAAO,CAAC"}

package/build/utils/index.js

@@ -14,9 +14,10 @@ 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 });
+__exportStar(require("./batch-processing"), exports);
 __exportStar(require("./json-schema-generator"), exports);
 __exportStar(require("./misc"), exports);
 __exportStar(require("./request"), exports);
 __exportStar(require("./tests"), exports);
 __exportStar(require("./zod"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDBEQUF3QztBQUN4Qyx5Q0FBdUI7QUFDdkIsNENBQTBCO0FBQzFCLDBDQUF3QjtBQUN4Qix3Q0FBc0IiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2pzb24tc2NoZW1hLWdlbmVyYXRvcic7XG5leHBvcnQgKiBmcm9tICcuL21pc2MnO1xuZXhwb3J0ICogZnJvbSAnLi9yZXF1ZXN0JztcbmV4cG9ydCAqIGZyb20gJy4vdGVzdHMnO1xuZXhwb3J0ICogZnJvbSAnLi96b2QnO1xuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXRpbHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLHFEQUFtQztBQUNuQywwREFBd0M7QUFDeEMseUNBQXVCO0FBQ3ZCLDRDQUEwQjtBQUMxQiwwQ0FBd0I7QUFDeEIsd0NBQXNCIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9iYXRjaC1wcm9jZXNzaW5nJztcbmV4cG9ydCAqIGZyb20gJy4vanNvbi1zY2hlbWEtZ2VuZXJhdG9yJztcbmV4cG9ydCAqIGZyb20gJy4vbWlzYyc7XG5leHBvcnQgKiBmcm9tICcuL3JlcXVlc3QnO1xuZXhwb3J0ICogZnJvbSAnLi90ZXN0cyc7XG5leHBvcnQgKiBmcm9tICcuL3pvZCc7XG4iXX0=

package/build/utils/misc.d.ts

@@ -136,4 +136,17 @@ export declare const generateRandomString: (length?: number) => string;
  * In case of empty array, the key is removed from the output
  */
 export declare const flattenQueryParams: (qParams: Record<string, any | any[]>) => Record<string, any>;
+/**
+ * Recursively freezes an object and all its properties.
+ * This makes the object and its nested properties immutable.
+ *
+ * @template T - The type of the object to freeze
+ * @param {T} obj - The object to freeze
+ * @returns {Readonly<T>} - The frozen object
+ *
+ * @example
+ * const config = deepFreeze({ api: { key: 'secret', timeout: 1000 } });
+ * // Attempting to modify config.api.key will throw an error in strict mode
+ */
+export declare const deepFreeze: <T>(obj: T) => Readonly<T>;
 //# sourceMappingURL=misc.d.ts.map

package/build/utils/misc.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"misc.d.ts","sourceRoot":"","sources":["../../src/utils/misc.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"misc.d.ts","sourceRoot":"","sources":["../../src/utils/misc.ts"],"names":[],"mappings":"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"}

package/build/utils/misc.js

@@ -36,7 +36,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.flattenQueryParams = exports.generateRandomString = exports.uuidv5 = exports.convertToString = exports.generateUUID = exports.hashToSha256 = exports.formatTimeStamp = exports.getOffsetInSec = exports.flattenJson = exports.getValueFromPropertiesOrTraits = exports.getHashFromArrayWithValueAsObject = exports.getHashFromArrayWithDuplicate = exports.getHashFromArray = exports.removeUndefinedNullEmptyExclBoolInt = exports.isDefinedNotNullNotEmpty = exports.isEmptyObject = exports.isEmpty = exports.isObject = exports.getType = exports.isPrimitive = exports.stripTrailingSlash = exports.isValidUrl = exports.base64Convertor = exports.flattenMap = exports.removeUndefinedAndNullAndEmptyValues = exports.removeUndefinedAndNullValues = exports.removeNullValues = exports.removeUndefinedValues = exports.isBlank = exports.isDefinedAndNotNullAndNotEmpty = exports.isDefinedAndNotNull = exports.isNotNull = exports.isNotEmpty = exports.isDefined = exports.set = exports.get = void 0;
+exports.deepFreeze = exports.flattenQueryParams = exports.generateRandomString = exports.uuidv5 = exports.convertToString = exports.generateUUID = exports.hashToSha256 = exports.formatTimeStamp = exports.getOffsetInSec = exports.flattenJson = exports.getValueFromPropertiesOrTraits = exports.getHashFromArrayWithValueAsObject = exports.getHashFromArrayWithDuplicate = exports.getHashFromArray = exports.removeUndefinedNullEmptyExclBoolInt = exports.isDefinedNotNullNotEmpty = exports.isEmptyObject = exports.isEmpty = exports.isObject = exports.getType = exports.isPrimitive = exports.stripTrailingSlash = exports.isValidUrl = exports.base64Convertor = exports.flattenMap = exports.removeUndefinedAndNullAndEmptyValues = exports.removeUndefinedAndNullValues = exports.removeNullValues = exports.removeUndefinedValues = exports.isBlank = exports.isDefinedAndNotNullAndNotEmpty = exports.isDefinedAndNotNull = exports.isNotNull = exports.isNotEmpty = exports.isDefined = exports.set = exports.get = void 0;
 const lodash_1 = __importDefault(require("lodash"));
 const get_value_1 = __importDefault(require("get-value"));
 exports.get = get_value_1.default;
@@ -386,4 +386,31 @@ const flattenQueryParams = (qParams) => {
     return formattedOutput;
 };
 exports.flattenQueryParams = flattenQueryParams;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"misc.js","sourceRoot":"","sources":["../../src/utils/misc.ts"],"names":[],"mappings":"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","sourcesContent":["import _ from 'lodash';\nimport get from 'get-value';\nimport set from 'set-value';\nimport moment from 'moment-timezone';\nimport sha256 from 'sha256';\nimport crypto from 'crypto';\nimport { v5 } from 'uuid';\nimport * as logger from '../logger';\n\ninterface DestinationMap {\n  [key: string]: string;\n}\n\n// ========================================================================\n// INLINERS\n// ========================================================================\nexport { get, set };\nexport const isDefined = (x: unknown) => !_.isUndefined(x);\nexport const isNotEmpty = (x: unknown) => !_.isEmpty(x);\nexport const isNotNull = (x: unknown) => x != null;\nexport const isDefinedAndNotNull = (x: unknown) => isDefined(x) && isNotNull(x);\nexport const isDefinedAndNotNullAndNotEmpty = (x: unknown) =>\n  isDefined(x) && isNotNull(x) && isNotEmpty(x);\nexport const isBlank = (value: unknown) => _.isEmpty(_.toString(value));\n\n// ========================================================================\nexport const removeUndefinedValues = (obj: unknown) => {\n  if (!_.isObject(obj)) return obj;\n  return _.pickBy(obj, isDefined);\n};\n\nexport const removeNullValues = (obj: unknown) => {\n  if (!_.isObject(obj)) return obj;\n  return _.pickBy(obj, isNotNull);\n};\nexport const removeUndefinedAndNullValues = (obj: unknown) => {\n  if (!_.isObject(obj)) return obj;\n  return _.pickBy(obj, isDefinedAndNotNull);\n};\nexport const removeUndefinedAndNullAndEmptyValues = (obj: unknown) => {\n  if (!_.isObject(obj)) return obj;\n  return _.pickBy(obj, isDefinedAndNotNullAndNotEmpty);\n};\n\n/**\n * The flattenMap function takes a collection as input and returns a flattened version of the collection. If the input is not an array or an object, it is returned as is. Otherwise, the function uses the flatMap function from the lodash library to flatten the collection.\n * @param collection\n * @returns\n */\nexport const flattenMap = (collection: unknown) => {\n  if (!_.isArray(collection) && !_.isObject(collection)) return collection;\n  return _.flatMap(collection, (x) => x);\n};\n\n// ========================================================================\n// GENERIC UTLITY\n// ========================================================================\n\nexport const base64Convertor = (string: string) => Buffer.from(string).toString('base64');\n\n// return a valid URL object if correct else null\nexport const isValidUrl = (url: string | URL) => {\n  try {\n    return new URL(url);\n  } catch (err) {\n    return null;\n  }\n};\n\nexport const stripTrailingSlash = (str: string) =>\n  str && str.endsWith('/') ? str.slice(0, -1) : str;\n\nexport const isPrimitive = (arg: unknown) => {\n  const type = typeof arg;\n  return arg == null || (type !== 'object' && type !== 'function');\n};\n\n/**\n *\n * @param {*} arg\n * @returns {type}\n *\n * Returns type of passed arg\n * for null argss returns \"NULL\" insted of \"object\"\n *\n */\nexport const getType = (arg: unknown) => {\n  const type = typeof arg;\n  if (arg == null) {\n    return 'NULL';\n  }\n  if (Array.isArray(arg)) {\n    return 'array';\n  }\n  return type;\n};\n\nexport const isObject = (value: unknown) => {\n  const type = typeof value;\n  return value != null && (type === 'object' || type === 'function') && !Array.isArray(value);\n};\n\nexport const isEmpty = (input: unknown) => _.isEmpty(_.toString(input).trim());\n\n/**\n * Returns true for empty object {}\n * @param {*} obj\n * @returns\n */\nexport const isEmptyObject = (obj: any) => {\n  if (!obj) {\n    logger.warn('input is undefined or null');\n    return true;\n  }\n  return Object.keys(obj).length === 0;\n};\n\n/**\n * Function to check if value is Defined, Not null and Not Empty.\n * Create this function, Because existing isDefinedAndNotNullAndNotEmpty(123) is returning false due to lodash _.isEmpty function.\n * _.isEmpty is used to detect empty collections/objects and it will return true for Integer, Boolean values.\n * ref: https://github.com/lodash/lodash/issues/496\n * @param {*} value 123\n * @returns yes\n */\nexport const isDefinedNotNullNotEmpty = (value: unknown) =>\n  !(\n    value === undefined ||\n    value === null ||\n    Number.isNaN(value) ||\n    (typeof value === 'object' && Object.keys(value).length === 0) ||\n    (typeof value === 'string' && value.trim().length === 0)\n  );\n\nexport const removeUndefinedNullEmptyExclBoolInt = (obj: unknown) => {\n  if (!_.isObject(obj)) return obj;\n  return _.pickBy(obj, isDefinedNotNullNotEmpty);\n};\n\n// Format the destination.Config.dynamicMap arrays to hashMap\nexport const getHashFromArray = (\n  arrays: Array<DestinationMap>,\n  fromKey: string = 'from',\n  toKey: string = 'to',\n  isLowerCase = true,\n) => {\n  const hashMap: Record<string, any> = {};\n  if (Array.isArray(arrays)) {\n    arrays.forEach((array) => {\n      if (isEmpty(array[fromKey])) return;\n      hashMap[isLowerCase ? array[fromKey].toString().toLowerCase() : array[fromKey]] =\n        array[toKey];\n    });\n  }\n  return hashMap;\n};\n\n/**\n * Format the destination.Config.dynamicMap arrays to hashMap\n * where value is an array\n * @param  {} arrays [{\"from\":\"prop1\",\"to\":\"val1\"},{\"from\":\"prop1\",\"to\":\"val2\"},{\"from\":\"prop2\",\"to\":\"val2\"}]\n * @param  {} fromKey=\"from\"\n * @param  {} toKey=\"to\"\n * @param  {} isLowerCase=true\n * @param  {} return hashmap {\"prop1\":[\"val1\",\"val2\"],\"prop2\":[\"val2\"]}\n */\nexport const getHashFromArrayWithDuplicate = (\n  arrays: Array<DestinationMap>,\n  fromKey = 'from' as string,\n  toKey = 'to',\n  isLowerCase = true,\n) => {\n  const hashMap: Record<string, any> = {};\n  if (Array.isArray(arrays)) {\n    arrays.forEach((array) => {\n      if (isEmpty(array[fromKey])) return;\n      const key = isLowerCase\n        ? array[fromKey].toString().toLowerCase().trim()\n        : array[fromKey].toString().trim();\n\n      if (hashMap[key]) {\n        hashMap[key].add(array[toKey]);\n      } else {\n        hashMap[key] = new Set();\n        hashMap[key].add(array[toKey]);\n      }\n    });\n  }\n  return hashMap;\n};\n\n/**\n * Format the arrays to hashMap with key as `fromKey` and value as Object\n * @param {*} arrays [{\"id\":\"a0b8efe1-c828-4c63-8850-0d0742888f9d\",\"name\":\"Email\",\"type\":\"email\",\"type_config\":{},\"date_created\":\"1662225840284\",\"hide_from_guests\":false,\"required\":false}]\n * @param {*} fromKey name\n * @param {*} isLowerCase false\n * @returns // {\"Email\":{\"id\":\"a0b8efe1-c828-4c63-8850-0d0742888f9d\",\"name\":\"Email\",\"type\":\"email\",\"type_config\":{},\"date_created\":\"1662225840284\",\"hide_from_guests\":false,\"required\":false}}\n */\nexport const getHashFromArrayWithValueAsObject = (\n  arrays: Array<DestinationMap>,\n  fromKey = 'from',\n  isLowerCase = true,\n) => {\n  const hashMap: Record<string, any> = {};\n  if (Array.isArray(arrays)) {\n    arrays.forEach((array) => {\n      if (isEmpty(array[fromKey])) return;\n      hashMap[isLowerCase ? array[fromKey].toLowerCase() : array[fromKey]] = array;\n    });\n  }\n  return hashMap;\n};\n\n/**\n * Retrieves a value from a message object based on a given key. It searches for the key in the properties, traits, and context.traits of the message object in that order.\n *\n * @param {Object} options - The options object.\n * @param {Object} options.message - The message object containing properties, traits, and context.traits.\n * @param {string} options.key - The key to search for in the message object.\n * @returns {*} The value found in the message object for the given key, or null if the key is not found or the value is null.\n */\nexport const getValueFromPropertiesOrTraits = ({ message, key }: { message: any; key: any }) => {\n  const keySet = ['properties', 'traits', 'context.traits'];\n\n  const val = _.find(\n    _.map(keySet, (k) => get(message, `${k}.${key}`)),\n    (v) => !_.isNil(v),\n  );\n  return !_.isNil(val) ? val : null;\n};\n\n/**\n * Flattens a JSON object into a single-level object.\n *\n * @param data - The JSON object to be flattened.\n * @param separator - The character used to separate the keys in the flattened object. Default is '.'.\n * @param mode - The mode used to flatten arrays. If set to 'strict', the array indices will be included in the flattened keys. Default is 'normal'.\n * @returns The flattened JSON object.\n */\nexport const flattenJson = (data: unknown, separator = '.', mode = 'normal') => {\n  const result: Record<any, any> = {};\n\n  // a recursive function to loop through the array of the data\n  const recurse = (cur: any, prop: any) => {\n    let i;\n    if (Object(cur) !== cur) {\n      result[prop] = cur;\n    } else if (Array.isArray(cur)) {\n      for (i = 0; i < cur.length; i += 1) {\n        if (mode === 'strict') {\n          recurse(cur[i], `${prop}${separator}${i}`);\n        } else {\n          recurse(cur[i], `${prop}[${i}]`);\n        }\n      }\n      if (cur.length === 0) {\n        result[prop] = [];\n      }\n    } else {\n      let isEmptyFlag = true;\n      Object.keys(cur).forEach((key) => {\n        isEmptyFlag = false;\n        recurse(cur[key], prop ? `${prop}${separator}${key}` : key);\n      });\n      if (isEmptyFlag && prop) result[prop] = {};\n    }\n  };\n\n  recurse(data, '');\n  return result;\n};\n\n/**\n * Get the offset value in seconds for a given timezone.\n *\n * @param value - The timezone value for which the offset needs to be calculated.\n * @returns The offset value in seconds for the given timezone. If the timezone is invalid or not found, it returns `undefined`.\n *\n * @example\n * const offset = getOffsetInSec('Asia/Calcutta');\n * console.log(offset); // Output: 19800\n */\nexport const getOffsetInSec = (value: string) => {\n  const name = moment.tz.zone(value);\n  if (name) {\n    const x = moment().tz(value).format('Z');\n    const split = x.split(':');\n    const hour = Number(split[0]);\n    const min = Number(split[1]);\n    let sec = 0;\n    sec = hour < 0 ? -1 * (hour * -60 * 60 + min * 60) : hour * 60 * 60 + min * 60;\n    return sec;\n  }\n  return undefined;\n};\n\n/**\n * Converts a date string into a formatted timestamp.\n * If a format string is provided, it uses the moment library to format the date.\n * If no format string is provided, it returns the timestamp of the date.\n * @param dateStr - The date string to be formatted.\n * @param format - (Optional) The format string to be used for formatting the date.\n * @returns The formatted date as a string if a format string is provided,\n *          otherwise the timestamp of the date as a number.\n */\nexport const formatTimeStamp = (dateStr: string, format?: string) => {\n  const date = new Date(dateStr);\n  // moment format is passed. format accordingly\n  if (format) {\n    return moment.utc(date).format(format);\n  }\n\n  // return default format\n  return date.getTime();\n};\n\nexport const hashToSha256 = (value: string | Buffer | number[]) => sha256(value);\n\n/**\n * Generates a Universally Unique Identifier (UUID) using the `crypto.randomUUID()` method.\n * The `disableEntropyCache` option is set to `true` to prevent caching of generated UUIDs.\n *\n * @returns {string} A randomly generated UUID.\n *\n * @see {@link https://nodejs.org/api/crypto.html#cryptorandomuuidoptions:~:text=options%20%3CObject%3E-,disableEntropyCache,-%3Cboolean%3E%20By}\n */\nexport const generateUUID = (): string => crypto.randomUUID({ disableEntropyCache: true });\n\nexport const convertToString = (value: any) => {\n  if (typeof value === 'string') {\n    return value;\n  }\n  return JSON.stringify(value);\n};\n\nconst uuid_namespace = 'e76c6e51-06f9-4222-9636-5aba7e3a84b6';\nexport const uuidv5 = (val: string) => v5(val, uuid_namespace);\n\nexport const generateRandomString = (length: number = 10) =>\n  crypto.randomBytes(length).toString('hex').slice(0, length);\n\n/**\n *\n * @param {Record<string, any | any[]} qParams - Object containing parameters where values are arrays\n * @returns {Record<string, any>} Flattened object where array values of length one are replaced with their first element\n * @description\n * Flattens an object by replacing array values of length one with their first element,\n * while keeping non-array values or arrays of length more than one unchanged.\n * In case of empty array, the key is removed from the output\n */\nexport const flattenQueryParams = (qParams: Record<string, any | any[]>): Record<string, any> => {\n  if (!qParams) return {}; // Early return for nullish values\n  const formattedOutput: Record<string, any> = {};\n\n  Object.entries(qParams).forEach(([key, value]) => {\n    const finalValue = Array.isArray(value) && value.length <= 1 ? value[0] : value;\n    if (finalValue !== undefined && finalValue !== null) {\n      formattedOutput[key] = finalValue;\n    }\n  });\n\n  return formattedOutput;\n};\n"]}
+/**
+ * Recursively freezes an object and all its properties.
+ * This makes the object and its nested properties immutable.
+ *
+ * @template T - The type of the object to freeze
+ * @param {T} obj - The object to freeze
+ * @returns {Readonly<T>} - The frozen object
+ *
+ * @example
+ * const config = deepFreeze({ api: { key: 'secret', timeout: 1000 } });
+ * // Attempting to modify config.api.key will throw an error in strict mode
+ */
+const deepFreeze = (obj) => {
+    // If the object is null, undefined, or not an object, return it as is
+    if (!obj || typeof obj !== 'object')
+        return obj;
+    // Freeze all properties of the object
+    Object.getOwnPropertyNames(obj).forEach((key) => {
+        const value = obj[key];
+        if (value && typeof value === 'object' && !Object.isFrozen(value)) {
+            (0, exports.deepFreeze)(value);
+        }
+    });
+    // Freeze the object itself and return it
+    return Object.freeze(obj);
+};
+exports.deepFreeze = deepFreeze;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"misc.js","sourceRoot":"","sources":["../../src/utils/misc.ts"],"names":[],"mappings":"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","sourcesContent":["import _ from 'lodash';\nimport get from 'get-value';\nimport set from 'set-value';\nimport moment from 'moment-timezone';\nimport sha256 from 'sha256';\nimport crypto from 'crypto';\nimport { v5 } from 'uuid';\nimport * as logger from '../logger';\n\ninterface DestinationMap {\n  [key: string]: string;\n}\n\n// ========================================================================\n// INLINERS\n// ========================================================================\nexport { get, set };\nexport const isDefined = (x: unknown) => !_.isUndefined(x);\nexport const isNotEmpty = (x: unknown) => !_.isEmpty(x);\nexport const isNotNull = (x: unknown) => x != null;\nexport const isDefinedAndNotNull = (x: unknown) => isDefined(x) && isNotNull(x);\nexport const isDefinedAndNotNullAndNotEmpty = (x: unknown) =>\n  isDefined(x) && isNotNull(x) && isNotEmpty(x);\nexport const isBlank = (value: unknown) => _.isEmpty(_.toString(value));\n\n// ========================================================================\nexport const removeUndefinedValues = (obj: unknown) => {\n  if (!_.isObject(obj)) return obj;\n  return _.pickBy(obj, isDefined);\n};\n\nexport const removeNullValues = (obj: unknown) => {\n  if (!_.isObject(obj)) return obj;\n  return _.pickBy(obj, isNotNull);\n};\nexport const removeUndefinedAndNullValues = (obj: unknown) => {\n  if (!_.isObject(obj)) return obj;\n  return _.pickBy(obj, isDefinedAndNotNull);\n};\nexport const removeUndefinedAndNullAndEmptyValues = (obj: unknown) => {\n  if (!_.isObject(obj)) return obj;\n  return _.pickBy(obj, isDefinedAndNotNullAndNotEmpty);\n};\n\n/**\n * The flattenMap function takes a collection as input and returns a flattened version of the collection. If the input is not an array or an object, it is returned as is. Otherwise, the function uses the flatMap function from the lodash library to flatten the collection.\n * @param collection\n * @returns\n */\nexport const flattenMap = (collection: unknown) => {\n  if (!_.isArray(collection) && !_.isObject(collection)) return collection;\n  return _.flatMap(collection, (x) => x);\n};\n\n// ========================================================================\n// GENERIC UTLITY\n// ========================================================================\n\nexport const base64Convertor = (string: string) => Buffer.from(string).toString('base64');\n\n// return a valid URL object if correct else null\nexport const isValidUrl = (url: string | URL) => {\n  try {\n    return new URL(url);\n  } catch (err) {\n    return null;\n  }\n};\n\nexport const stripTrailingSlash = (str: string) =>\n  str && str.endsWith('/') ? str.slice(0, -1) : str;\n\nexport const isPrimitive = (arg: unknown) => {\n  const type = typeof arg;\n  return arg == null || (type !== 'object' && type !== 'function');\n};\n\n/**\n *\n * @param {*} arg\n * @returns {type}\n *\n * Returns type of passed arg\n * for null argss returns \"NULL\" insted of \"object\"\n *\n */\nexport const getType = (arg: unknown) => {\n  const type = typeof arg;\n  if (arg == null) {\n    return 'NULL';\n  }\n  if (Array.isArray(arg)) {\n    return 'array';\n  }\n  return type;\n};\n\nexport const isObject = (value: unknown) => {\n  const type = typeof value;\n  return value != null && (type === 'object' || type === 'function') && !Array.isArray(value);\n};\n\nexport const isEmpty = (input: unknown) => _.isEmpty(_.toString(input).trim());\n\n/**\n * Returns true for empty object {}\n * @param {*} obj\n * @returns\n */\nexport const isEmptyObject = (obj: any) => {\n  if (!obj) {\n    logger.warn('input is undefined or null');\n    return true;\n  }\n  return Object.keys(obj).length === 0;\n};\n\n/**\n * Function to check if value is Defined, Not null and Not Empty.\n * Create this function, Because existing isDefinedAndNotNullAndNotEmpty(123) is returning false due to lodash _.isEmpty function.\n * _.isEmpty is used to detect empty collections/objects and it will return true for Integer, Boolean values.\n * ref: https://github.com/lodash/lodash/issues/496\n * @param {*} value 123\n * @returns yes\n */\nexport const isDefinedNotNullNotEmpty = (value: unknown) =>\n  !(\n    value === undefined ||\n    value === null ||\n    Number.isNaN(value) ||\n    (typeof value === 'object' && Object.keys(value).length === 0) ||\n    (typeof value === 'string' && value.trim().length === 0)\n  );\n\nexport const removeUndefinedNullEmptyExclBoolInt = (obj: unknown) => {\n  if (!_.isObject(obj)) return obj;\n  return _.pickBy(obj, isDefinedNotNullNotEmpty);\n};\n\n// Format the destination.Config.dynamicMap arrays to hashMap\nexport const getHashFromArray = (\n  arrays: Array<DestinationMap>,\n  fromKey: string = 'from',\n  toKey: string = 'to',\n  isLowerCase = true,\n) => {\n  const hashMap: Record<string, any> = {};\n  if (Array.isArray(arrays)) {\n    arrays.forEach((array) => {\n      if (isEmpty(array[fromKey])) return;\n      hashMap[isLowerCase ? array[fromKey].toString().toLowerCase() : array[fromKey]] =\n        array[toKey];\n    });\n  }\n  return hashMap;\n};\n\n/**\n * Format the destination.Config.dynamicMap arrays to hashMap\n * where value is an array\n * @param  {} arrays [{\"from\":\"prop1\",\"to\":\"val1\"},{\"from\":\"prop1\",\"to\":\"val2\"},{\"from\":\"prop2\",\"to\":\"val2\"}]\n * @param  {} fromKey=\"from\"\n * @param  {} toKey=\"to\"\n * @param  {} isLowerCase=true\n * @param  {} return hashmap {\"prop1\":[\"val1\",\"val2\"],\"prop2\":[\"val2\"]}\n */\nexport const getHashFromArrayWithDuplicate = (\n  arrays: Array<DestinationMap>,\n  fromKey = 'from' as string,\n  toKey = 'to',\n  isLowerCase = true,\n) => {\n  const hashMap: Record<string, any> = {};\n  if (Array.isArray(arrays)) {\n    arrays.forEach((array) => {\n      if (isEmpty(array[fromKey])) return;\n      const key = isLowerCase\n        ? array[fromKey].toString().toLowerCase().trim()\n        : array[fromKey].toString().trim();\n\n      if (hashMap[key]) {\n        hashMap[key].add(array[toKey]);\n      } else {\n        hashMap[key] = new Set();\n        hashMap[key].add(array[toKey]);\n      }\n    });\n  }\n  return hashMap;\n};\n\n/**\n * Format the arrays to hashMap with key as `fromKey` and value as Object\n * @param {*} arrays [{\"id\":\"a0b8efe1-c828-4c63-8850-0d0742888f9d\",\"name\":\"Email\",\"type\":\"email\",\"type_config\":{},\"date_created\":\"1662225840284\",\"hide_from_guests\":false,\"required\":false}]\n * @param {*} fromKey name\n * @param {*} isLowerCase false\n * @returns // {\"Email\":{\"id\":\"a0b8efe1-c828-4c63-8850-0d0742888f9d\",\"name\":\"Email\",\"type\":\"email\",\"type_config\":{},\"date_created\":\"1662225840284\",\"hide_from_guests\":false,\"required\":false}}\n */\nexport const getHashFromArrayWithValueAsObject = (\n  arrays: Array<DestinationMap>,\n  fromKey = 'from',\n  isLowerCase = true,\n) => {\n  const hashMap: Record<string, any> = {};\n  if (Array.isArray(arrays)) {\n    arrays.forEach((array) => {\n      if (isEmpty(array[fromKey])) return;\n      hashMap[isLowerCase ? array[fromKey].toLowerCase() : array[fromKey]] = array;\n    });\n  }\n  return hashMap;\n};\n\n/**\n * Retrieves a value from a message object based on a given key. It searches for the key in the properties, traits, and context.traits of the message object in that order.\n *\n * @param {Object} options - The options object.\n * @param {Object} options.message - The message object containing properties, traits, and context.traits.\n * @param {string} options.key - The key to search for in the message object.\n * @returns {*} The value found in the message object for the given key, or null if the key is not found or the value is null.\n */\nexport const getValueFromPropertiesOrTraits = ({ message, key }: { message: any; key: any }) => {\n  const keySet = ['properties', 'traits', 'context.traits'];\n\n  const val = _.find(\n    _.map(keySet, (k) => get(message, `${k}.${key}`)),\n    (v) => !_.isNil(v),\n  );\n  return !_.isNil(val) ? val : null;\n};\n\n/**\n * Flattens a JSON object into a single-level object.\n *\n * @param data - The JSON object to be flattened.\n * @param separator - The character used to separate the keys in the flattened object. Default is '.'.\n * @param mode - The mode used to flatten arrays. If set to 'strict', the array indices will be included in the flattened keys. Default is 'normal'.\n * @returns The flattened JSON object.\n */\nexport const flattenJson = (data: unknown, separator = '.', mode = 'normal') => {\n  const result: Record<any, any> = {};\n\n  // a recursive function to loop through the array of the data\n  const recurse = (cur: any, prop: any) => {\n    let i;\n    if (Object(cur) !== cur) {\n      result[prop] = cur;\n    } else if (Array.isArray(cur)) {\n      for (i = 0; i < cur.length; i += 1) {\n        if (mode === 'strict') {\n          recurse(cur[i], `${prop}${separator}${i}`);\n        } else {\n          recurse(cur[i], `${prop}[${i}]`);\n        }\n      }\n      if (cur.length === 0) {\n        result[prop] = [];\n      }\n    } else {\n      let isEmptyFlag = true;\n      Object.keys(cur).forEach((key) => {\n        isEmptyFlag = false;\n        recurse(cur[key], prop ? `${prop}${separator}${key}` : key);\n      });\n      if (isEmptyFlag && prop) result[prop] = {};\n    }\n  };\n\n  recurse(data, '');\n  return result;\n};\n\n/**\n * Get the offset value in seconds for a given timezone.\n *\n * @param value - The timezone value for which the offset needs to be calculated.\n * @returns The offset value in seconds for the given timezone. If the timezone is invalid or not found, it returns `undefined`.\n *\n * @example\n * const offset = getOffsetInSec('Asia/Calcutta');\n * console.log(offset); // Output: 19800\n */\nexport const getOffsetInSec = (value: string) => {\n  const name = moment.tz.zone(value);\n  if (name) {\n    const x = moment().tz(value).format('Z');\n    const split = x.split(':');\n    const hour = Number(split[0]);\n    const min = Number(split[1]);\n    let sec = 0;\n    sec = hour < 0 ? -1 * (hour * -60 * 60 + min * 60) : hour * 60 * 60 + min * 60;\n    return sec;\n  }\n  return undefined;\n};\n\n/**\n * Converts a date string into a formatted timestamp.\n * If a format string is provided, it uses the moment library to format the date.\n * If no format string is provided, it returns the timestamp of the date.\n * @param dateStr - The date string to be formatted.\n * @param format - (Optional) The format string to be used for formatting the date.\n * @returns The formatted date as a string if a format string is provided,\n *          otherwise the timestamp of the date as a number.\n */\nexport const formatTimeStamp = (dateStr: string, format?: string) => {\n  const date = new Date(dateStr);\n  // moment format is passed. format accordingly\n  if (format) {\n    return moment.utc(date).format(format);\n  }\n\n  // return default format\n  return date.getTime();\n};\n\nexport const hashToSha256 = (value: string | Buffer | number[]) => sha256(value);\n\n/**\n * Generates a Universally Unique Identifier (UUID) using the `crypto.randomUUID()` method.\n * The `disableEntropyCache` option is set to `true` to prevent caching of generated UUIDs.\n *\n * @returns {string} A randomly generated UUID.\n *\n * @see {@link https://nodejs.org/api/crypto.html#cryptorandomuuidoptions:~:text=options%20%3CObject%3E-,disableEntropyCache,-%3Cboolean%3E%20By}\n */\nexport const generateUUID = (): string => crypto.randomUUID({ disableEntropyCache: true });\n\nexport const convertToString = (value: any) => {\n  if (typeof value === 'string') {\n    return value;\n  }\n  return JSON.stringify(value);\n};\n\nconst uuid_namespace = 'e76c6e51-06f9-4222-9636-5aba7e3a84b6';\nexport const uuidv5 = (val: string) => v5(val, uuid_namespace);\n\nexport const generateRandomString = (length: number = 10) =>\n  crypto.randomBytes(length).toString('hex').slice(0, length);\n\n/**\n *\n * @param {Record<string, any | any[]} qParams - Object containing parameters where values are arrays\n * @returns {Record<string, any>} Flattened object where array values of length one are replaced with their first element\n * @description\n * Flattens an object by replacing array values of length one with their first element,\n * while keeping non-array values or arrays of length more than one unchanged.\n * In case of empty array, the key is removed from the output\n */\nexport const flattenQueryParams = (qParams: Record<string, any | any[]>): Record<string, any> => {\n  if (!qParams) return {}; // Early return for nullish values\n  const formattedOutput: Record<string, any> = {};\n\n  Object.entries(qParams).forEach(([key, value]) => {\n    const finalValue = Array.isArray(value) && value.length <= 1 ? value[0] : value;\n    if (finalValue !== undefined && finalValue !== null) {\n      formattedOutput[key] = finalValue;\n    }\n  });\n\n  return formattedOutput;\n};\n\n/**\n * Recursively freezes an object and all its properties.\n * This makes the object and its nested properties immutable.\n *\n * @template T - The type of the object to freeze\n * @param {T} obj - The object to freeze\n * @returns {Readonly<T>} - The frozen object\n *\n * @example\n * const config = deepFreeze({ api: { key: 'secret', timeout: 1000 } });\n * // Attempting to modify config.api.key will throw an error in strict mode\n */\nexport const deepFreeze = <T>(obj: T): Readonly<T> => {\n  // If the object is null, undefined, or not an object, return it as is\n  if (!obj || typeof obj !== 'object') return obj;\n\n  // Freeze all properties of the object\n  Object.getOwnPropertyNames(obj).forEach((key) => {\n    const value = (obj as any)[key];\n    if (value && typeof value === 'object' && !Object.isFrozen(value)) {\n      deepFreeze(value);\n    }\n  });\n\n  // Freeze the object itself and return it\n  return Object.freeze(obj);\n};\n"]}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rudderstack/integrations-lib",
-  "version": "0.2.31",
+  "version": "0.2.33",
   "description": "",
   "main": "build/index.js",
   "module": "build/index.js",