sqs-partial-batch-processor 0.2.6 → 0.3.0

package/README.md

@@ -12,13 +12,15 @@ This library intentionally does **not** parse message bodies, validate schemas,
 
 - Implements Lambda SQS **partial batch response** pattern (only failed messages are retried).
 - Per-record error boundary (failures are isolated to each record).
-- Aggregates failed `messageId`s into `batchItemFailures`.
-- Optional bounded concurrency (`concurrency`) and error hook (`onRecordError`).
+- Aggregates failed identifiers into `batchItemFailures` (defaults to `messageId`).
+- Throw-style (`processPartialBatch`) and Result-style (`processPartialBatchWithResult`) APIs.
+- Optional bounded concurrency (`concurrency`), error hook (`onRecordError`), and custom `itemIdentifier` mapping (`mapMessageId`).
+- For `{ ok: false }`, `onRecordError` receives an `Error` that includes the resolved `itemIdentifier` (message and `cause`) for easier debugging.
 
 ## Requirements
 
 - Node.js **20+** (runtime requirement)
-- Module system: published as **CommonJS** (`"module": "CommonJS"`). Usable from both CJS and ESM runtimes.
+- Module system: published as **CommonJS** (`"main": "lib/index.js"`). Usable from both CJS and ESM runtimes.
 - Lambda SQS event source mapping has **Report batch item failures** enabled.
   See: [AWS Lambda SQS error handling docs](https://docs.aws.amazon.com/lambda/latest/dg/services-sqs-errorhandling.html#services-sqs-batchfailurereporting)
 
@@ -34,6 +36,8 @@ yarn add sqs-partial-batch-processor
 
 ## Usage
 
+Throw to mark a record as failed:
+
 ```ts
 import type { SQSEvent } from 'aws-lambda';
 import { processPartialBatch } from 'sqs-partial-batch-processor';
@@ -68,6 +72,8 @@ Both `processPartialBatch` and `processPartialBatchWithResult` accept an optiona
   - **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).
+  - **Caution**: do **not** log `record.body` as-is in `onRecordError`. Message bodies often contain secrets or personal data. Prefer `messageId` / your `mapMessageId` result and a sanitized error summary.
+  - When `processPartialBatchWithResult` receives `{ ok: false }`, the hook gets an `Error` whose message (and `cause.itemIdentifier`) includes the resolved `itemIdentifier` for easier debugging.
   - Example (structured log / metrics hook):
 
 ```ts
@@ -86,7 +92,7 @@ export const handler = async (event: SQSEvent) =>
           level: 'error',
           msg: 'record failed',
           messageId: record.messageId,
-          // Avoid logging sensitive contents from record.body.
+          // Do not log record.body — it may contain secrets or PII.
           error: error instanceof Error ? { name: error.name, message: error.message } : { message: String(error) },
         }));
       },
@@ -99,4 +105,4 @@ export const handler = async (event: SQSEvent) =>
 
 ## License
 
-This project is licensed under the (Apache-2.0) License.
+This project is licensed under the Apache-2.0 License.

package/lib/index.d.ts

@@ -7,32 +7,64 @@ export interface ProcessPartialBatchOptions {
      * Maximum number of records processed in parallel.
      *
      * - `1`: sequential processing
-     * - `> 1`: bounded concurrency pool (order of `batchItemFailures` is not guaranteed)
+     * - `> 1`: bounded concurrency pool (order of {@link SQSBatchResponse.batchItemFailures} is not guaranteed)
      *
+     * @default 1
      * @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
      */
     readonly concurrency?: number;
     /**
      * Called when a record is treated as failed (thrown error or `{ ok: false }`).
-     * Use for logging; the library does not write to `console` by default.
+     * Use for logging or metrics; the library does not write to `console` by default.
+     *
+     * For `{ ok: false }` from {@link processPartialBatchWithResult}, `error` is an `Error`
+     * whose message includes the resolved `itemIdentifier`, and whose `cause` is
+     * `{ itemIdentifier }` for structured logging.
+     *
+     * Do not log `record.body` as-is — it may contain secrets or personal data.
+     * Prefer identifiers such as `record.messageId` (or your `mapMessageId` result)
+     * and a sanitized error summary.
+     *
+     * @param record The failed SQS record.
+     * @param error The thrown value, or a synthesized `Error` when `{ ok: false }` was returned.
      */
     readonly onRecordError?: (record: SQSRecord, error: unknown) => void;
     /**
-     * Returns the value for `itemIdentifier` for a record. Defaults to `record.messageId`.
+     * Returns the `itemIdentifier` reported in `batchItemFailures` for a record.
+     * Defaults to `record.messageId` when omitted.
+     *
+     * @param record The SQS record being processed.
+     * @returns The identifier sent back to Lambda in `batchItemFailures`.
      */
     readonly mapMessageId?: (record: SQSRecord) => string;
 }
 /**
  * Runs `processRecord` for each SQS record. Thrown errors are mapped to
  * `batchItemFailures`; successful records are not listed.
+ *
+ * @param event The SQS Lambda event.
+ * @param processRecord Per-record handler. Throw to mark only that record as failed.
+ * @param options Optional concurrency, error hook, and message id mapping.
+ * @returns An {@link SQSBatchResponse} listing only failed `itemIdentifier`s.
+ * @throws {RangeError} When `options.concurrency` is less than 1.
+ * @throws {TypeError} When `options.concurrency` is not a finite integer.
  */
 export declare const processPartialBatch: (event: SQSEvent, processRecord: (record: SQSRecord) => Promise<void>, options?: ProcessPartialBatchOptions) => Promise<SQSBatchResponse>;
 /**
  * Like {@link processPartialBatch}, but uses a Result-style callback (no throw for control flow).
- * If `processRecord` throws, the record is still treated as failed and `onRecordError` is invoked when set.
+ *
+ * - `{ ok: true }`: success (not listed in `batchItemFailures`)
+ * - `{ ok: false }`: failure; if `onRecordError` is set, it receives an `Error` whose
+ *   message includes the resolved `itemIdentifier`, and whose `cause` is `{ itemIdentifier }`
+ * - thrown errors: still treated as failures; `onRecordError` receives the thrown value when set
+ *
+ * @param event The SQS Lambda event.
+ * @param processRecord Per-record handler returning `{ ok: true }` or `{ ok: false }`.
+ * @param options Optional concurrency, error hook, and message id mapping.
+ * @returns An {@link SQSBatchResponse} listing only failed `itemIdentifier`s.
+ * @throws {RangeError} When `options.concurrency` is less than 1.
+ * @throws {TypeError} When `options.concurrency` is not a finite integer.
  */
 export declare const processPartialBatchWithResult: (event: SQSEvent, processRecord: (record: SQSRecord) => Promise<{
     ok: true;

package/lib/index.js

@@ -3,7 +3,9 @@ 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.
+ * @returns An object suitable for {@link SQSBatchResponse.batchItemFailures}.
  */
 const itemFailure = (itemIdentifier) => ({
     itemIdentifier,
@@ -35,6 +37,7 @@ const resolveConcurrency = (value) => {
  * @param items Items to process.
  * @param concurrency Maximum parallel workers (must be `>= 1`).
  * @param fn Async handler invoked for each item.
+ * @returns A promise that resolves when every item has been processed.
  */
 const runWithConcurrency = async (items, concurrency, fn) => {
     if (items.length === 0) {
@@ -42,6 +45,11 @@ const runWithConcurrency = async (items, concurrency, fn) => {
     }
     const limit = Math.min(concurrency, items.length);
     let next = 0;
+    /**
+     * Claims the next work index, or `undefined` when the queue is empty.
+     *
+     * @returns The next index to process, or `undefined` if none remain.
+     */
     const takeNextIndex = () => {
         const index = next;
         next += 1;
@@ -69,10 +77,22 @@ const runWithConcurrency = async (items, concurrency, fn) => {
 /**
  * Runs `processRecord` for each SQS record. Thrown errors are mapped to
  * `batchItemFailures`; successful records are not listed.
+ *
+ * @param event The SQS Lambda event.
+ * @param processRecord Per-record handler. Throw to mark only that record as failed.
+ * @param options Optional concurrency, error hook, and message id mapping.
+ * @returns An {@link SQSBatchResponse} listing only failed `itemIdentifier`s.
+ * @throws {RangeError} When `options.concurrency` is less than 1.
+ * @throws {TypeError} When `options.concurrency` is not a finite integer.
  */
 const processPartialBatch = async (event, processRecord, options) => {
     const concurrency = resolveConcurrency(options?.concurrency);
     const batchItemFailures = [];
+    /**
+     * Processes one record and records a batch item failure on error.
+     *
+     * @param record The SQS record to process.
+     */
     const handle = async (record) => {
         const id = options?.mapMessageId?.(record) ?? record.messageId;
         try {
@@ -98,11 +118,27 @@ const processPartialBatch = async (event, processRecord, options) => {
 exports.processPartialBatch = processPartialBatch;
 /**
  * Like {@link processPartialBatch}, but uses a Result-style callback (no throw for control flow).
- * If `processRecord` throws, the record is still treated as failed and `onRecordError` is invoked when set.
+ *
+ * - `{ ok: true }`: success (not listed in `batchItemFailures`)
+ * - `{ ok: false }`: failure; if `onRecordError` is set, it receives an `Error` whose
+ *   message includes the resolved `itemIdentifier`, and whose `cause` is `{ itemIdentifier }`
+ * - thrown errors: still treated as failures; `onRecordError` receives the thrown value when set
+ *
+ * @param event The SQS Lambda event.
+ * @param processRecord Per-record handler returning `{ ok: true }` or `{ ok: false }`.
+ * @param options Optional concurrency, error hook, and message id mapping.
+ * @returns An {@link SQSBatchResponse} listing only failed `itemIdentifier`s.
+ * @throws {RangeError} When `options.concurrency` is less than 1.
+ * @throws {TypeError} When `options.concurrency` is not a finite integer.
  */
 const processPartialBatchWithResult = async (event, processRecord, options) => {
     const concurrency = resolveConcurrency(options?.concurrency);
     const batchItemFailures = [];
+    /**
+     * Processes one record; maps throws and `{ ok: false }` to batch item failures.
+     *
+     * @param record The SQS record to process.
+     */
     const handle = async (record) => {
         const id = options?.mapMessageId?.(record) ?? record.messageId;
         let result;
@@ -120,7 +156,9 @@ const processPartialBatchWithResult = async (event, processRecord, options) => {
             return;
         }
         if (options?.onRecordError) {
-            options.onRecordError(record, new Error('processRecord returned { ok: false }'));
+            const error = new Error(`processRecord returned { ok: false } (itemIdentifier=${id})`);
+            Object.assign(error, { cause: { itemIdentifier: id } });
+            options.onRecordError(record, error);
         }
         batchItemFailures.push(itemFailure(id));
     };
@@ -135,4 +173,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   * 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"]}
+//# 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 {@link SQSBatchResponse.batchItemFailures} is not guaranteed)\n   *\n   * @default 1\n   * @throws {RangeError} When `concurrency` is less than 1.\n   * @throws {TypeError} When `concurrency` is not a finite integer.\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 or metrics; the library does not write to `console` by default.\n   *\n   * For `{ ok: false }` from {@link processPartialBatchWithResult}, `error` is an `Error`\n   * whose message includes the resolved `itemIdentifier`, and whose `cause` is\n   * `{ itemIdentifier }` for structured logging.\n   *\n   * Do not log `record.body` as-is — it may contain secrets or personal data.\n   * Prefer identifiers such as `record.messageId` (or your `mapMessageId` result)\n   * and a sanitized error summary.\n   *\n   * @param record The failed SQS record.\n   * @param error The thrown value, or a synthesized `Error` when `{ ok: false }` was returned.\n   */\n  readonly onRecordError?: (record: SQSRecord, error: unknown) => void;\n\n  /**\n   * Returns the `itemIdentifier` reported in `batchItemFailures` for a record.\n   * Defaults to `record.messageId` when omitted.\n   *\n   * @param record The SQS record being processed.\n   * @returns The identifier sent back to Lambda in `batchItemFailures`.\n   */\n  readonly mapMessageId?: (record: SQSRecord) => string;\n}\n\n/**\n * Creates a single `batchItemFailures` entry for a failed record.\n *\n * @param itemIdentifier The identifier reported back to Lambda.\n * @returns An object suitable for {@link SQSBatchResponse.batchItemFailures}.\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 * @returns A promise that resolves when every item has been processed.\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  /**\n   * Claims the next work index, or `undefined` when the queue is empty.\n   *\n   * @returns The next index to process, or `undefined` if none remain.\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 *\n * @param event The SQS Lambda event.\n * @param processRecord Per-record handler. Throw to mark only that record as failed.\n * @param options Optional concurrency, error hook, and message id mapping.\n * @returns An {@link SQSBatchResponse} listing only failed `itemIdentifier`s.\n * @throws {RangeError} When `options.concurrency` is less than 1.\n * @throws {TypeError} When `options.concurrency` is not a finite integer.\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  /**\n   * Processes one record and records a batch item failure on error.\n   *\n   * @param record The SQS record to process.\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 *\n * - `{ ok: true }`: success (not listed in `batchItemFailures`)\n * - `{ ok: false }`: failure; if `onRecordError` is set, it receives an `Error` whose\n *   message includes the resolved `itemIdentifier`, and whose `cause` is `{ itemIdentifier }`\n * - thrown errors: still treated as failures; `onRecordError` receives the thrown value when set\n *\n * @param event The SQS Lambda event.\n * @param processRecord Per-record handler returning `{ ok: true }` or `{ ok: false }`.\n * @param options Optional concurrency, error hook, and message id mapping.\n * @returns An {@link SQSBatchResponse} listing only failed `itemIdentifier`s.\n * @throws {RangeError} When `options.concurrency` is less than 1.\n * @throws {TypeError} When `options.concurrency` is not a finite integer.\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  /**\n   * Processes one record; maps throws and `{ ok: false }` to batch item failures.\n   *\n   * @param record The SQS record to process.\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      const error = new Error(`processRecord returned { ok: false } (itemIdentifier=${id})`);\n      Object.assign(error, { cause: { itemIdentifier: id } });\n      options.onRecordError(record, error);\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

@@ -43,10 +43,10 @@
     "eslint-plugin-import": "^2.32.0",
     "jest": "^30.4.2",
     "jest-junit": "^17",
-    "projen": "^0.101.4",
+    "projen": "^0.101.11",
     "ts-jest": "^29.4.11",
     "ts-node": "^10.9.2",
-    "typescript": "5.9.x"
+    "typescript": "6.0.x"
   },
   "dependencies": {
     "@types/aws-lambda": "^8.10.145"
@@ -63,8 +63,7 @@
   },
   "devEngines": {
     "packageManager": {
-      "name": "yarn",
-      "version": "1.22.22",
+      "name": "npm",
       "onFail": "ignore"
     }
   },
@@ -73,7 +72,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.2.6",
+  "version": "0.3.0",
   "jest": {
     "coverageProvider": "v8",
     "testMatch": [