sqs-partial-batch-processor 0.3.7 → 0.4.1

package/README.md

@@ -8,13 +8,17 @@ You supply per-record async logic; the library handles looping, per-record error
 
 This library intentionally does **not** parse message bodies, validate schemas, create AWS SDK clients, or make retry/business decisions for you.
 
+Import the public API from the package root (`processPartialBatch`, `processPartialBatchWithResult`, `ProcessPartialBatchOptions`, `ProcessRecordResult`).
+
 ## Features
 
 - Implements Lambda SQS **partial batch response** pattern (only failed messages are retried).
 - Per-record error boundary (failures are isolated to each record).
 - Aggregates failed identifiers into `batchItemFailures` (defaults to `messageId`).
 - Throw-style (`processPartialBatch`) and Result-style (`processPartialBatchWithResult`) APIs.
+- Typed Result callback via `ProcessRecordResult` (`{ ok: true }` | `{ ok: false }`).
 - Optional bounded concurrency (`concurrency`), error hook (`onRecordError`), and custom `itemIdentifier` mapping (`mapMessageId`).
+- Shared options type `ProcessPartialBatchOptions` for both APIs.
 - For `{ ok: false }`, `onRecordError` receives an `Error` that includes the resolved `itemIdentifier` (message and `cause`) for easier debugging.
 
 ## Requirements
@@ -34,6 +38,10 @@ npm install sqs-partial-batch-processor
 yarn add sqs-partial-batch-processor
 ```
 
+```bash
+pnpm add sqs-partial-batch-processor
+```
+
 ## Usage
 
 Throw to mark a record as failed:
@@ -49,14 +57,21 @@ export const handler = async (event: SQSEvent) =>
   });
 ```
 
-Result-style callback (no throw for control flow):
+Result-style callback (no throw for control flow). Return a `ProcessRecordResult`:
+
+- `{ ok: true }`: success (not listed in `batchItemFailures`)
+- `{ ok: false }`: failure (listed in `batchItemFailures`)
+- thrown errors: still treated as failures
 
 ```ts
 import type { SQSEvent } from 'aws-lambda';
-import { processPartialBatchWithResult } from 'sqs-partial-batch-processor';
+import {
+  processPartialBatchWithResult,
+  type ProcessRecordResult,
+} from 'sqs-partial-batch-processor';
 
 export const handler = async (event: SQSEvent) =>
-  processPartialBatchWithResult(event, async (record) => {
+  processPartialBatchWithResult(event, async (record): Promise<ProcessRecordResult> => {
     if (record.body === '') {
       return { ok: false };
     }
@@ -66,7 +81,7 @@ export const handler = async (event: SQSEvent) =>
 
 ## Options
 
-Both `processPartialBatch` and `processPartialBatchWithResult` accept an optional `options` object:
+Both `processPartialBatch` and `processPartialBatchWithResult` accept an optional `ProcessPartialBatchOptions` object:
 
 - `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.
@@ -77,8 +92,8 @@ Both `processPartialBatch` and `processPartialBatchWithResult` accept an optiona
   - Example (structured log / metrics hook):
 
 ```ts
-import { processPartialBatch } from 'sqs-partial-batch-processor';
 import type { SQSEvent } from 'aws-lambda';
+import { processPartialBatch } from 'sqs-partial-batch-processor';
 
 export const handler = async (event: SQSEvent) =>
   processPartialBatch(

package/lib/index.d.ts

@@ -1,73 +1,3 @@
-import type { SQSBatchResponse, SQSEvent, SQSRecord } from 'aws-lambda';
-/**
- * Options for {@link processPartialBatch} and {@link processPartialBatchWithResult}.
- */
-export interface ProcessPartialBatchOptions {
-    /**
-     * Maximum number of records processed in parallel.
-     *
-     * - `1`: sequential processing
-     * - `> 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.
-     */
-    readonly concurrency?: number;
-    /**
-     * Called when a record is treated as failed (thrown error or `{ ok: false }`).
-     * 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 `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).
- *
- * - `{ 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;
-} | {
-    ok: false;
-}>, options?: ProcessPartialBatchOptions) => Promise<SQSBatchResponse>;
+export type { ProcessPartialBatchOptions, ProcessRecordResult } from './types';
+export { processPartialBatch } from './processor/process-partial-batch';
+export { processPartialBatchWithResult } from './processor/process-partial-batch-with-result';

package/lib/index.js

@@ -1,176 +1,8 @@
 "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.
- * @returns An object suitable for {@link SQSBatchResponse.batchItemFailures}.
- */
-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.
- * @returns A promise that resolves when every item has been processed.
- */
-const runWithConcurrency = async (items, concurrency, fn) => {
-    if (items.length === 0) {
-        return;
-    }
-    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;
-        if (index >= items.length) {
-            return undefined;
-        }
-        return index;
-    };
-    const workers = [];
-    for (let w = 0; w < limit; w++) {
-        workers.push((async () => {
-            let workIndex = takeNextIndex();
-            while (workIndex !== undefined) {
-                const item = items[workIndex];
-                if (item === undefined) {
-                    return;
-                }
-                await fn(item);
-                workIndex = takeNextIndex();
-            }
-        })());
-    }
-    await Promise.all(workers);
-};
-/**
- * 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 {
-            await processRecord(record);
-        }
-        catch (error) {
-            if (options?.onRecordError) {
-                options.onRecordError(record, error);
-            }
-            batchItemFailures.push(itemFailure(id));
-        }
-    };
-    if (concurrency <= 1) {
-        for (const record of event.Records) {
-            await handle(record);
-        }
-    }
-    else {
-        await runWithConcurrency(event.Records, concurrency, handle);
-    }
-    return { batchItemFailures };
-};
-exports.processPartialBatch = processPartialBatch;
-/**
- * Like {@link processPartialBatch}, but uses a Result-style callback (no throw for control flow).
- *
- * - `{ 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;
-        try {
-            result = await processRecord(record);
-        }
-        catch (error) {
-            if (options?.onRecordError) {
-                options.onRecordError(record, error);
-            }
-            batchItemFailures.push(itemFailure(id));
-            return;
-        }
-        if (result.ok) {
-            return;
-        }
-        if (options?.onRecordError) {
-            const error = new Error(`processRecord returned { ok: false } (itemIdentifier=${id})`);
-            Object.assign(error, { cause: { itemIdentifier: id } });
-            options.onRecordError(record, error);
-        }
-        batchItemFailures.push(itemFailure(id));
-    };
-    if (concurrency <= 1) {
-        for (const record of event.Records) {
-            await handle(record);
-        }
-    }
-    else {
-        await runWithConcurrency(event.Records, concurrency, handle);
-    }
-    return { batchItemFailures };
-};
-exports.processPartialBatchWithResult = processPartialBatchWithResult;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;AA6CA;;;;;GAKG;AACH,MAAM,WAAW,GAAG,CAAC,cAAsB,EAA8B,EAAE,CAAC,CAAC;IAC3E,cAAc;CACf,CAAC,CAAC;AAEH;;;;;;;GAOG;AACH,MAAM,kBAAkB,GAAG,CAAC,KAAyB,EAAU,EAAE;IAC/D,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACxB,OAAO,CAAC,CAAC;IACX,CAAC;IACD,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC;QACxD,MAAM,IAAI,SAAS,CAAC,sCAAsC,CAAC,CAAC;IAC9D,CAAC;IACD,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;QACd,MAAM,IAAI,UAAU,CAAC,0BAA0B,CAAC,CAAC;IACnD,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC,CAAC;AAEF;;;;;;;;GAQG;AACH,MAAM,kBAAkB,GAAG,KAAK,EAC9B,KAAmB,EACnB,WAAmB,EACnB,EAA8B,EACf,EAAE;IACjB,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;QACvB,OAAO;IACT,CAAC;IACD,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,WAAW,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IAClD,IAAI,IAAI,GAAG,CAAC,CAAC;IAEb;;;;OAIG;IACH,MAAM,aAAa,GAAG,GAAuB,EAAE;QAC7C,MAAM,KAAK,GAAG,IAAI,CAAC;QACnB,IAAI,IAAI,CAAC,CAAC;QACV,IAAI,KAAK,IAAI,KAAK,CAAC,MAAM,EAAE,CAAC;YAC1B,OAAO,SAAS,CAAC;QACnB,CAAC;QACD,OAAO,KAAK,CAAC;IACf,CAAC,CAAC;IAEF,MAAM,OAAO,GAAoB,EAAE,CAAC;IACpC,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,EAAE,CAAC,EAAE,EAAE,CAAC;QAC/B,OAAO,CAAC,IAAI,CAAC,CAAC,KAAK,IAAI,EAAE;YACvB,IAAI,SAAS,GAAG,aAAa,EAAE,CAAC;YAChC,OAAO,SAAS,KAAK,SAAS,EAAE,CAAC;gBAC/B,MAAM,IAAI,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC;gBAC9B,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;oBACvB,OAAO;gBACT,CAAC;gBACD,MAAM,EAAE,CAAC,IAAI,CAAC,CAAC;gBACf,SAAS,GAAG,aAAa,EAAE,CAAC;YAC9B,CAAC;QACH,CAAC,CAAC,EAAE,CAAC,CAAC;IACR,CAAC;IACD,MAAM,OAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;AAC7B,CAAC,CAAC;AAEF;;;;;;;;;;GAUG;AACI,MAAM,mBAAmB,GAAG,KAAK,EACtC,KAAe,EACf,aAAmD,EACnD,OAAoC,EACT,EAAE;IAC7B,MAAM,WAAW,GAAG,kBAAkB,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;IAC7D,MAAM,iBAAiB,GAAiC,EAAE,CAAC;IAE3D;;;;OAIG;IACH,MAAM,MAAM,GAAG,KAAK,EAAE,MAAiB,EAAiB,EAAE;QACxD,MAAM,EAAE,GAAG,OAAO,EAAE,YAAY,EAAE,CAAC,MAAM,CAAC,IAAI,MAAM,CAAC,SAAS,CAAC;QAC/D,IAAI,CAAC;YACH,MAAM,aAAa,CAAC,MAAM,CAAC,CAAC;QAC9B,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,OAAO,EAAE,aAAa,EAAE,CAAC;gBAC3B,OAAO,CAAC,aAAa,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;YACvC,CAAC;YACD,iBAAiB,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC,CAAC;QAC1C,CAAC;IACH,CAAC,CAAC;IAEF,IAAI,WAAW,IAAI,CAAC,EAAE,CAAC;QACrB,KAAK,MAAM,MAAM,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC;YACnC,MAAM,MAAM,CAAC,MAAM,CAAC,CAAC;QACvB,CAAC;IACH,CAAC;SAAM,CAAC;QACN,MAAM,kBAAkB,CAAC,KAAK,CAAC,OAAO,EAAE,WAAW,EAAE,MAAM,CAAC,CAAC;IAC/D,CAAC;IAED,OAAO,EAAE,iBAAiB,EAAE,CAAC;AAC/B,CAAC,CAAC;AAlCW,QAAA,mBAAmB,uBAkC9B;AAEF;;;;;;;;;;;;;;GAcG;AACI,MAAM,6BAA6B,GAAG,KAAK,EAChD,KAAe,EACf,aAA2E,EAC3E,OAAoC,EACT,EAAE;IAC7B,MAAM,WAAW,GAAG,kBAAkB,CAAC,OAAO,EAAE,WAAW,CAAC,CAAC;IAC7D,MAAM,iBAAiB,GAAiC,EAAE,CAAC;IAE3D;;;;OAIG;IACH,MAAM,MAAM,GAAG,KAAK,EAAE,MAAiB,EAAiB,EAAE;QACxD,MAAM,EAAE,GAAG,OAAO,EAAE,YAAY,EAAE,CAAC,MAAM,CAAC,IAAI,MAAM,CAAC,SAAS,CAAC;QAC/D,IAAI,MAAoC,CAAC;QACzC,IAAI,CAAC;YACH,MAAM,GAAG,MAAM,aAAa,CAAC,MAAM,CAAC,CAAC;QACvC,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,IAAI,OAAO,EAAE,aAAa,EAAE,CAAC;gBAC3B,OAAO,CAAC,aAAa,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;YACvC,CAAC;YACD,iBAAiB,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC,CAAC;YACxC,OAAO;QACT,CAAC;QACD,IAAI,MAAM,CAAC,EAAE,EAAE,CAAC;YACd,OAAO;QACT,CAAC;QACD,IAAI,OAAO,EAAE,aAAa,EAAE,CAAC;YAC3B,MAAM,KAAK,GAAG,IAAI,KAAK,CAAC,wDAAwD,EAAE,GAAG,CAAC,CAAC;YACvF,MAAM,CAAC,MAAM,CAAC,KAAK,EAAE,EAAE,KAAK,EAAE,EAAE,cAAc,EAAE,EAAE,EAAE,EAAE,CAAC,CAAC;YACxD,OAAO,CAAC,aAAa,CAAC,MAAM,EAAE,KAAK,CAAC,CAAC;QACvC,CAAC;QACD,iBAAiB,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC,CAAC;IAC1C,CAAC,CAAC;IAEF,IAAI,WAAW,IAAI,CAAC,EAAE,CAAC;QACrB,KAAK,MAAM,MAAM,IAAI,KAAK,CAAC,OAAO,EAAE,CAAC;YACnC,MAAM,MAAM,CAAC,MAAM,CAAC,CAAC;QACvB,CAAC;IACH,CAAC;SAAM,CAAC;QACN,MAAM,kBAAkB,CAAC,KAAK,CAAC,OAAO,EAAE,WAAW,EAAE,MAAM,CAAC,CAAC;IAC/D,CAAC;IAED,OAAO,EAAE,iBAAiB,EAAE,CAAC;AAC/B,CAAC,CAAC;AA7CW,QAAA,6BAA6B,iCA6CxC","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"]}
+var process_partial_batch_1 = require("./processor/process-partial-batch");
+Object.defineProperty(exports, "processPartialBatch", { enumerable: true, get: function () { return process_partial_batch_1.processPartialBatch; } });
+var process_partial_batch_with_result_1 = require("./processor/process-partial-batch-with-result");
+Object.defineProperty(exports, "processPartialBatchWithResult", { enumerable: true, get: function () { return process_partial_batch_with_result_1.processPartialBatchWithResult; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQ0EsMkVBQXdFO0FBQS9ELDRIQUFBLG1CQUFtQixPQUFBO0FBQzVCLG1HQUE4RjtBQUFyRixrSkFBQSw2QkFBNkIsT0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB0eXBlIHsgUHJvY2Vzc1BhcnRpYWxCYXRjaE9wdGlvbnMsIFByb2Nlc3NSZWNvcmRSZXN1bHQgfSBmcm9tICcuL3R5cGVzJztcbmV4cG9ydCB7IHByb2Nlc3NQYXJ0aWFsQmF0Y2ggfSBmcm9tICcuL3Byb2Nlc3Nvci9wcm9jZXNzLXBhcnRpYWwtYmF0Y2gnO1xuZXhwb3J0IHsgcHJvY2Vzc1BhcnRpYWxCYXRjaFdpdGhSZXN1bHQgfSBmcm9tICcuL3Byb2Nlc3Nvci9wcm9jZXNzLXBhcnRpYWwtYmF0Y2gtd2l0aC1yZXN1bHQnO1xuIl19

package/lib/processor/concurrency.d.ts

@@ -0,0 +1,19 @@
+/**
+ * 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.
+ */
+export declare const resolveConcurrency: (value: number | undefined) => number;
+/**
+ * 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.
+ * @returns A promise that resolves when every item has been processed.
+ */
+export declare const runWithConcurrency: <T>(items: readonly T[], concurrency: number, fn: (item: T) => Promise<void>) => Promise<void>;

package/lib/processor/concurrency.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runWithConcurrency = exports.resolveConcurrency = void 0;
+/**
+ * Returns whether a worker still has an index to process.
+ *
+ * @param workIndex The index claimed from the work queue, or `undefined` when empty.
+ * @returns `true` when `workIndex` is a remaining item index.
+ */
+const hasRemainingWork = (workIndex) => workIndex !== undefined;
+/**
+ * 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;
+};
+exports.resolveConcurrency = resolveConcurrency;
+/**
+ * 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.
+ * @returns A promise that resolves when every item has been processed.
+ */
+const runWithConcurrency = async (items, concurrency, fn) => {
+    if (items.length === 0) {
+        return;
+    }
+    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;
+        if (index >= items.length) {
+            return undefined;
+        }
+        return index;
+    };
+    const workers = [];
+    for (let w = 0; w < limit; w++) {
+        workers.push((async () => {
+            let workIndex = takeNextIndex();
+            while (hasRemainingWork(workIndex)) {
+                const item = items[workIndex];
+                if (item === undefined) {
+                    return;
+                }
+                await fn(item);
+                workIndex = takeNextIndex();
+            }
+        })());
+    }
+    await Promise.all(workers);
+};
+exports.runWithConcurrency = runWithConcurrency;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/processor/item-failure.d.ts

@@ -0,0 +1,8 @@
+import type { SQSBatchResponse } from 'aws-lambda';
+/**
+ * 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}.
+ */
+export declare const itemFailure: (itemIdentifier: string) => SQSBatchResponse["batchItemFailures"][number];

package/lib/processor/item-failure.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.itemFailure = 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,
+});
+exports.itemFailure = itemFailure;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXRlbS1mYWlsdXJlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3Byb2Nlc3Nvci9pdGVtLWZhaWx1cmUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBRUE7Ozs7O0dBS0c7QUFDSSxNQUFNLFdBQVcsR0FBRyxDQUN6QixjQUFzQixFQUN5QixFQUFFLENBQUMsQ0FBQztJQUNuRCxjQUFjO0NBQ2YsQ0FBQyxDQUFDO0FBSlUsUUFBQSxXQUFXLGVBSXJCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBTUVNCYXRjaFJlc3BvbnNlIH0gZnJvbSAnYXdzLWxhbWJkYSc7XG5cbi8qKlxuICogQ3JlYXRlcyBhIHNpbmdsZSBgYmF0Y2hJdGVtRmFpbHVyZXNgIGVudHJ5IGZvciBhIGZhaWxlZCByZWNvcmQuXG4gKlxuICogQHBhcmFtIGl0ZW1JZGVudGlmaWVyIFRoZSBpZGVudGlmaWVyIHJlcG9ydGVkIGJhY2sgdG8gTGFtYmRhLlxuICogQHJldHVybnMgQW4gb2JqZWN0IHN1aXRhYmxlIGZvciB7QGxpbmsgU1FTQmF0Y2hSZXNwb25zZS5iYXRjaEl0ZW1GYWlsdXJlc30uXG4gKi9cbmV4cG9ydCBjb25zdCBpdGVtRmFpbHVyZSA9IChcbiAgaXRlbUlkZW50aWZpZXI6IHN0cmluZyxcbik6IFNRU0JhdGNoUmVzcG9uc2VbJ2JhdGNoSXRlbUZhaWx1cmVzJ11bbnVtYmVyXSA9PiAoe1xuICBpdGVtSWRlbnRpZmllcixcbn0pO1xuIl19

package/lib/processor/process-partial-batch-with-result.d.ts

@@ -0,0 +1,18 @@
+import type { SQSBatchResponse, SQSEvent, SQSRecord } from 'aws-lambda';
+import type { ProcessPartialBatchOptions, ProcessRecordResult } from '../types';
+/**
+ * Like {@link processPartialBatch}, but uses a Result-style callback (no throw for control flow).
+ *
+ * - `{ 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<ProcessRecordResult>, options?: ProcessPartialBatchOptions) => Promise<SQSBatchResponse>;

package/lib/processor/process-partial-batch-with-result.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processPartialBatchWithResult = void 0;
+const concurrency_1 = require("./concurrency");
+const item_failure_1 = require("./item-failure");
+/**
+ * Like {@link processPartialBatch}, but uses a Result-style callback (no throw for control flow).
+ *
+ * - `{ 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 = (0, concurrency_1.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;
+        try {
+            result = await processRecord(record);
+        }
+        catch (error) {
+            if (options?.onRecordError) {
+                options.onRecordError(record, error);
+            }
+            batchItemFailures.push((0, item_failure_1.itemFailure)(id));
+            return;
+        }
+        if (result.ok) {
+            return;
+        }
+        if (options?.onRecordError) {
+            const error = new Error(`processRecord returned { ok: false } (itemIdentifier=${id})`);
+            Object.assign(error, { cause: { itemIdentifier: id } });
+            options.onRecordError(record, error);
+        }
+        batchItemFailures.push((0, item_failure_1.itemFailure)(id));
+    };
+    if (concurrency <= 1) {
+        for (const record of event.Records) {
+            await handle(record);
+        }
+    }
+    else {
+        await (0, concurrency_1.runWithConcurrency)(event.Records, concurrency, handle);
+    }
+    return { batchItemFailures };
+};
+exports.processPartialBatchWithResult = processPartialBatchWithResult;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/processor/process-partial-batch.d.ts

@@ -0,0 +1,14 @@
+import type { SQSBatchResponse, SQSEvent, SQSRecord } from 'aws-lambda';
+import type { ProcessPartialBatchOptions } from '../types';
+/**
+ * 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>;

package/lib/processor/process-partial-batch.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processPartialBatch = void 0;
+const concurrency_1 = require("./concurrency");
+const item_failure_1 = require("./item-failure");
+/**
+ * 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 = (0, concurrency_1.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 {
+            await processRecord(record);
+        }
+        catch (error) {
+            if (options?.onRecordError) {
+                options.onRecordError(record, error);
+            }
+            batchItemFailures.push((0, item_failure_1.itemFailure)(id));
+        }
+    };
+    if (concurrency <= 1) {
+        for (const record of event.Records) {
+            await handle(record);
+        }
+    }
+    else {
+        await (0, concurrency_1.runWithConcurrency)(event.Records, concurrency, handle);
+    }
+    return { batchItemFailures };
+};
+exports.processPartialBatch = processPartialBatch;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvY2Vzcy1wYXJ0aWFsLWJhdGNoLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3Byb2Nlc3Nvci9wcm9jZXNzLXBhcnRpYWwtYmF0Y2gudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBRUEsK0NBQXVFO0FBQ3ZFLGlEQUE2QztBQUU3Qzs7Ozs7Ozs7OztHQVVHO0FBQ0ksTUFBTSxtQkFBbUIsR0FBRyxLQUFLLEVBQ3RDLEtBQWUsRUFDZixhQUFtRCxFQUNuRCxPQUFvQyxFQUNULEVBQUU7SUFDN0IsTUFBTSxXQUFXLEdBQUcsSUFBQSxnQ0FBa0IsRUFBQyxPQUFPLEVBQUUsV0FBVyxDQUFDLENBQUM7SUFDN0QsTUFBTSxpQkFBaUIsR0FBaUMsRUFBRSxDQUFDO0lBRTNEOzs7O09BSUc7SUFDSCxNQUFNLE1BQU0sR0FBRyxLQUFLLEVBQUUsTUFBaUIsRUFBaUIsRUFBRTtRQUN4RCxNQUFNLEVBQUUsR0FBRyxPQUFPLEVBQUUsWUFBWSxFQUFFLENBQUMsTUFBTSxDQUFDLElBQUksTUFBTSxDQUFDLFNBQVMsQ0FBQztRQUMvRCxJQUFJLENBQUM7WUFDSCxNQUFNLGFBQWEsQ0FBQyxNQUFNLENBQUMsQ0FBQztRQUM5QixDQUFDO1FBQUMsT0FBTyxLQUFLLEVBQUUsQ0FBQztZQUNmLElBQUksT0FBTyxFQUFFLGFBQWEsRUFBRSxDQUFDO2dCQUMzQixPQUFPLENBQUMsYUFBYSxDQUFDLE1BQU0sRUFBRSxLQUFLLENBQUMsQ0FBQztZQUN2QyxDQUFDO1lBQ0QsaUJBQWlCLENBQUMsSUFBSSxDQUFDLElBQUEsMEJBQVcsRUFBQyxFQUFFLENBQUMsQ0FBQyxDQUFDO1FBQzFDLENBQUM7SUFDSCxDQUFDLENBQUM7SUFFRixJQUFJLFdBQVcsSUFBSSxDQUFDLEVBQUUsQ0FBQztRQUNyQixLQUFLLE1BQU0sTUFBTSxJQUFJLEtBQUssQ0FBQyxPQUFPLEVBQUUsQ0FBQztZQUNuQyxNQUFNLE1BQU0sQ0FBQyxNQUFNLENBQUMsQ0FBQztRQUN2QixDQUFDO0lBQ0gsQ0FBQztTQUFNLENBQUM7UUFDTixNQUFNLElBQUEsZ0NBQWtCLEVBQUMsS0FBSyxDQUFDLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxDQUFDLENBQUM7SUFDL0QsQ0FBQztJQUVELE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxDQUFDO0FBQy9CLENBQUMsQ0FBQztBQWxDVyxRQUFBLG1CQUFtQix1QkFrQzlCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHR5cGUgeyBTUVNCYXRjaFJlc3BvbnNlLCBTUVNFdmVudCwgU1FTUmVjb3JkIH0gZnJvbSAnYXdzLWxhbWJkYSc7XG5pbXBvcnQgdHlwZSB7IFByb2Nlc3NQYXJ0aWFsQmF0Y2hPcHRpb25zIH0gZnJvbSAnLi4vdHlwZXMnO1xuaW1wb3J0IHsgcmVzb2x2ZUNvbmN1cnJlbmN5LCBydW5XaXRoQ29uY3VycmVuY3kgfSBmcm9tICcuL2NvbmN1cnJlbmN5JztcbmltcG9ydCB7IGl0ZW1GYWlsdXJlIH0gZnJvbSAnLi9pdGVtLWZhaWx1cmUnO1xuXG4vKipcbiAqIFJ1bnMgYHByb2Nlc3NSZWNvcmRgIGZvciBlYWNoIFNRUyByZWNvcmQuIFRocm93biBlcnJvcnMgYXJlIG1hcHBlZCB0b1xuICogYGJhdGNoSXRlbUZhaWx1cmVzYDsgc3VjY2Vzc2Z1bCByZWNvcmRzIGFyZSBub3QgbGlzdGVkLlxuICpcbiAqIEBwYXJhbSBldmVudCBUaGUgU1FTIExhbWJkYSBldmVudC5cbiAqIEBwYXJhbSBwcm9jZXNzUmVjb3JkIFBlci1yZWNvcmQgaGFuZGxlci4gVGhyb3cgdG8gbWFyayBvbmx5IHRoYXQgcmVjb3JkIGFzIGZhaWxlZC5cbiAqIEBwYXJhbSBvcHRpb25zIE9wdGlvbmFsIGNvbmN1cnJlbmN5LCBlcnJvciBob29rLCBhbmQgbWVzc2FnZSBpZCBtYXBwaW5nLlxuICogQHJldHVybnMgQW4ge0BsaW5rIFNRU0JhdGNoUmVzcG9uc2V9IGxpc3Rpbmcgb25seSBmYWlsZWQgYGl0ZW1JZGVudGlmaWVyYHMuXG4gKiBAdGhyb3dzIHtSYW5nZUVycm9yfSBXaGVuIGBvcHRpb25zLmNvbmN1cnJlbmN5YCBpcyBsZXNzIHRoYW4gMS5cbiAqIEB0aHJvd3Mge1R5cGVFcnJvcn0gV2hlbiBgb3B0aW9ucy5jb25jdXJyZW5jeWAgaXMgbm90IGEgZmluaXRlIGludGVnZXIuXG4gKi9cbmV4cG9ydCBjb25zdCBwcm9jZXNzUGFydGlhbEJhdGNoID0gYXN5bmMgKFxuICBldmVudDogU1FTRXZlbnQsXG4gIHByb2Nlc3NSZWNvcmQ6IChyZWNvcmQ6IFNRU1JlY29yZCkgPT4gUHJvbWlzZTx2b2lkPixcbiAgb3B0aW9ucz86IFByb2Nlc3NQYXJ0aWFsQmF0Y2hPcHRpb25zLFxuKTogUHJvbWlzZTxTUVNCYXRjaFJlc3BvbnNlPiA9PiB7XG4gIGNvbnN0IGNvbmN1cnJlbmN5ID0gcmVzb2x2ZUNvbmN1cnJlbmN5KG9wdGlvbnM/LmNvbmN1cnJlbmN5KTtcbiAgY29uc3QgYmF0Y2hJdGVtRmFpbHVyZXM6IHsgaXRlbUlkZW50aWZpZXI6IHN0cmluZyB9W10gPSBbXTtcblxuICAvKipcbiAgICogUHJvY2Vzc2VzIG9uZSByZWNvcmQgYW5kIHJlY29yZHMgYSBiYXRjaCBpdGVtIGZhaWx1cmUgb24gZXJyb3IuXG4gICAqXG4gICAqIEBwYXJhbSByZWNvcmQgVGhlIFNRUyByZWNvcmQgdG8gcHJvY2Vzcy5cbiAgICovXG4gIGNvbnN0IGhhbmRsZSA9IGFzeW5jIChyZWNvcmQ6IFNRU1JlY29yZCk6IFByb21pc2U8dm9pZD4gPT4ge1xuICAgIGNvbnN0IGlkID0gb3B0aW9ucz8ubWFwTWVzc2FnZUlkPy4ocmVjb3JkKSA/PyByZWNvcmQubWVzc2FnZUlkO1xuICAgIHRyeSB7XG4gICAgICBhd2FpdCBwcm9jZXNzUmVjb3JkKHJlY29yZCk7XG4gICAgfSBjYXRjaCAoZXJyb3IpIHtcbiAgICAgIGlmIChvcHRpb25zPy5vblJlY29yZEVycm9yKSB7XG4gICAgICAgIG9wdGlvbnMub25SZWNvcmRFcnJvcihyZWNvcmQsIGVycm9yKTtcbiAgICAgIH1cbiAgICAgIGJhdGNoSXRlbUZhaWx1cmVzLnB1c2goaXRlbUZhaWx1cmUoaWQpKTtcbiAgICB9XG4gIH07XG5cbiAgaWYgKGNvbmN1cnJlbmN5IDw9IDEpIHtcbiAgICBmb3IgKGNvbnN0IHJlY29yZCBvZiBldmVudC5SZWNvcmRzKSB7XG4gICAgICBhd2FpdCBoYW5kbGUocmVjb3JkKTtcbiAgICB9XG4gIH0gZWxzZSB7XG4gICAgYXdhaXQgcnVuV2l0aENvbmN1cnJlbmN5KGV2ZW50LlJlY29yZHMsIGNvbmN1cnJlbmN5LCBoYW5kbGUpO1xuICB9XG5cbiAgcmV0dXJuIHsgYmF0Y2hJdGVtRmFpbHVyZXMgfTtcbn07XG4iXX0=

package/lib/types/index.d.ts

@@ -0,0 +1,52 @@
+import type { SQSRecord } from 'aws-lambda';
+/**
+ * Result of a per-record handler used by {@link processPartialBatchWithResult}.
+ *
+ * - `{ ok: true }`: success (not listed in `batchItemFailures`)
+ * - `{ ok: false }`: failure (listed in `batchItemFailures`)
+ */
+export type ProcessRecordResult = {
+    ok: true;
+} | {
+    ok: false;
+};
+/**
+ * Options for {@link processPartialBatch} and {@link processPartialBatchWithResult}.
+ */
+export interface ProcessPartialBatchOptions {
+    /**
+     * Maximum number of records processed in parallel.
+     *
+     * - `1`: sequential processing
+     * - `> 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.
+     */
+    readonly concurrency?: number;
+    /**
+     * Called when a record is treated as failed (thrown error or `{ ok: false }`).
+     * 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 `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;
+}

package/lib/types/index.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -42,9 +42,9 @@
     "eslint": "^9",
     "eslint-import-resolver-typescript": "^4.4.5",
     "eslint-plugin-import": "^2.32.0",
-    "jest": "^30.5.0",
+    "jest": "^30.5.1",
     "jest-junit": "^17",
-    "projen": "^0.103.11",
+    "projen": "^0.103.20",
     "ts-jest": "^29.4.12",
     "ts-node": "^10.9.2",
     "typescript": "6.0.x"
@@ -73,7 +73,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.3.7",
+  "version": "0.4.1",
   "jest": {
     "coverageProvider": "v8",
     "testMatch": [