@rudderstack/integrations-lib 0.2.32 → 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/package.json

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