sqs-partial-batch-processor 0.1.11 → 0.2.0

package/README.md

@@ -17,9 +17,10 @@ This library intentionally does **not** parse message bodies, validate schemas,
 
 ## Requirements
 
-- Node.js **20+**
+- Node.js **20+** (runtime requirement)
+- Module system: published as **CommonJS** (`"module": "CommonJS"`). Usable from both CJS and ESM runtimes.
 - Lambda SQS event source mapping has **Report batch item failures** enabled.
-  See the AWS docs: https://docs.aws.amazon.com/lambda/latest/dg/services-sqs-errorhandling.html#services-sqs-batchfailurereporting
+  See: [AWS Lambda SQS error handling docs](https://docs.aws.amazon.com/lambda/latest/dg/services-sqs-errorhandling.html#services-sqs-batchfailurereporting)
 
 ## Installation
 
@@ -63,9 +64,38 @@ export const handler = async (event: SQSEvent) =>
 
 Both `processPartialBatch` and `processPartialBatchWithResult` accept an optional `options` object:
 
-- `concurrency?: number` (default: `1`): bounded parallelism. Order of `batchItemFailures` is not guaranteed.
-- `onRecordError?: (record, error) => void`: called when a record is treated as failed (useful for logging/metrics).
+- `concurrency?: number` (default: `1`): maximum parallelism. Must be a finite integer `>= 1` (`1` = sequential, `> 1` = bounded concurrency). If invalid, the function throws (`RangeError` for `< 1`, `TypeError` for non-integer / non-finite).
+  - **Tip**: start with `1` and increase gradually while watching downstream limits (external API rate limits, DB connection pools, and Lambda reserved concurrency). SQS batches are typically small, so a large value rarely helps.
+  - **Note**: when `concurrency > 1`, the order of `batchItemFailures` is **not guaranteed**. Tests should compare as a set, not by array order.
+- `onRecordError?: (record, error) => void`: called when a record is treated as failed (useful for structured logs / metrics).
+  - Example (structured log / metrics hook):
+
+```ts
+import { processPartialBatch } from 'sqs-partial-batch-processor';
+import type { SQSEvent } from 'aws-lambda';
+
+export const handler = async (event: SQSEvent) =>
+  processPartialBatch(
+    event,
+    async (record) => {
+      // ...
+    },
+    {
+      onRecordError: (record, error) => {
+        console.log(JSON.stringify({
+          level: 'error',
+          msg: 'record failed',
+          messageId: record.messageId,
+          // Avoid logging sensitive contents from record.body.
+          error: error instanceof Error ? { name: error.name, message: error.message } : { message: String(error) },
+        }));
+      },
+    },
+  );
+```
+
 - `mapMessageId?: (record) => string`: customize the `itemIdentifier` (defaults to `record.messageId`).
+  - Typical uses: align the identifier with an **application-level id** (e.g., an id stored in `messageAttributes` or the parsed payload), or normalize identifiers across FIFO/standard queues for easier correlation.
 
 ## License
 

package/lib/index.d.ts

@@ -4,7 +4,13 @@ import type { SQSBatchResponse, SQSEvent, SQSRecord } from 'aws-lambda';
  */
 export interface ProcessPartialBatchOptions {
     /**
-     * When greater than 1, records are processed with a bounded concurrency pool.
+     * Maximum number of records processed in parallel.
+     *
+     * - `1`: sequential processing
+     * - `> 1`: bounded concurrency pool (order of `batchItemFailures` is not guaranteed)
+     *
+     * @throws {RangeError} When `concurrency` is less than 1.
+     * @throws {TypeError} When `concurrency` is not a finite integer.
      * Order of entries in {@link SQSBatchResponse.batchItemFailures} is not guaranteed.
      * @default 1
      */

package/lib/index.js

@@ -1,18 +1,46 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.processPartialBatchWithResult = exports.processPartialBatch = void 0;
+/**
+ * Creates a single `batchItemFailures` entry for a failed record.
+ * @param itemIdentifier The identifier reported back to Lambda.
+ */
 const itemFailure = (itemIdentifier) => ({
     itemIdentifier,
 });
+/**
+ * Resolves and validates the `concurrency` option.
+ *
+ * @param value User-provided concurrency.
+ * @returns A validated concurrency value (defaults to `1`).
+ * @throws {RangeError} When `value` is less than 1.
+ * @throws {TypeError} When `value` is not a finite integer.
+ */
+const resolveConcurrency = (value) => {
+    if (value === undefined) {
+        return 1;
+    }
+    if (!Number.isFinite(value) || !Number.isInteger(value)) {
+        throw new TypeError('concurrency must be a finite integer');
+    }
+    if (value < 1) {
+        throw new RangeError('concurrency must be >= 1');
+    }
+    return value;
+};
 /**
  * Runs `fn` over `items` with at most `concurrency` parallel workers.
  * Each worker pulls the next index until none remain.
+ *
+ * @param items Items to process.
+ * @param concurrency Maximum parallel workers (must be `>= 1`).
+ * @param fn Async handler invoked for each item.
  */
 const runWithConcurrency = async (items, concurrency, fn) => {
     if (items.length === 0) {
         return;
     }
-    const limit = Math.min(Math.max(1, concurrency), items.length);
+    const limit = Math.min(concurrency, items.length);
     let next = 0;
     const takeNextIndex = () => {
         const index = next;
@@ -43,7 +71,7 @@ const runWithConcurrency = async (items, concurrency, fn) => {
  * `batchItemFailures`; successful records are not listed.
  */
 const processPartialBatch = async (event, processRecord, options) => {
-    const concurrency = options?.concurrency ?? 1;
+    const concurrency = resolveConcurrency(options?.concurrency);
     const batchItemFailures = [];
     const handle = async (record) => {
         const id = options?.mapMessageId?.(record) ?? record.messageId;
@@ -73,7 +101,7 @@ exports.processPartialBatch = processPartialBatch;
  * If `processRecord` throws, the record is still treated as failed and `onRecordError` is invoked when set.
  */
 const processPartialBatchWithResult = async (event, processRecord, options) => {
-    const concurrency = options?.concurrency ?? 1;
+    const concurrency = resolveConcurrency(options?.concurrency);
     const batchItemFailures = [];
     const handle = async (record) => {
         const id = options?.mapMessageId?.(record) ?? record.messageId;
@@ -107,4 +135,4 @@ const processPartialBatchWithResult = async (event, processRecord, options) => {
     return { batchItemFailures };
 };
 exports.processPartialBatchWithResult = processPartialBatchWithResult;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["import type { SQSBatchResponse, SQSEvent, SQSRecord } from 'aws-lambda';\n\n/**\n * Options for {@link processPartialBatch} and {@link processPartialBatchWithResult}.\n */\nexport interface ProcessPartialBatchOptions {\n  /**\n   * When greater than 1, records are processed with a bounded concurrency pool.\n   * Order of entries in {@link SQSBatchResponse.batchItemFailures} is not guaranteed.\n   * @default 1\n   */\n  readonly concurrency?: number;\n\n  /**\n   * Called when a record is treated as failed (thrown error or `{ ok: false }`).\n   * Use for logging; the library does not write to `console` by default.\n   */\n  readonly onRecordError?: (record: SQSRecord, error: unknown) => void;\n\n  /**\n   * Returns the value for `itemIdentifier` for a record. Defaults to `record.messageId`.\n   */\n  readonly mapMessageId?: (record: SQSRecord) => string;\n}\n\nconst itemFailure = (itemIdentifier: string): { itemIdentifier: string } => ({\n  itemIdentifier,\n});\n\n/**\n * Runs `fn` over `items` with at most `concurrency` parallel workers.\n * Each worker pulls the next index until none remain.\n */\nconst runWithConcurrency = async <T>(\n  items: readonly T[],\n  concurrency: number,\n  fn: (item: T) => Promise<void>,\n): Promise<void> => {\n  if (items.length === 0) {\n    return;\n  }\n  const limit = Math.min(Math.max(1, concurrency), items.length);\n  let next = 0;\n\n  const takeNextIndex = (): number | undefined => {\n    const index = next;\n    next += 1;\n    if (index >= items.length) {\n      return undefined;\n    }\n    return index;\n  };\n\n  const workers: Promise<void>[] = [];\n  for (let w = 0; w < limit; w++) {\n    workers.push((async () => {\n      let workIndex = takeNextIndex();\n      while (workIndex !== undefined) {\n        const item = items[workIndex];\n        if (item === undefined) {\n          return;\n        }\n        await fn(item);\n        workIndex = takeNextIndex();\n      }\n    })());\n  }\n  await Promise.all(workers);\n};\n\n/**\n * Runs `processRecord` for each SQS record. Thrown errors are mapped to\n * `batchItemFailures`; successful records are not listed.\n */\nexport const processPartialBatch = async (\n  event: SQSEvent,\n  processRecord: (record: SQSRecord) => Promise<void>,\n  options?: ProcessPartialBatchOptions,\n): Promise<SQSBatchResponse> => {\n  const concurrency = options?.concurrency ?? 1;\n  const batchItemFailures: { itemIdentifier: string }[] = [];\n\n  const handle = async (record: SQSRecord): Promise<void> => {\n    const id = options?.mapMessageId?.(record) ?? record.messageId;\n    try {\n      await processRecord(record);\n    } catch (error) {\n      if (options?.onRecordError) {\n        options.onRecordError(record, error);\n      }\n      batchItemFailures.push(itemFailure(id));\n    }\n  };\n\n  if (concurrency <= 1) {\n    for (const record of event.Records) {\n      await handle(record);\n    }\n  } else {\n    await runWithConcurrency(event.Records, concurrency, handle);\n  }\n\n  return { batchItemFailures };\n};\n\n/**\n * Like {@link processPartialBatch}, but uses a Result-style callback (no throw for control flow).\n * If `processRecord` throws, the record is still treated as failed and `onRecordError` is invoked when set.\n */\nexport const processPartialBatchWithResult = async (\n  event: SQSEvent,\n  processRecord: (record: SQSRecord) => Promise<{ ok: true } | { ok: false }>,\n  options?: ProcessPartialBatchOptions,\n): Promise<SQSBatchResponse> => {\n  const concurrency = options?.concurrency ?? 1;\n  const batchItemFailures: { itemIdentifier: string }[] = [];\n\n  const handle = async (record: SQSRecord): Promise<void> => {\n    const id = options?.mapMessageId?.(record) ?? record.messageId;\n    let result: { ok: true } | { ok: false };\n    try {\n      result = await processRecord(record);\n    } catch (error) {\n      if (options?.onRecordError) {\n        options.onRecordError(record, error);\n      }\n      batchItemFailures.push(itemFailure(id));\n      return;\n    }\n    if (result.ok) {\n      return;\n    }\n    if (options?.onRecordError) {\n      options.onRecordError(record, new Error('processRecord returned { ok: false }'));\n    }\n    batchItemFailures.push(itemFailure(id));\n  };\n\n  if (concurrency <= 1) {\n    for (const record of event.Records) {\n      await handle(record);\n    }\n  } else {\n    await runWithConcurrency(event.Records, concurrency, handle);\n  }\n\n  return { batchItemFailures };\n};\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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","sourcesContent":["import type { SQSBatchResponse, SQSEvent, SQSRecord } from 'aws-lambda';\n\n/**\n * Options for {@link processPartialBatch} and {@link processPartialBatchWithResult}.\n */\nexport interface ProcessPartialBatchOptions {\n  /**\n   * Maximum number of records processed in parallel.\n   *\n   * - `1`: sequential processing\n   * - `> 1`: bounded concurrency pool (order of `batchItemFailures` is not guaranteed)\n   *\n   * @throws {RangeError} When `concurrency` is less than 1.\n   * @throws {TypeError} When `concurrency` is not a finite integer.\n   * Order of entries in {@link SQSBatchResponse.batchItemFailures} is not guaranteed.\n   * @default 1\n   */\n  readonly concurrency?: number;\n\n  /**\n   * Called when a record is treated as failed (thrown error or `{ ok: false }`).\n   * Use for logging; the library does not write to `console` by default.\n   */\n  readonly onRecordError?: (record: SQSRecord, error: unknown) => void;\n\n  /**\n   * Returns the value for `itemIdentifier` for a record. Defaults to `record.messageId`.\n   */\n  readonly mapMessageId?: (record: SQSRecord) => string;\n}\n\n/**\n * Creates a single `batchItemFailures` entry for a failed record.\n * @param itemIdentifier The identifier reported back to Lambda.\n */\nconst itemFailure = (itemIdentifier: string): { itemIdentifier: string } => ({\n  itemIdentifier,\n});\n\n/**\n * Resolves and validates the `concurrency` option.\n *\n * @param value User-provided concurrency.\n * @returns A validated concurrency value (defaults to `1`).\n * @throws {RangeError} When `value` is less than 1.\n * @throws {TypeError} When `value` is not a finite integer.\n */\nconst resolveConcurrency = (value: number | undefined): number => {\n  if (value === undefined) {\n    return 1;\n  }\n  if (!Number.isFinite(value) || !Number.isInteger(value)) {\n    throw new TypeError('concurrency must be a finite integer');\n  }\n  if (value < 1) {\n    throw new RangeError('concurrency must be >= 1');\n  }\n  return value;\n};\n\n/**\n * Runs `fn` over `items` with at most `concurrency` parallel workers.\n * Each worker pulls the next index until none remain.\n *\n * @param items Items to process.\n * @param concurrency Maximum parallel workers (must be `>= 1`).\n * @param fn Async handler invoked for each item.\n */\nconst runWithConcurrency = async <T>(\n  items: readonly T[],\n  concurrency: number,\n  fn: (item: T) => Promise<void>,\n): Promise<void> => {\n  if (items.length === 0) {\n    return;\n  }\n  const limit = Math.min(concurrency, items.length);\n  let next = 0;\n\n  const takeNextIndex = (): number | undefined => {\n    const index = next;\n    next += 1;\n    if (index >= items.length) {\n      return undefined;\n    }\n    return index;\n  };\n\n  const workers: Promise<void>[] = [];\n  for (let w = 0; w < limit; w++) {\n    workers.push((async () => {\n      let workIndex = takeNextIndex();\n      while (workIndex !== undefined) {\n        const item = items[workIndex];\n        if (item === undefined) {\n          return;\n        }\n        await fn(item);\n        workIndex = takeNextIndex();\n      }\n    })());\n  }\n  await Promise.all(workers);\n};\n\n/**\n * Runs `processRecord` for each SQS record. Thrown errors are mapped to\n * `batchItemFailures`; successful records are not listed.\n */\nexport const processPartialBatch = async (\n  event: SQSEvent,\n  processRecord: (record: SQSRecord) => Promise<void>,\n  options?: ProcessPartialBatchOptions,\n): Promise<SQSBatchResponse> => {\n  const concurrency = resolveConcurrency(options?.concurrency);\n  const batchItemFailures: { itemIdentifier: string }[] = [];\n\n  const handle = async (record: SQSRecord): Promise<void> => {\n    const id = options?.mapMessageId?.(record) ?? record.messageId;\n    try {\n      await processRecord(record);\n    } catch (error) {\n      if (options?.onRecordError) {\n        options.onRecordError(record, error);\n      }\n      batchItemFailures.push(itemFailure(id));\n    }\n  };\n\n  if (concurrency <= 1) {\n    for (const record of event.Records) {\n      await handle(record);\n    }\n  } else {\n    await runWithConcurrency(event.Records, concurrency, handle);\n  }\n\n  return { batchItemFailures };\n};\n\n/**\n * Like {@link processPartialBatch}, but uses a Result-style callback (no throw for control flow).\n * If `processRecord` throws, the record is still treated as failed and `onRecordError` is invoked when set.\n */\nexport const processPartialBatchWithResult = async (\n  event: SQSEvent,\n  processRecord: (record: SQSRecord) => Promise<{ ok: true } | { ok: false }>,\n  options?: ProcessPartialBatchOptions,\n): Promise<SQSBatchResponse> => {\n  const concurrency = resolveConcurrency(options?.concurrency);\n  const batchItemFailures: { itemIdentifier: string }[] = [];\n\n  const handle = async (record: SQSRecord): Promise<void> => {\n    const id = options?.mapMessageId?.(record) ?? record.messageId;\n    let result: { ok: true } | { ok: false };\n    try {\n      result = await processRecord(record);\n    } catch (error) {\n      if (options?.onRecordError) {\n        options.onRecordError(record, error);\n      }\n      batchItemFailures.push(itemFailure(id));\n      return;\n    }\n    if (result.ok) {\n      return;\n    }\n    if (options?.onRecordError) {\n      options.onRecordError(record, new Error('processRecord returned { ok: false }'));\n    }\n    batchItemFailures.push(itemFailure(id));\n  };\n\n  if (concurrency <= 1) {\n    for (const record of event.Records) {\n      await handle(record);\n    }\n  } else {\n    await runWithConcurrency(event.Records, concurrency, handle);\n  }\n\n  return { batchItemFailures };\n};\n"]}

package/package.json

@@ -65,7 +65,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.1.11",
+  "version": "0.2.0",
   "jest": {
     "coverageProvider": "v8",
     "testMatch": [