@rudderstack/integrations-lib 0.2.32 → 0.2.34

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

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=batch-processing.bench.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"batch-processing.bench.d.ts","sourceRoot":"","sources":["../../src/utils/batch-processing.bench.ts"],"names":[],"mappings":""}

package/build/utils/batch-processing.bench.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable no-console */
+const node_perf_hooks_1 = require("node:perf_hooks");
+const lodash_1 = __importDefault(require("lodash"));
+const batch_processing_1 = require("./batch-processing");
+async function bench(fn, label, iterations = 5) {
+    let total = 0;
+    for (let i = 0; i < iterations; i += 1) {
+        const start = node_perf_hooks_1.performance.now();
+        // eslint-disable-next-line no-await-in-loop
+        await fn();
+        total += node_perf_hooks_1.performance.now() - start;
+    }
+    const avg = total / iterations;
+    console.log(`${label}: avg ${avg.toFixed(2)} ms over ${iterations} runs`);
+    return avg;
+}
+async function section(title, fn) {
+    console.log(`\n=== ${title} ===`);
+    await fn();
+}
+async function runBenchmarks() {
+    const arr = Array.from({ length: 10_000 }, (_, i) => i);
+    console.log(`Running benchmarks on array of length ${arr.length}`);
+    await section('map', async () => {
+        await bench(() => (0, batch_processing_1.mapInBatches)(arr, (x) => x + 1, { batchSize: 20, yieldThreshold: 10 }), 'mapInBatches { batchSize: 20, yieldThreshold: 10 }');
+        await bench(() => (0, batch_processing_1.mapInBatches)(arr, (x) => x + 1, {
+            batchSize: 20,
+            yieldThreshold: 10,
+            sequentialProcessing: false,
+        }), 'mapInBatches { batchSize: 20, yieldThreshold: 10, sequentialProcessing: false }');
+        await bench(() => Promise.resolve(lodash_1.default.map(arr, (x) => x + 1)), 'lodash.map');
+        await bench(() => Promise.resolve(arr.map((x) => x + 1)), 'Array.prototype.map');
+    });
+    await section('filter', async () => {
+        await bench(() => (0, batch_processing_1.filterInBatches)(arr, (x) => x % 2 === 0, { batchSize: 20, yieldThreshold: 10 }), 'filterInBatches { batchSize: 20, yieldThreshold: 10 }');
+        await bench(() => (0, batch_processing_1.filterInBatches)(arr, (x) => x % 2 === 0, {
+            batchSize: 20,
+            yieldThreshold: 10,
+            sequentialProcessing: false,
+        }), 'filterInBatches { batchSize: 20, yieldThreshold: 10, sequentialProcessing: false }');
+        await bench(() => Promise.resolve(lodash_1.default.filter(arr, (x) => x % 2 === 0)), 'lodash.filter');
+        await bench(() => Promise.resolve(arr.filter((x) => x % 2 === 0)), 'Array.prototype.filter');
+    });
+    await section('groupBy', async () => {
+        await bench(() => (0, batch_processing_1.groupByInBatches)(arr, (x) => (x % 2 === 0 ? 'even' : 'odd'), {
+            batchSize: 20,
+            yieldThreshold: 10,
+        }), 'groupByInBatches { batchSize: 20, yieldThreshold: 10 }');
+        await bench(() => (0, batch_processing_1.groupByInBatches)(arr, (x) => (x % 2 === 0 ? 'even' : 'odd'), {
+            batchSize: 20,
+            yieldThreshold: 10,
+            sequentialProcessing: false,
+        }), 'groupByInBatches { batchSize: 20, yieldThreshold: 10, sequentialProcessing: false }');
+        await bench(() => Promise.resolve(lodash_1.default.groupBy(arr, (x) => (x % 2 === 0 ? 'even' : 'odd'))), 'lodash.groupBy');
+    });
+    await section('reduce', async () => {
+        await bench(() => (0, batch_processing_1.reduceInBatches)(arr, (acc, x) => acc + x, 0, { batchSize: 20, yieldThreshold: 10 }), 'reduceInBatches { batchSize: 20, yieldThreshold: 10 }');
+        await bench(() => Promise.resolve(lodash_1.default.reduce(arr, (acc, x) => acc + x, 0)), 'lodash.reduce');
+        await bench(() => Promise.resolve(arr.reduce((acc, x) => acc + x, 0)), 'Array.prototype.reduce');
+    });
+    await section('flatMap', async () => {
+        await bench(() => (0, batch_processing_1.flatMapInBatches)(arr, (x) => [x, x], { batchSize: 20, yieldThreshold: 10 }), 'flatMapInBatches { batchSize: 20, yieldThreshold: 10 }');
+        await bench(() => (0, batch_processing_1.flatMapInBatches)(arr, (x) => [x, x], {
+            batchSize: 20,
+            yieldThreshold: 10,
+            sequentialProcessing: false,
+        }), 'flatMapInBatches { batchSize: 20, yieldThreshold: 10, sequentialProcessing: false }');
+        await bench(() => Promise.resolve(lodash_1.default.flatMap(arr, (x) => [x, x])), 'lodash.flatMap');
+        await bench(() => Promise.resolve(arr.flatMap
+            ? arr.flatMap((x) => [x, x])
+            : [].concat(...arr.map((x) => [x, x]))), 'Array.prototype.flatMap');
+    });
+    await section('forEach', async () => {
+        await bench(() => (0, batch_processing_1.forEachInBatches)(arr, () => { }, { batchSize: 20, yieldThreshold: 10 }), 'forEachInBatches { batchSize: 20, yieldThreshold: 10 }');
+        await bench(() => (0, batch_processing_1.forEachInBatches)(arr, () => { }, {
+            batchSize: 20,
+            yieldThreshold: 10,
+            sequentialProcessing: false,
+        }), 'forEachInBatches { batchSize: 20, yieldThreshold: 10, sequentialProcessing: false }');
+        await bench(() => Promise.resolve(arr.forEach(() => { })), 'Array.prototype.forEach');
+        await bench(() => Promise.resolve(lodash_1.default.forEach(arr, () => { })), 'lodash.forEach');
+    });
+}
+// to run benchmarks use: npx ts-node src/utils/batch-processing.bench.ts
+if (require.main === module) {
+    runBenchmarks().catch((err) => {
+        console.error(err);
+        process.exit(1);
+    });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"batch-processing.bench.js","sourceRoot":"","sources":["../../src/utils/batch-processing.bench.ts"],"names":[],"mappings":"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","sourcesContent":["/* eslint-disable no-console */\nimport { performance } from 'node:perf_hooks';\nimport lodash from 'lodash';\nimport {\n  mapInBatches,\n  filterInBatches,\n  groupByInBatches,\n  reduceInBatches,\n  flatMapInBatches,\n  forEachInBatches,\n} from './batch-processing';\n\nasync function bench(\n  fn: () => Promise<unknown> | unknown,\n  label: string,\n  iterations = 5,\n): Promise<number> {\n  let total = 0;\n  for (let i = 0; i < iterations; i += 1) {\n    const start = performance.now();\n    // eslint-disable-next-line no-await-in-loop\n    await fn();\n    total += performance.now() - start;\n  }\n  const avg = total / iterations;\n  console.log(`${label}: avg ${avg.toFixed(2)} ms over ${iterations} runs`);\n  return avg;\n}\n\nasync function section(title: string, fn: () => Promise<void>) {\n  console.log(`\\n=== ${title} ===`);\n  await fn();\n}\n\nasync function runBenchmarks() {\n  const arr = Array.from({ length: 10_000 }, (_, i) => i);\n\n  console.log(`Running benchmarks on array of length ${arr.length}`);\n\n  await section('map', async () => {\n    await bench(\n      () => mapInBatches(arr, (x) => x + 1, { batchSize: 20, yieldThreshold: 10 }),\n      'mapInBatches { batchSize: 20, yieldThreshold: 10 }',\n    );\n    await bench(\n      () =>\n        mapInBatches(arr, (x) => x + 1, {\n          batchSize: 20,\n          yieldThreshold: 10,\n          sequentialProcessing: false,\n        }),\n      'mapInBatches { batchSize: 20, yieldThreshold: 10, sequentialProcessing: false }',\n    );\n    await bench(() => Promise.resolve(lodash.map(arr, (x) => x + 1)), 'lodash.map');\n    await bench(() => Promise.resolve(arr.map((x) => x + 1)), 'Array.prototype.map');\n  });\n\n  await section('filter', async () => {\n    await bench(\n      () => filterInBatches(arr, (x) => x % 2 === 0, { batchSize: 20, yieldThreshold: 10 }),\n      'filterInBatches { batchSize: 20, yieldThreshold: 10 }',\n    );\n    await bench(\n      () =>\n        filterInBatches(arr, (x) => x % 2 === 0, {\n          batchSize: 20,\n          yieldThreshold: 10,\n          sequentialProcessing: false,\n        }),\n      'filterInBatches { batchSize: 20, yieldThreshold: 10, sequentialProcessing: false }',\n    );\n    await bench(() => Promise.resolve(lodash.filter(arr, (x) => x % 2 === 0)), 'lodash.filter');\n    await bench(() => Promise.resolve(arr.filter((x) => x % 2 === 0)), 'Array.prototype.filter');\n  });\n\n  await section('groupBy', async () => {\n    await bench(\n      () =>\n        groupByInBatches(arr, (x) => (x % 2 === 0 ? 'even' : 'odd'), {\n          batchSize: 20,\n          yieldThreshold: 10,\n        }),\n      'groupByInBatches { batchSize: 20, yieldThreshold: 10 }',\n    );\n    await bench(\n      () =>\n        groupByInBatches(arr, (x) => (x % 2 === 0 ? 'even' : 'odd'), {\n          batchSize: 20,\n          yieldThreshold: 10,\n          sequentialProcessing: false,\n        }),\n      'groupByInBatches { batchSize: 20, yieldThreshold: 10, sequentialProcessing: false }',\n    );\n    await bench(\n      () => Promise.resolve(lodash.groupBy(arr, (x) => (x % 2 === 0 ? 'even' : 'odd'))),\n      'lodash.groupBy',\n    );\n  });\n\n  await section('reduce', async () => {\n    await bench(\n      () => reduceInBatches(arr, (acc, x) => acc + x, 0, { batchSize: 20, yieldThreshold: 10 }),\n      'reduceInBatches { batchSize: 20, yieldThreshold: 10 }',\n    );\n    await bench(() => Promise.resolve(lodash.reduce(arr, (acc, x) => acc + x, 0)), 'lodash.reduce');\n    await bench(\n      () => Promise.resolve(arr.reduce((acc, x) => acc + x, 0)),\n      'Array.prototype.reduce',\n    );\n  });\n\n  await section('flatMap', async () => {\n    await bench(\n      () => flatMapInBatches(arr, (x) => [x, x], { batchSize: 20, yieldThreshold: 10 }),\n      'flatMapInBatches { batchSize: 20, yieldThreshold: 10 }',\n    );\n    await bench(\n      () =>\n        flatMapInBatches(arr, (x) => [x, x], {\n          batchSize: 20,\n          yieldThreshold: 10,\n          sequentialProcessing: false,\n        }),\n      'flatMapInBatches { batchSize: 20, yieldThreshold: 10, sequentialProcessing: false }',\n    );\n    await bench(() => Promise.resolve(lodash.flatMap(arr, (x) => [x, x])), 'lodash.flatMap');\n    await bench(\n      () =>\n        Promise.resolve(\n          arr.flatMap\n            ? arr.flatMap((x) => [x, x])\n            : ([] as number[]).concat(...arr.map((x) => [x, x])),\n        ),\n      'Array.prototype.flatMap',\n    );\n  });\n\n  await section('forEach', async () => {\n    await bench(\n      () => forEachInBatches(arr, () => {}, { batchSize: 20, yieldThreshold: 10 }),\n      'forEachInBatches { batchSize: 20, yieldThreshold: 10 }',\n    );\n    await bench(\n      () =>\n        forEachInBatches(arr, () => {}, {\n          batchSize: 20,\n          yieldThreshold: 10,\n          sequentialProcessing: false,\n        }),\n      'forEachInBatches { batchSize: 20, yieldThreshold: 10, sequentialProcessing: false }',\n    );\n    await bench(() => Promise.resolve(arr.forEach(() => {})), 'Array.prototype.forEach');\n    await bench(() => Promise.resolve(lodash.forEach(arr, () => {})), 'lodash.forEach');\n  });\n}\n\n// to run benchmarks use: npx ts-node src/utils/batch-processing.bench.ts\nif (require.main === module) {\n  runBenchmarks().catch((err) => {\n    console.error(err);\n    process.exit(1);\n  });\n}\n"]}

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

@@ -0,0 +1,197 @@
+/**
+ * Options for batch processing operations
+ */
+export interface BatchProcessingOptions {
+    /**
+     * Number of items to process in each batch (default: 10)
+     * Must be a positive integer.
+     */
+    batchSize?: number;
+    /**
+     * Time threshold in milliseconds (default: 10) before yielding control back to the event loop.
+     * Set to 0 to yield after every batch. Must be a non-negative integer.
+     */
+    yieldThreshold?: number;
+    /**
+     * Whether to process items sequentially within each batch. When true (default), each item in a batch
+     * will be processed one at a time. When false, all items in a batch will be processed concurrently.
+     * Consider the implications of concurrency on your processing logic before setting this to false, e.g. race conditions, rate limits, memory pressure, etc.
+     */
+    sequentialProcessing?: boolean;
+}
+/**
+ * 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 });
+ *
+ * // Enable concurrent processing within batches
+ * configureBatchProcessingDefaults({ sequentialProcessing: false });
+ *
+ * // Get current configuration
+ * const currentConfig = configureBatchProcessingDefaults();
+ * ```
+ */
+export declare function configureBatchProcessingDefaults(config?: BatchProcessingOptions): BatchProcessingOptions;
+/**
+ * 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 options - Batch processing options
+ * @returns A promise that resolves to the mapped array
+ * @throws {Error} When batchSize is not a positive integer
+ *
+ * @example
+ * ```typescript
+ * // Synchronous mapping with default options (sequential processing)
+ * const doubled = await mapInBatches([1, 2, 3, 4], (x) => x * 2);
+ *
+ * // With concurrent processing within batches
+ * const doubled = await mapInBatches([1, 2, 3, 4], (x) => x * 2, { sequentialProcessing: false });
+ * ```
+ */
+export declare function mapInBatches<T, R>(items: T[], mapFn: (item: T, index: number) => R | Promise<R>, options?: BatchProcessingOptions): 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 options - Batch processing options
+ * @returns A promise that resolves to the filtered array
+ * @throws {Error} When batchSize is not a positive integer
+ *
+ * @example
+ * ```typescript
+ * // Synchronous filtering with default options
+ * const evens = await filterInBatches([1, 2, 3, 4, 5], (x) => x % 2 === 0);
+ * // Result: [2, 4]
+ *
+ * // With custom batch size
+ * const evens = await filterInBatches([1, 2, 3, 4, 5], (x) => x % 2 === 0, { batchSize: 2 });
+ * ```
+ */
+export declare function filterInBatches<T>(items: T[], predicate: (item: T, index: number) => boolean | Promise<boolean>, options?: BatchProcessingOptions): 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 options - Batch processing options
+ * @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 with default options
+ * const byType = await groupByInBatches(
+ *   [{type: 'A', value: 1}, {type: 'B', value: 2}, {type: 'A', value: 3}],
+ *   (item) => item.type
+ * );
+ * // Result: {A: [{type: 'A', value: 1}, {type: 'A', value: 3}], B: [{type: 'B', value: 2}]}
+ *
+ * // With custom batch size
+ * const byType = await groupByInBatches(
+ *   [{type: 'A', value: 1}, {type: 'B', value: 2}, {type: 'A', value: 3}],
+ *   (item) => item.type,
+ *   { batchSize: 2 }
+ * );
+ * ```
+ */
+export declare function groupByInBatches<T, K extends PropertyKey>(items: T[], keyFn: (item: T, index: number) => K | Promise<K>, options?: BatchProcessingOptions): 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. Sequential processing is always used for the reducer function,
+ * irrespective of the `sequentialProcessing` option.
+ *
+ * @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 options - Batch processing options
+ * @returns A promise that resolves to the reduced value
+ * @throws {Error} When batchSize is not a positive integer
+ *
+ * @example
+ * ```typescript
+ * // Sum numbers with default options
+ * const sum = await reduceInBatches([1, 2, 3, 4], (acc, x) => acc + x, 0);
+ * // Result: 10
+ *
+ * // With custom batch size
+ * const sum = await reduceInBatches([1, 2, 3, 4], (acc, x) => acc + x, 0, { batchSize: 2 });
+ * ```
+ */
+export declare function reduceInBatches<T, R>(items: T[], reducer: (acc: R, item: T, index: number) => R | Promise<R>, initialValue: R, options?: BatchProcessingOptions): 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 options - Batch processing options
+ * @returns A promise that resolves to the flattened mapped array
+ * @throws {Error} When batchSize is not a positive integer
+ *
+ * @example
+ * ```typescript
+ * // Duplicate each item with default options
+ * const duplicated = await flatMapInBatches([1, 2, 3], (x) => [x, x]);
+ * // Result: [1, 1, 2, 2, 3, 3]
+ *
+ * // With custom batch size
+ * const duplicated = await flatMapInBatches([1, 2, 3], (x) => [x, x], { batchSize: 2 });
+ * ```
+ */
+export declare function flatMapInBatches<T, R>(items: T[], mapFn: (item: T, index: number) => R[] | Promise<R[]>, options?: BatchProcessingOptions): Promise<R[]>;
+/**
+ * forEach 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
+ * @param items - The array to iterate over
+ * @param fn - The function to apply to each item. Receives the item and its index. Can be async.
+ * @param options - Batch processing options
+ * @returns A promise that resolves when all items have been processed
+ * @throws {Error} When batchSize is not a positive integer
+ *
+ * @example
+ * ```typescript
+ * // Process items in batches with default options
+ * await forEachInBatches([1, 2, 3, 4], async (x) => {
+ *   await doSomething(x);
+ * });
+ *
+ * // With custom batch size
+ * await forEachInBatches([1, 2, 3, 4], async (x) => {
+ *   await doSomething(x);
+ * }, { batchSize: 2 });
+ * ```
+ */
+export declare function forEachInBatches<T>(items: T[], fn: (item: T, index: number) => void | Promise<void>, options?: BatchProcessingOptions): Promise<void>;
+//# 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,sBAAsB;IACrC;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB;;;;OAIG;IACH,oBAAoB,CAAC,EAAE,OAAO,CAAC;CAChC;AAOD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,gCAAgC,CAC9C,MAAM,CAAC,EAAE,sBAAsB,GAC9B,sBAAsB,CA0BxB;AAoFD;;;;;;;;;;;;;;;;;;;;;GAqBG;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,OAAO,CAAC,EAAE,sBAAsB,GAC/B,OAAO,CAAC,CAAC,EAAE,CAAC,CAqBd;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;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,OAAO,CAAC,EAAE,sBAAsB,GAC/B,OAAO,CAAC,CAAC,EAAE,CAAC,CAuBd;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;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,OAAO,CAAC,EAAE,sBAAsB,GAC/B,OAAO,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,CA0BzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;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,OAAO,CAAC,EAAE,sBAAsB,GAC/B,OAAO,CAAC,CAAC,CAAC,CAcZ;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;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,OAAO,CAAC,EAAE,sBAAsB,GAC/B,OAAO,CAAC,CAAC,EAAE,CAAC,CAuBd;AAED;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,gBAAgB,CAAC,CAAC,EAChC,KAAK,EAAE,CAAC,EAAE,EACV,EAAE,EAAE,CAAC,IAAI,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,EACpD,OAAO,CAAC,EAAE,sBAAsB,GAC/B,OAAO,CAAC,IAAI,CAAC,CAef"}

package/build/utils/batch-processing.js

@@ -0,0 +1,409 @@
+"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;
+exports.forEachInBatches = forEachInBatches;
+// Default configuration values (internal)
+let defaultBatchSize = 10;
+let defaultYieldThreshold = 10;
+let defaultSequentialProcessing = true;
+/**
+ * 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 });
+ *
+ * // Enable concurrent processing within batches
+ * configureBatchProcessingDefaults({ sequentialProcessing: false });
+ *
+ * // 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;
+        }
+        if (config.sequentialProcessing !== undefined) {
+            defaultSequentialProcessing = Boolean(config.sequentialProcessing);
+        }
+    }
+    return {
+        batchSize: defaultBatchSize,
+        yieldThreshold: defaultYieldThreshold,
+        sequentialProcessing: defaultSequentialProcessing,
+    };
+}
+/**
+ * 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);
+}
+/**
+ * Helper to get batch processing options with defaults applied
+ * @param options - User provided options
+ * @returns Options with defaults applied
+ * @internal
+ */
+function getOptions(options) {
+    const batchSize = options?.batchSize ?? defaultBatchSize;
+    const yieldThreshold = options?.yieldThreshold ?? defaultYieldThreshold;
+    const sequentialProcessing = options?.sequentialProcessing ?? defaultSequentialProcessing;
+    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');
+    }
+    return {
+        batchSize,
+        yieldThreshold,
+        sequentialProcessing,
+    };
+}
+/**
+ * Helper to process an array in batches, yielding as needed.
+ * @param items - The array to process
+ * @param options - Batch processing options
+ * @param batchHandler - Function to handle each batch: (batch, batchStartIndex) => Promise<any>
+ * @returns Promise<void>
+ */
+async function processInBatches(items, options, batchHandler) {
+    let i = 0;
+    let startTime = Date.now();
+    const { batchSize } = options;
+    const n = items.length;
+    // Allocate a single batch array and reuses it for all batches
+    const batch = Array(batchSize);
+    while (i < n) {
+        const len = Math.min(batchSize, n - i);
+        for (let j = 0; j < len; j += 1) {
+            batch[j] = items[i + j];
+        }
+        batch.length = len;
+        // eslint-disable-next-line no-await-in-loop
+        await batchHandler(batch, i);
+        i += batchSize;
+        // eslint-disable-next-line no-await-in-loop
+        const didYield = await defer(startTime, options.yieldThreshold);
+        if (didYield)
+            startTime = Date.now();
+    }
+}
+/**
+ * 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 options - Batch processing options
+ * @returns A promise that resolves to the mapped array
+ * @throws {Error} When batchSize is not a positive integer
+ *
+ * @example
+ * ```typescript
+ * // Synchronous mapping with default options (sequential processing)
+ * const doubled = await mapInBatches([1, 2, 3, 4], (x) => x * 2);
+ *
+ * // With concurrent processing within batches
+ * const doubled = await mapInBatches([1, 2, 3, 4], (x) => x * 2, { sequentialProcessing: false });
+ * ```
+ */
+function mapInBatches(items, mapFn, options) {
+    const opts = getOptions(options);
+    return (async () => {
+        const result = [];
+        await processInBatches(items, opts, async (batch, batchStart) => {
+            if (opts.sequentialProcessing) {
+                // Process items sequentially
+                for (let j = 0; j < batch.length; j += 1) {
+                    // eslint-disable-next-line no-await-in-loop -- sequential processing is required
+                    const mapped = await mapFn(batch[j], batchStart + j);
+                    result.push(mapped);
+                }
+            }
+            else {
+                // Process items concurrently
+                const mapped = await Promise.all(batch.map((item, j) => mapFn(item, batchStart + j)));
+                result.push(...mapped);
+            }
+        });
+        return result;
+    })();
+}
+/**
+ * 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 options - Batch processing options
+ * @returns A promise that resolves to the filtered array
+ * @throws {Error} When batchSize is not a positive integer
+ *
+ * @example
+ * ```typescript
+ * // Synchronous filtering with default options
+ * const evens = await filterInBatches([1, 2, 3, 4, 5], (x) => x % 2 === 0);
+ * // Result: [2, 4]
+ *
+ * // With custom batch size
+ * const evens = await filterInBatches([1, 2, 3, 4, 5], (x) => x % 2 === 0, { batchSize: 2 });
+ * ```
+ */
+function filterInBatches(items, predicate, options) {
+    const opts = getOptions(options);
+    return (async () => {
+        const result = [];
+        await processInBatches(items, opts, async (batch, batchStart) => {
+            if (opts.sequentialProcessing) {
+                // Process items sequentially
+                for (let j = 0; j < batch.length; j += 1) {
+                    // eslint-disable-next-line no-await-in-loop -- sequential processing is required
+                    const passes = await predicate(batch[j], batchStart + j);
+                    if (passes)
+                        result.push(batch[j]);
+                }
+            }
+            else {
+                // Process items concurrently
+                const flags = await Promise.all(batch.map((item, j) => predicate(item, batchStart + j)));
+                for (let j = 0; j < batch.length; j += 1) {
+                    if (flags[j])
+                        result.push(batch[j]);
+                }
+            }
+        });
+        return result;
+    })();
+}
+/**
+ * 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 options - Batch processing options
+ * @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 with default options
+ * const byType = await groupByInBatches(
+ *   [{type: 'A', value: 1}, {type: 'B', value: 2}, {type: 'A', value: 3}],
+ *   (item) => item.type
+ * );
+ * // Result: {A: [{type: 'A', value: 1}, {type: 'A', value: 3}], B: [{type: 'B', value: 2}]}
+ *
+ * // With custom batch size
+ * const byType = await groupByInBatches(
+ *   [{type: 'A', value: 1}, {type: 'B', value: 2}, {type: 'A', value: 3}],
+ *   (item) => item.type,
+ *   { batchSize: 2 }
+ * );
+ * ```
+ */
+function groupByInBatches(items, keyFn, options) {
+    const opts = getOptions(options);
+    return (async () => {
+        const result = {};
+        await processInBatches(items, opts, async (batch, batchStart) => {
+            if (opts.sequentialProcessing) {
+                // Process items sequentially
+                for (let j = 0; j < batch.length; j += 1) {
+                    // eslint-disable-next-line no-await-in-loop -- sequential processing is required
+                    const key = await keyFn(batch[j], batchStart + j);
+                    if (!result[key])
+                        result[key] = [];
+                    result[key].push(batch[j]);
+                }
+            }
+            else {
+                // Process items concurrently
+                const keys = await Promise.all(batch.map((item, j) => keyFn(item, batchStart + j)));
+                for (let j = 0; j < batch.length; j += 1) {
+                    const key = keys[j];
+                    if (!result[key])
+                        result[key] = [];
+                    result[key].push(batch[j]);
+                }
+            }
+        });
+        return result;
+    })();
+}
+/**
+ * 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. Sequential processing is always used for the reducer function,
+ * irrespective of the `sequentialProcessing` option.
+ *
+ * @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 options - Batch processing options
+ * @returns A promise that resolves to the reduced value
+ * @throws {Error} When batchSize is not a positive integer
+ *
+ * @example
+ * ```typescript
+ * // Sum numbers with default options
+ * const sum = await reduceInBatches([1, 2, 3, 4], (acc, x) => acc + x, 0);
+ * // Result: 10
+ *
+ * // With custom batch size
+ * const sum = await reduceInBatches([1, 2, 3, 4], (acc, x) => acc + x, 0, { batchSize: 2 });
+ * ```
+ */
+function reduceInBatches(items, reducer, initialValue, options) {
+    const opts = getOptions(options);
+    return (async () => {
+        let acc = initialValue;
+        await processInBatches(items, opts, async (batch, batchStart) => {
+            // Always sequential, regardless of sequentialProcessing option
+            for (let j = 0; j < batch.length; j += 1) {
+                // eslint-disable-next-line no-await-in-loop -- sequential processing is required
+                acc = await reducer(acc, batch[j], batchStart + j);
+            }
+        });
+        return acc;
+    })();
+}
+/**
+ * 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 options - Batch processing options
+ * @returns A promise that resolves to the flattened mapped array
+ * @throws {Error} When batchSize is not a positive integer
+ *
+ * @example
+ * ```typescript
+ * // Duplicate each item with default options
+ * const duplicated = await flatMapInBatches([1, 2, 3], (x) => [x, x]);
+ * // Result: [1, 1, 2, 2, 3, 3]
+ *
+ * // With custom batch size
+ * const duplicated = await flatMapInBatches([1, 2, 3], (x) => [x, x], { batchSize: 2 });
+ * ```
+ */
+function flatMapInBatches(items, mapFn, options) {
+    const opts = getOptions(options);
+    return (async () => {
+        const result = [];
+        await processInBatches(items, opts, async (batch, batchStart) => {
+            if (opts.sequentialProcessing) {
+                // Process items sequentially
+                for (let j = 0; j < batch.length; j += 1) {
+                    // eslint-disable-next-line no-await-in-loop -- sequential processing is required
+                    const mapped = await mapFn(batch[j], batchStart + j);
+                    result.push(...mapped);
+                }
+            }
+            else {
+                // Process items concurrently
+                const mapped = await Promise.all(batch.map((item, j) => mapFn(item, batchStart + j)));
+                mapped.forEach((arr) => {
+                    result.push(...arr);
+                });
+            }
+        });
+        return result;
+    })();
+}
+/**
+ * forEach 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
+ * @param items - The array to iterate over
+ * @param fn - The function to apply to each item. Receives the item and its index. Can be async.
+ * @param options - Batch processing options
+ * @returns A promise that resolves when all items have been processed
+ * @throws {Error} When batchSize is not a positive integer
+ *
+ * @example
+ * ```typescript
+ * // Process items in batches with default options
+ * await forEachInBatches([1, 2, 3, 4], async (x) => {
+ *   await doSomething(x);
+ * });
+ *
+ * // With custom batch size
+ * await forEachInBatches([1, 2, 3, 4], async (x) => {
+ *   await doSomething(x);
+ * }, { batchSize: 2 });
+ * ```
+ */
+function forEachInBatches(items, fn, options) {
+    const opts = getOptions(options);
+    return processInBatches(items, opts, async (batch, batchStart) => {
+        if (opts.sequentialProcessing) {
+            // Process items sequentially
+            for (let j = 0; j < batch.length; j += 1) {
+                // eslint-disable-next-line no-await-in-loop -- sequential processing is required
+                await fn(batch[j], batchStart + j);
+            }
+        }
+        else {
+            // Process items concurrently
+            await Promise.all(batch.map((item, j) => fn(item, batchStart + j)));
+        }
+    });
+}
+//# 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 * Options for batch processing operations\n */\nexport interface BatchProcessingOptions {\n  /**\n   * Number of items to process in each batch (default: 10)\n   * Must be a positive integer.\n   */\n  batchSize?: number;\n\n  /**\n   * Time threshold in milliseconds (default: 10) before yielding control back to the event loop.\n   * Set to 0 to yield after every batch. Must be a non-negative integer.\n   */\n  yieldThreshold?: number;\n\n  /**\n   * Whether to process items sequentially within each batch. When true (default), each item in a batch\n   * will be processed one at a time. When false, all items in a batch will be processed concurrently.\n   * Consider the implications of concurrency on your processing logic before setting this to false, e.g. race conditions, rate limits, memory pressure, etc.\n   */\n  sequentialProcessing?: boolean;\n}\n\n// Default configuration values (internal)\nlet defaultBatchSize = 10;\nlet defaultYieldThreshold = 10;\nlet defaultSequentialProcessing = true;\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 * // Enable concurrent processing within batches\n * configureBatchProcessingDefaults({ sequentialProcessing: false });\n *\n * // Get current configuration\n * const currentConfig = configureBatchProcessingDefaults();\n * ```\n */\nexport function configureBatchProcessingDefaults(\n  config?: BatchProcessingOptions,\n): BatchProcessingOptions {\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    if (config.sequentialProcessing !== undefined) {\n      defaultSequentialProcessing = Boolean(config.sequentialProcessing);\n    }\n  }\n\n  return {\n    batchSize: defaultBatchSize,\n    yieldThreshold: defaultYieldThreshold,\n    sequentialProcessing: defaultSequentialProcessing,\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 * Helper to get batch processing options with defaults applied\n * @param options - User provided options\n * @returns Options with defaults applied\n * @internal\n */\nfunction getOptions(options?: BatchProcessingOptions): Required<BatchProcessingOptions> {\n  const batchSize = options?.batchSize ?? defaultBatchSize;\n  const yieldThreshold = options?.yieldThreshold ?? defaultYieldThreshold;\n  const sequentialProcessing = options?.sequentialProcessing ?? defaultSequentialProcessing;\n\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\n  return {\n    batchSize,\n    yieldThreshold,\n    sequentialProcessing,\n  };\n}\n\n/**\n * Helper to process an array in batches, yielding as needed.\n * @param items - The array to process\n * @param options - Batch processing options\n * @param batchHandler - Function to handle each batch: (batch, batchStartIndex) => Promise<any>\n * @returns Promise<void>\n */\nasync function processInBatches<T>(\n  items: T[],\n  options: Required<BatchProcessingOptions>,\n  batchHandler: (batch: T[], batchStart: number) => Promise<void>,\n): Promise<void> {\n  let i = 0;\n  let startTime = Date.now();\n  const { batchSize } = options;\n  const n = items.length;\n  // Allocate a single batch array and reuses it for all batches\n  const batch: T[] = Array(batchSize);\n  while (i < n) {\n    const len = Math.min(batchSize, n - i);\n    for (let j = 0; j < len; j += 1) {\n      batch[j] = items[i + j];\n    }\n    batch.length = len;\n    // eslint-disable-next-line no-await-in-loop\n    await batchHandler(batch, i);\n    i += batchSize;\n    // eslint-disable-next-line no-await-in-loop\n    const didYield = await defer(startTime, options.yieldThreshold);\n    if (didYield) startTime = Date.now();\n  }\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 options - Batch processing options\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 with default options (sequential processing)\n * const doubled = await mapInBatches([1, 2, 3, 4], (x) => x * 2);\n *\n * // With concurrent processing within batches\n * const doubled = await mapInBatches([1, 2, 3, 4], (x) => x * 2, { sequentialProcessing: false });\n * ```\n */\nexport function mapInBatches<T, R>(\n  items: T[],\n  mapFn: (item: T, index: number) => R | Promise<R>,\n  options?: BatchProcessingOptions,\n): Promise<R[]> {\n  const opts = getOptions(options);\n\n  return (async () => {\n    const result: R[] = [];\n    await processInBatches(items, opts, async (batch, batchStart) => {\n      if (opts.sequentialProcessing) {\n        // Process items sequentially\n        for (let j = 0; j < batch.length; j += 1) {\n          // eslint-disable-next-line no-await-in-loop -- sequential processing is required\n          const mapped = await mapFn(batch[j], batchStart + j);\n          result.push(mapped);\n        }\n      } else {\n        // Process items concurrently\n        const mapped = await Promise.all(batch.map((item, j) => mapFn(item, batchStart + j)));\n        result.push(...mapped);\n      }\n    });\n    return result;\n  })();\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 options - Batch processing options\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 with default options\n * const evens = await filterInBatches([1, 2, 3, 4, 5], (x) => x % 2 === 0);\n * // Result: [2, 4]\n *\n * // With custom batch size\n * const evens = await filterInBatches([1, 2, 3, 4, 5], (x) => x % 2 === 0, { batchSize: 2 });\n * ```\n */\nexport function filterInBatches<T>(\n  items: T[],\n  predicate: (item: T, index: number) => boolean | Promise<boolean>,\n  options?: BatchProcessingOptions,\n): Promise<T[]> {\n  const opts = getOptions(options);\n\n  return (async () => {\n    const result: T[] = [];\n    await processInBatches(items, opts, async (batch, batchStart) => {\n      if (opts.sequentialProcessing) {\n        // Process items sequentially\n        for (let j = 0; j < batch.length; j += 1) {\n          // eslint-disable-next-line no-await-in-loop -- sequential processing is required\n          const passes = await predicate(batch[j], batchStart + j);\n          if (passes) result.push(batch[j]);\n        }\n      } else {\n        // Process items concurrently\n        const flags = await Promise.all(batch.map((item, j) => predicate(item, batchStart + j)));\n        for (let j = 0; j < batch.length; j += 1) {\n          if (flags[j]) result.push(batch[j]);\n        }\n      }\n    });\n    return result;\n  })();\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 options - Batch processing options\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 with default options\n * const byType = await groupByInBatches(\n *   [{type: 'A', value: 1}, {type: 'B', value: 2}, {type: 'A', value: 3}],\n *   (item) => item.type\n * );\n * // Result: {A: [{type: 'A', value: 1}, {type: 'A', value: 3}], B: [{type: 'B', value: 2}]}\n *\n * // With custom batch size\n * const byType = await groupByInBatches(\n *   [{type: 'A', value: 1}, {type: 'B', value: 2}, {type: 'A', value: 3}],\n *   (item) => item.type,\n *   { batchSize: 2 }\n * );\n * ```\n */\nexport function groupByInBatches<T, K extends PropertyKey>(\n  items: T[],\n  keyFn: (item: T, index: number) => K | Promise<K>,\n  options?: BatchProcessingOptions,\n): Promise<Record<K, T[]>> {\n  const opts = getOptions(options);\n\n  return (async () => {\n    const result: Record<K, T[]> = {} as Record<K, T[]>;\n    await processInBatches(items, opts, async (batch, batchStart) => {\n      if (opts.sequentialProcessing) {\n        // Process items sequentially\n        for (let j = 0; j < batch.length; j += 1) {\n          // eslint-disable-next-line no-await-in-loop -- sequential processing is required\n          const key = await keyFn(batch[j], batchStart + j);\n          if (!result[key]) result[key] = [];\n          result[key].push(batch[j]);\n        }\n      } else {\n        // Process items concurrently\n        const keys = await Promise.all(batch.map((item, j) => keyFn(item, batchStart + j)));\n        for (let j = 0; j < batch.length; j += 1) {\n          const key = keys[j];\n          if (!result[key]) result[key] = [];\n          result[key].push(batch[j]);\n        }\n      }\n    });\n    return result;\n  })();\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. Sequential processing is always used for the reducer function,\n * irrespective of the `sequentialProcessing` option.\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 options - Batch processing options\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 with default options\n * const sum = await reduceInBatches([1, 2, 3, 4], (acc, x) => acc + x, 0);\n * // Result: 10\n *\n * // With custom batch size\n * const sum = await reduceInBatches([1, 2, 3, 4], (acc, x) => acc + x, 0, { batchSize: 2 });\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  options?: BatchProcessingOptions,\n): Promise<R> {\n  const opts = getOptions(options);\n\n  return (async () => {\n    let acc = initialValue;\n    await processInBatches(items, opts, async (batch, batchStart) => {\n      // Always sequential, regardless of sequentialProcessing option\n      for (let j = 0; j < batch.length; j += 1) {\n        // eslint-disable-next-line no-await-in-loop -- sequential processing is required\n        acc = await reducer(acc, batch[j], batchStart + j);\n      }\n    });\n    return acc;\n  })();\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 options - Batch processing options\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 with default options\n * const duplicated = await flatMapInBatches([1, 2, 3], (x) => [x, x]);\n * // Result: [1, 1, 2, 2, 3, 3]\n *\n * // With custom batch size\n * const duplicated = await flatMapInBatches([1, 2, 3], (x) => [x, x], { batchSize: 2 });\n * ```\n */\nexport function flatMapInBatches<T, R>(\n  items: T[],\n  mapFn: (item: T, index: number) => R[] | Promise<R[]>,\n  options?: BatchProcessingOptions,\n): Promise<R[]> {\n  const opts = getOptions(options);\n\n  return (async () => {\n    const result: R[] = [];\n    await processInBatches(items, opts, async (batch, batchStart) => {\n      if (opts.sequentialProcessing) {\n        // Process items sequentially\n        for (let j = 0; j < batch.length; j += 1) {\n          // eslint-disable-next-line no-await-in-loop -- sequential processing is required\n          const mapped = await mapFn(batch[j], batchStart + j);\n          result.push(...mapped);\n        }\n      } else {\n        // Process items concurrently\n        const mapped = await Promise.all(batch.map((item, j) => mapFn(item, batchStart + j)));\n        mapped.forEach((arr) => {\n          result.push(...arr);\n        });\n      }\n    });\n    return result;\n  })();\n}\n\n/**\n * forEach 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 * @param items - The array to iterate over\n * @param fn - The function to apply to each item. Receives the item and its index. Can be async.\n * @param options - Batch processing options\n * @returns A promise that resolves when all items have been processed\n * @throws {Error} When batchSize is not a positive integer\n *\n * @example\n * ```typescript\n * // Process items in batches with default options\n * await forEachInBatches([1, 2, 3, 4], async (x) => {\n *   await doSomething(x);\n * });\n *\n * // With custom batch size\n * await forEachInBatches([1, 2, 3, 4], async (x) => {\n *   await doSomething(x);\n * }, { batchSize: 2 });\n * ```\n */\nexport function forEachInBatches<T>(\n  items: T[],\n  fn: (item: T, index: number) => void | Promise<void>,\n  options?: BatchProcessingOptions,\n): Promise<void> {\n  const opts = getOptions(options);\n\n  return processInBatches(items, opts, async (batch, batchStart) => {\n    if (opts.sequentialProcessing) {\n      // Process items sequentially\n      for (let j = 0; j < batch.length; j += 1) {\n        // eslint-disable-next-line no-await-in-loop -- sequential processing is required\n        await fn(batch[j], batchStart + j);\n      }\n    } else {\n      // Process items concurrently\n      await Promise.all(batch.map((item, j) => fn(item, batchStart + j)));\n    }\n  });\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.34",
   "description": "",
   "main": "build/index.js",
   "module": "build/index.js",