sqs-partial-batch-processor 0.4.5 → 0.5.0

package/.editorconfig

@@ -0,0 +1,12 @@
+# ~~ Generated by projen. To modify, edit .projenrc.ts and run "npx projen".
+
+root=true
+
+[*]
+end_of_line=lf
+charset=utf-8
+
+[*\.{js,ts}]
+indent_style=space
+indent_size=2
+max_line_length=160

package/README.md

@@ -1,49 +1,52 @@
 # SQS Partial Batch Processor
 
-[![npm](https://img.shields.io/npm/v/sqs-partial-batch-processor)](https://www.npmjs.com/package/sqs-partial-batch-processor)
-[![build](https://img.shields.io/github/actions/workflow/status/gammarers-aws-sdk-extensions/sqs-partial-batch-processor/build.yml?branch=main)](https://github.com/gammarers-aws-sdk-extensions/sqs-partial-batch-processor/actions/workflows/build.yml)
+[![npm version](https://img.shields.io/npm/v/sqs-partial-batch-processor?style=flat-square)](https://www.npmjs.com/package/sqs-partial-batch-processor)
+[![license](https://img.shields.io/npm/l/sqs-partial-batch-processor?style=flat-square)](https://www.npmjs.com/package/sqs-partial-batch-processor)
+[![Node.js](https://img.shields.io/node/v/sqs-partial-batch-processor?style=flat-square)](https://www.npmjs.com/package/sqs-partial-batch-processor)
+[![build](https://img.shields.io/github/actions/workflow/status/gammarers-aws-sdk-extensions/sqs-partial-batch-processor/build.yml?label=build&style=flat-square)](https://github.com/gammarers-aws-sdk-extensions/sqs-partial-batch-processor/actions/workflows/build.yml)
 
 A small TypeScript helper for AWS Lambda SQS triggers using **partial batch responses** (`SQSBatchResponse.batchItemFailures`).
 You supply per-record async logic; the library handles looping, per-record error boundaries, and the response shape.
 
-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).
+- Implements the Lambda SQS partial batch response pattern, so only failed messages are retried.
+- Keeps a failure inside the record that raised it.
 - 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.
+- Marks a record failed by throwing from the per-record function passed to `processPartialBatch`.
+- Accepts bounded concurrency (`concurrency`), an error hook (`onRecordError`), and custom `itemIdentifier` mapping (`mapMessageId`) through `ProcessPartialBatchOptions`.
+- Throws `SqsPartialBatchProcessorRangeError` or `SqsPartialBatchProcessorTypeError` for invalid `concurrency`. Check the subclass before `SqsPartialBatchProcessorError`.
 
-## Requirements
+## How it works
+
+An SQS event source mapping invokes your Lambda function with a batch of records. Pass that event and a per-record function to `processPartialBatch`. Throw from that function to fail one record. The returned `SQSBatchResponse` lists failed records in `batchItemFailures`. Enable **Report batch item failures** on the event source mapping so SQS retries those messages and deletes the successful ones. See the [AWS Lambda SQS error handling docs](https://docs.aws.amazon.com/lambda/latest/dg/services-sqs-errorhandling.html#services-sqs-batchfailurereporting).
 
-- Node.js **20+** (runtime requirement)
-- 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)
+Your function owns message parsing, schema validation, AWS SDK clients, and retry policy. The package is published as CommonJS (`lib/index.js`) and can be imported from CommonJS or ESM.
 
 ## Installation
 
+### npm
+
 ```bash
 npm install sqs-partial-batch-processor
 ```
 
+### yarn
+
 ```bash
 yarn add sqs-partial-batch-processor
 ```
 
+### pnpm
+
 ```bash
 pnpm add sqs-partial-batch-processor
 ```
 
 ## Usage
 
+Import the public API from the package root.
+
 Throw to mark a record as failed:
 
 ```ts
@@ -57,39 +60,7 @@ export const handler = async (event: SQSEvent) =>
   });
 ```
 
-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,
-  type ProcessRecordResult,
-} from 'sqs-partial-batch-processor';
-
-export const handler = async (event: SQSEvent) =>
-  processPartialBatchWithResult(event, async (record): Promise<ProcessRecordResult> => {
-    if (record.body === '') {
-      return { ok: false };
-    }
-    return { ok: true };
-  });
-```
-
-## Options
-
-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.
-  - **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):
+`onRecordError` is a logging or metrics hook. A throw from the hook stays on that record.
 
 ```ts
 import type { SQSEvent } from 'aws-lambda';
@@ -107,7 +78,7 @@ export const handler = async (event: SQSEvent) =>
           level: 'error',
           msg: 'record failed',
           messageId: record.messageId,
-          // Do not log record.body — it may contain secrets or PII.
+          // Avoid logging record.body — it may contain secrets or personal data.
           error: error instanceof Error ? { name: error.name, message: error.message } : { message: String(error) },
         }));
       },
@@ -115,8 +86,19 @@ export const handler = async (event: SQSEvent) =>
   );
 ```
 
-- `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.
+## Options
+
+`processPartialBatch` accepts an optional `ProcessPartialBatchOptions` object.
+
+| Name | Type | Default | Description |
+| --- | --- | --- | --- |
+| `concurrency` | `number` | `1` | Maximum number of records processed in parallel. `1` runs records one at a time. A value greater than `1` uses a bounded pool, and the order of `batchItemFailures` is not guaranteed. The value must be a finite integer greater than or equal to 1. A smaller value throws `SqsPartialBatchProcessorRangeError`. Any other invalid value throws `SqsPartialBatchProcessorTypeError`. Check the subclass before `SqsPartialBatchProcessorError`. Start with `1` and raise it while watching downstream limits such as API rate limits, database pools, and Lambda reserved concurrency. |
+| `onRecordError` | `(record, error) => void` |  | Called when a record handler throws. A throw from this hook leaves that record in `batchItemFailures` and lets the other records continue. Avoid logging `record.body`. Prefer `messageId`, the `mapMessageId` result, and a sanitized error summary. When `mapMessageId` throws, `error` is that thrown value and the reported identifier is `record.messageId`. |
+| `mapMessageId` | `(record) => string` | `record.messageId` | Returns the `itemIdentifier` reported for a record. Use it to align the identifier with an application-level id, such as one stored in `messageAttributes` or the parsed payload. When this function throws, that record is reported with `record.messageId` and the remaining records are still processed. |
+
+## Requirements
+
+- Node.js `>= 20.0.0`
 
 ## License
 

package/lib/core/concurrency-predicates.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Minimum accepted `concurrency`. Also the default when the option is omitted.
+ */
+export declare const MIN_CONCURRENCY = 1;
+/**
+ * Returns whether records run one at a time.
+ *
+ * @param concurrency Validated concurrency value.
+ * @returns `true` when `concurrency` is at most {@link MIN_CONCURRENCY}.
+ */
+export declare const isSequentialConcurrency: (concurrency: number) => boolean;
+/**
+ * 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.
+ */
+export declare const hasRemainingWork: (workIndex: number | undefined) => workIndex is number;

package/lib/core/concurrency-predicates.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasRemainingWork = exports.isSequentialConcurrency = exports.MIN_CONCURRENCY = void 0;
+/**
+ * Minimum accepted `concurrency`. Also the default when the option is omitted.
+ */
+exports.MIN_CONCURRENCY = 1;
+/**
+ * Returns whether records run one at a time.
+ *
+ * @param concurrency Validated concurrency value.
+ * @returns `true` when `concurrency` is at most {@link MIN_CONCURRENCY}.
+ */
+const isSequentialConcurrency = (concurrency) => concurrency <= exports.MIN_CONCURRENCY;
+exports.isSequentialConcurrency = isSequentialConcurrency;
+/**
+ * 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;
+exports.hasRemainingWork = hasRemainingWork;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uY3VycmVuY3ktcHJlZGljYXRlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9jb3JlL2NvbmN1cnJlbmN5LXByZWRpY2F0ZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUE7O0dBRUc7QUFDVSxRQUFBLGVBQWUsR0FBRyxDQUFDLENBQUM7QUFFakM7Ozs7O0dBS0c7QUFDSSxNQUFNLHVCQUF1QixHQUFHLENBQUMsV0FBbUIsRUFBVyxFQUFFLENBQ3RFLFdBQVcsSUFBSSx1QkFBZSxDQUFDO0FBRHBCLFFBQUEsdUJBQXVCLDJCQUNIO0FBRWpDOzs7OztHQUtHO0FBQ0ksTUFBTSxnQkFBZ0IsR0FBRyxDQUFDLFNBQTZCLEVBQXVCLEVBQUUsQ0FDckYsU0FBUyxLQUFLLFNBQVMsQ0FBQztBQURiLFFBQUEsZ0JBQWdCLG9CQUNIIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBNaW5pbXVtIGFjY2VwdGVkIGBjb25jdXJyZW5jeWAuIEFsc28gdGhlIGRlZmF1bHQgd2hlbiB0aGUgb3B0aW9uIGlzIG9taXR0ZWQuXG4gKi9cbmV4cG9ydCBjb25zdCBNSU5fQ09OQ1VSUkVOQ1kgPSAxO1xuXG4vKipcbiAqIFJldHVybnMgd2hldGhlciByZWNvcmRzIHJ1biBvbmUgYXQgYSB0aW1lLlxuICpcbiAqIEBwYXJhbSBjb25jdXJyZW5jeSBWYWxpZGF0ZWQgY29uY3VycmVuY3kgdmFsdWUuXG4gKiBAcmV0dXJucyBgdHJ1ZWAgd2hlbiBgY29uY3VycmVuY3lgIGlzIGF0IG1vc3Qge0BsaW5rIE1JTl9DT05DVVJSRU5DWX0uXG4gKi9cbmV4cG9ydCBjb25zdCBpc1NlcXVlbnRpYWxDb25jdXJyZW5jeSA9IChjb25jdXJyZW5jeTogbnVtYmVyKTogYm9vbGVhbiA9PlxuICBjb25jdXJyZW5jeSA8PSBNSU5fQ09OQ1VSUkVOQ1k7XG5cbi8qKlxuICogUmV0dXJucyB3aGV0aGVyIGEgd29ya2VyIHN0aWxsIGhhcyBhbiBpbmRleCB0byBwcm9jZXNzLlxuICpcbiAqIEBwYXJhbSB3b3JrSW5kZXggVGhlIGluZGV4IGNsYWltZWQgZnJvbSB0aGUgd29yayBxdWV1ZSwgb3IgYHVuZGVmaW5lZGAgd2hlbiBlbXB0eS5cbiAqIEByZXR1cm5zIGB0cnVlYCB3aGVuIGB3b3JrSW5kZXhgIGlzIGEgcmVtYWluaW5nIGl0ZW0gaW5kZXguXG4gKi9cbmV4cG9ydCBjb25zdCBoYXNSZW1haW5pbmdXb3JrID0gKHdvcmtJbmRleDogbnVtYmVyIHwgdW5kZWZpbmVkKTogd29ya0luZGV4IGlzIG51bWJlciA9PlxuICB3b3JrSW5kZXggIT09IHVuZGVmaW5lZDtcbiJdfQ==

package/lib/core/concurrency.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Resolves and validates the `concurrency` option.
+ *
+ * @param value User-provided concurrency.
+ * @returns A validated concurrency value (defaults to {@link MIN_CONCURRENCY}).
+ * @throws {@link SqsPartialBatchProcessorRangeError} When `value` is less than {@link MIN_CONCURRENCY}.
+ * @throws {@link SqsPartialBatchProcessorTypeError} 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.
+ *
+ * An `undefined` item ends that worker. With one worker, later indexes stay unclaimed.
+ *
+ * @param items Items to process.
+ * @param concurrency Maximum parallel workers (validated integer `>= 1`).
+ * @param fn Async handler invoked for each item.
+ * @returns A promise that resolves when every claimed item has been processed.
+ */
+export declare const runWithConcurrency: <T>(items: readonly T[], concurrency: number, fn: (item: T) => Promise<void>) => Promise<void>;
+/**
+ * Runs `fn` over `items` one at a time, or through the bounded worker pool.
+ *
+ * @param items Items to process.
+ * @param concurrency User-provided concurrency. Omitted means sequential.
+ * @param fn Async handler invoked for each item.
+ * @returns A promise that resolves when every item has been processed.
+ * @throws {@link SqsPartialBatchProcessorRangeError} When `concurrency` is less than {@link MIN_CONCURRENCY}.
+ * @throws {@link SqsPartialBatchProcessorTypeError} When `concurrency` is not a finite integer.
+ */
+export declare const runAtConcurrency: <T>(items: readonly T[], concurrency: number | undefined, fn: (item: T) => Promise<void>) => Promise<void>;

package/lib/core/concurrency.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runAtConcurrency = exports.runWithConcurrency = exports.resolveConcurrency = void 0;
+const concurrency_predicates_1 = require("./concurrency-predicates");
+const errors_1 = require("./errors");
+/**
+ * Resolves and validates the `concurrency` option.
+ *
+ * @param value User-provided concurrency.
+ * @returns A validated concurrency value (defaults to {@link MIN_CONCURRENCY}).
+ * @throws {@link SqsPartialBatchProcessorRangeError} When `value` is less than {@link MIN_CONCURRENCY}.
+ * @throws {@link SqsPartialBatchProcessorTypeError} When `value` is not a finite integer.
+ */
+const resolveConcurrency = (value) => {
+    if (value === undefined) {
+        return concurrency_predicates_1.MIN_CONCURRENCY;
+    }
+    if (!Number.isFinite(value) || !Number.isInteger(value)) {
+        throw new errors_1.SqsPartialBatchProcessorTypeError('concurrency must be a finite integer');
+    }
+    if (value < concurrency_predicates_1.MIN_CONCURRENCY) {
+        throw new errors_1.SqsPartialBatchProcessorRangeError(`concurrency must be >= ${concurrency_predicates_1.MIN_CONCURRENCY}`);
+    }
+    return value;
+};
+exports.resolveConcurrency = resolveConcurrency;
+/**
+ * Runs `fn` over `items` with at most `concurrency` parallel workers.
+ * Each worker pulls the next index until none remain.
+ *
+ * An `undefined` item ends that worker. With one worker, later indexes stay unclaimed.
+ *
+ * @param items Items to process.
+ * @param concurrency Maximum parallel workers (validated integer `>= 1`).
+ * @param fn Async handler invoked for each item.
+ * @returns A promise that resolves when every claimed 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 ((0, concurrency_predicates_1.hasRemainingWork)(workIndex)) {
+                const item = items[workIndex];
+                if (item === undefined) {
+                    return;
+                }
+                await fn(item);
+                workIndex = takeNextIndex();
+            }
+        })());
+    }
+    await Promise.all(workers);
+};
+exports.runWithConcurrency = runWithConcurrency;
+/**
+ * Runs `fn` over `items` one at a time, or through the bounded worker pool.
+ *
+ * @param items Items to process.
+ * @param concurrency User-provided concurrency. Omitted means sequential.
+ * @param fn Async handler invoked for each item.
+ * @returns A promise that resolves when every item has been processed.
+ * @throws {@link SqsPartialBatchProcessorRangeError} When `concurrency` is less than {@link MIN_CONCURRENCY}.
+ * @throws {@link SqsPartialBatchProcessorTypeError} When `concurrency` is not a finite integer.
+ */
+const runAtConcurrency = async (items, concurrency, fn) => {
+    const limit = (0, exports.resolveConcurrency)(concurrency);
+    if ((0, concurrency_predicates_1.isSequentialConcurrency)(limit)) {
+        for (const item of items) {
+            await fn(item);
+        }
+        return;
+    }
+    await (0, exports.runWithConcurrency)(items, limit, fn);
+};
+exports.runAtConcurrency = runAtConcurrency;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/core/errors.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Base error for failures thrown by this package.
+ */
+export declare abstract class SqsPartialBatchProcessorError extends Error {
+    readonly name: string;
+    /**
+     * @param message Error message.
+     */
+    protected constructor(message: string);
+}
+/**
+ * Thrown when `concurrency` is less than 1.
+ */
+export declare class SqsPartialBatchProcessorRangeError extends SqsPartialBatchProcessorError {
+    readonly name: string;
+    /**
+     * @param message Error message.
+     */
+    constructor(message: string);
+}
+/**
+ * Thrown when `concurrency` is not a finite integer.
+ */
+export declare class SqsPartialBatchProcessorTypeError extends SqsPartialBatchProcessorError {
+    readonly name: string;
+    /**
+     * @param message Error message.
+     */
+    constructor(message: string);
+}

package/lib/core/errors.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SqsPartialBatchProcessorTypeError = exports.SqsPartialBatchProcessorRangeError = exports.SqsPartialBatchProcessorError = void 0;
+/**
+ * Base error for failures thrown by this package.
+ */
+class SqsPartialBatchProcessorError extends Error {
+    /**
+     * @param message Error message.
+     */
+    constructor(message) {
+        super(message);
+        this.name = 'SqsPartialBatchProcessorError';
+        Object.setPrototypeOf(this, SqsPartialBatchProcessorError.prototype);
+    }
+}
+exports.SqsPartialBatchProcessorError = SqsPartialBatchProcessorError;
+/**
+ * Thrown when `concurrency` is less than 1.
+ */
+class SqsPartialBatchProcessorRangeError extends SqsPartialBatchProcessorError {
+    /**
+     * @param message Error message.
+     */
+    constructor(message) {
+        super(message);
+        this.name = 'SqsPartialBatchProcessorRangeError';
+        Object.setPrototypeOf(this, SqsPartialBatchProcessorRangeError.prototype);
+    }
+}
+exports.SqsPartialBatchProcessorRangeError = SqsPartialBatchProcessorRangeError;
+/**
+ * Thrown when `concurrency` is not a finite integer.
+ */
+class SqsPartialBatchProcessorTypeError extends SqsPartialBatchProcessorError {
+    /**
+     * @param message Error message.
+     */
+    constructor(message) {
+        super(message);
+        this.name = 'SqsPartialBatchProcessorTypeError';
+        Object.setPrototypeOf(this, SqsPartialBatchProcessorTypeError.prototype);
+    }
+}
+exports.SqsPartialBatchProcessorTypeError = SqsPartialBatchProcessorTypeError;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/core/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaXRlbS1mYWlsdXJlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL2NvcmUvaXRlbS1mYWlsdXJlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUVBOzs7OztHQUtHO0FBQ0ksTUFBTSxXQUFXLEdBQUcsQ0FDekIsY0FBc0IsRUFDeUIsRUFBRSxDQUFDLENBQUM7SUFDbkQsY0FBYztDQUNmLENBQUMsQ0FBQztBQUpVLFFBQUEsV0FBVyxlQUlyQiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgU1FTQmF0Y2hSZXNwb25zZSB9IGZyb20gJ2F3cy1sYW1iZGEnO1xuXG4vKipcbiAqIENyZWF0ZXMgYSBzaW5nbGUgYGJhdGNoSXRlbUZhaWx1cmVzYCBlbnRyeSBmb3IgYSBmYWlsZWQgcmVjb3JkLlxuICpcbiAqIEBwYXJhbSBpdGVtSWRlbnRpZmllciBUaGUgaWRlbnRpZmllciByZXBvcnRlZCBiYWNrIHRvIExhbWJkYS5cbiAqIEByZXR1cm5zIEFuIG9iamVjdCBzdWl0YWJsZSBmb3Ige0BsaW5rIFNRU0JhdGNoUmVzcG9uc2UuYmF0Y2hJdGVtRmFpbHVyZXN9LlxuICovXG5leHBvcnQgY29uc3QgaXRlbUZhaWx1cmUgPSAoXG4gIGl0ZW1JZGVudGlmaWVyOiBzdHJpbmcsXG4pOiBTUVNCYXRjaFJlc3BvbnNlWydiYXRjaEl0ZW1GYWlsdXJlcyddW251bWJlcl0gPT4gKHtcbiAgaXRlbUlkZW50aWZpZXIsXG59KTtcbiJdfQ==

package/lib/core/report-record-failure.d.ts

@@ -0,0 +1,16 @@
+import type { SQSBatchResponse, SQSRecord } from 'aws-lambda';
+import type { ProcessPartialBatchOptions } from './types';
+/**
+ * Reports one failed record inside the per-record boundary.
+ *
+ * Invokes `onRecordError` when set. A throw from the hook is caught here so
+ * the processor promise still resolves and other records keep running.
+ * The resolved `itemIdentifier` is always appended to `batchItemFailures`.
+ *
+ * @param batchItemFailures Failure list for the current batch.
+ * @param record The SQS record that failed.
+ * @param itemIdentifier Identifier already resolved for this record.
+ * @param error The failure passed to `onRecordError`.
+ * @param onRecordError Optional per-record error hook.
+ */
+export declare const reportRecordFailure: (batchItemFailures: SQSBatchResponse["batchItemFailures"], record: SQSRecord, itemIdentifier: string, error: unknown, onRecordError: ProcessPartialBatchOptions["onRecordError"]) => void;

package/lib/core/report-record-failure.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reportRecordFailure = void 0;
+const item_failure_1 = require("./item-failure");
+/**
+ * Reports one failed record inside the per-record boundary.
+ *
+ * Invokes `onRecordError` when set. A throw from the hook is caught here so
+ * the processor promise still resolves and other records keep running.
+ * The resolved `itemIdentifier` is always appended to `batchItemFailures`.
+ *
+ * @param batchItemFailures Failure list for the current batch.
+ * @param record The SQS record that failed.
+ * @param itemIdentifier Identifier already resolved for this record.
+ * @param error The failure passed to `onRecordError`.
+ * @param onRecordError Optional per-record error hook.
+ */
+const reportRecordFailure = (batchItemFailures, record, itemIdentifier, error, onRecordError) => {
+    try {
+        onRecordError?.(record, error);
+    }
+    catch {
+        // Hook failures stay inside this record. The item is still reported below.
+    }
+    batchItemFailures.push((0, item_failure_1.itemFailure)(itemIdentifier));
+};
+exports.reportRecordFailure = reportRecordFailure;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/{types/index.d.ts → core/types.d.ts}

@@ -1,17 +1,6 @@
 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}.
+ * Options for {@link processPartialBatch}.
  */
 export interface ProcessPartialBatchOptions {
     /**
@@ -21,30 +10,35 @@ export interface ProcessPartialBatchOptions {
      * - `> 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.
+     * @throws {@link SqsPartialBatchProcessorRangeError} When `concurrency` is less than 1.
+     * @throws {@link SqsPartialBatchProcessorTypeError} When `concurrency` is not a finite integer.
      */
     readonly concurrency?: number;
     /**
-     * Called when a record is treated as failed (thrown error or `{ ok: false }`).
+     * Called when a record handler throws.
      * 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.
      *
+     * A throw from this hook does not reject the processor. The record is still
+     * listed in `batchItemFailures` with the identifier already resolved for it.
+     * When `mapMessageId` throws, `error` is that thrown value and the identifier
+     * falls back to `record.messageId`.
+     *
      * @param record The failed SQS record.
-     * @param error The thrown value, or a synthesized `Error` when `{ ok: false }` was returned.
+     * @param error The value thrown by the record handler or by `mapMessageId`.
      */
     readonly onRecordError?: (record: SQSRecord, error: unknown) => void;
     /**
      * Returns the `itemIdentifier` reported in `batchItemFailures` for a record.
      * Defaults to `record.messageId` when omitted.
      *
+     * When this function throws, that record is reported with `record.messageId`
+     * and the remaining records are still processed. The thrown value is passed
+     * to `onRecordError` when the hook is set.
+     *
      * @param record The SQS record being processed.
      * @returns The identifier sent back to Lambda in `batchItemFailures`.
      */

package/lib/core/types.js

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

package/lib/index.d.ts

@@ -1,3 +1,3 @@
-export type { ProcessPartialBatchOptions, ProcessRecordResult } from './types';
-export { processPartialBatch } from './processor/process-partial-batch';
-export { processPartialBatchWithResult } from './processor/process-partial-batch-with-result';
+export type { ProcessPartialBatchOptions } from './core/types';
+export { SqsPartialBatchProcessorError, SqsPartialBatchProcessorRangeError, SqsPartialBatchProcessorTypeError, } from './core/errors';
+export { processPartialBatch } from './process-partial-batch';

package/lib/index.js

@@ -1,8 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.processPartialBatchWithResult = exports.processPartialBatch = void 0;
-var process_partial_batch_1 = require("./processor/process-partial-batch");
+exports.processPartialBatch = exports.SqsPartialBatchProcessorTypeError = exports.SqsPartialBatchProcessorRangeError = exports.SqsPartialBatchProcessorError = void 0;
+var errors_1 = require("./core/errors");
+Object.defineProperty(exports, "SqsPartialBatchProcessorError", { enumerable: true, get: function () { return errors_1.SqsPartialBatchProcessorError; } });
+Object.defineProperty(exports, "SqsPartialBatchProcessorRangeError", { enumerable: true, get: function () { return errors_1.SqsPartialBatchProcessorRangeError; } });
+Object.defineProperty(exports, "SqsPartialBatchProcessorTypeError", { enumerable: true, get: function () { return errors_1.SqsPartialBatchProcessorTypeError; } });
+var process_partial_batch_1 = require("./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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQ0Esd0NBSXVCO0FBSHJCLHVIQUFBLDZCQUE2QixPQUFBO0FBQzdCLDRIQUFBLGtDQUFrQyxPQUFBO0FBQ2xDLDJIQUFBLGlDQUFpQyxPQUFBO0FBRW5DLGlFQUE4RDtBQUFyRCw0SEFBQSxtQkFBbUIsT0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB0eXBlIHsgUHJvY2Vzc1BhcnRpYWxCYXRjaE9wdGlvbnMgfSBmcm9tICcuL2NvcmUvdHlwZXMnO1xuZXhwb3J0IHtcbiAgU3FzUGFydGlhbEJhdGNoUHJvY2Vzc29yRXJyb3IsXG4gIFNxc1BhcnRpYWxCYXRjaFByb2Nlc3NvclJhbmdlRXJyb3IsXG4gIFNxc1BhcnRpYWxCYXRjaFByb2Nlc3NvclR5cGVFcnJvcixcbn0gZnJvbSAnLi9jb3JlL2Vycm9ycyc7XG5leHBvcnQgeyBwcm9jZXNzUGFydGlhbEJhdGNoIH0gZnJvbSAnLi9wcm9jZXNzLXBhcnRpYWwtYmF0Y2gnO1xuIl19

package/lib/{processor/process-partial-batch.d.ts → process-partial-batch.d.ts}

@@ -1,14 +1,18 @@
 import type { SQSBatchResponse, SQSEvent, SQSRecord } from 'aws-lambda';
-import type { ProcessPartialBatchOptions } from '../types';
+import type { ProcessPartialBatchOptions } from './core/types';
 /**
  * Runs `processRecord` for each SQS record. Thrown errors are mapped to
  * `batchItemFailures`; successful records are not listed.
  *
+ * Throws from `processRecord`, `mapMessageId`, and `onRecordError` stay inside
+ * the record that raised them. The returned promise still resolves. When
+ * `mapMessageId` throws, that record is reported with `record.messageId`.
+ *
  * @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.
+ * @throws {@link SqsPartialBatchProcessorRangeError} When `options.concurrency` is less than 1.
+ * @throws {@link SqsPartialBatchProcessorTypeError} 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/process-partial-batch.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processPartialBatch = void 0;
+const concurrency_1 = require("./core/concurrency");
+const report_record_failure_1 = require("./core/report-record-failure");
+/**
+ * Runs `processRecord` for each SQS record. Thrown errors are mapped to
+ * `batchItemFailures`; successful records are not listed.
+ *
+ * Throws from `processRecord`, `mapMessageId`, and `onRecordError` stay inside
+ * the record that raised them. The returned promise still resolves. When
+ * `mapMessageId` throws, that record is reported with `record.messageId`.
+ *
+ * @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 {@link SqsPartialBatchProcessorRangeError} When `options.concurrency` is less than 1.
+ * @throws {@link SqsPartialBatchProcessorTypeError} When `options.concurrency` is not a finite integer.
+ */
+const processPartialBatch = async (event, processRecord, options) => {
+    const batchItemFailures = [];
+    /**
+     * Processes one record and records a batch item failure on error.
+     * Identifier resolution and the error hook stay inside this boundary.
+     *
+     * @param record The SQS record to process.
+     */
+    const handle = async (record) => {
+        let id = record.messageId;
+        try {
+            id = options?.mapMessageId?.(record) ?? record.messageId;
+            await processRecord(record);
+        }
+        catch (error) {
+            (0, report_record_failure_1.reportRecordFailure)(batchItemFailures, record, id, error, options?.onRecordError);
+        }
+    };
+    await (0, concurrency_1.runAtConcurrency)(event.Records, options?.concurrency, handle);
+    return { batchItemFailures };
+};
+exports.processPartialBatch = processPartialBatch;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHJvY2Vzcy1wYXJ0aWFsLWJhdGNoLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vc3JjL3Byb2Nlc3MtcGFydGlhbC1iYXRjaC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFDQSxvREFBc0Q7QUFDdEQsd0VBQW1FO0FBR25FOzs7Ozs7Ozs7Ozs7OztHQWNHO0FBQ0ksTUFBTSxtQkFBbUIsR0FBRyxLQUFLLEVBQ3RDLEtBQWUsRUFDZixhQUFtRCxFQUNuRCxPQUFvQyxFQUNULEVBQUU7SUFDN0IsTUFBTSxpQkFBaUIsR0FBaUMsRUFBRSxDQUFDO0lBRTNEOzs7OztPQUtHO0lBQ0gsTUFBTSxNQUFNLEdBQUcsS0FBSyxFQUFFLE1BQWlCLEVBQWlCLEVBQUU7UUFDeEQsSUFBSSxFQUFFLEdBQUcsTUFBTSxDQUFDLFNBQVMsQ0FBQztRQUUxQixJQUFJLENBQUM7WUFDSCxFQUFFLEdBQUcsT0FBTyxFQUFFLFlBQVksRUFBRSxDQUFDLE1BQU0sQ0FBQyxJQUFJLE1BQU0sQ0FBQyxTQUFTLENBQUM7WUFDekQsTUFBTSxhQUFhLENBQUMsTUFBTSxDQUFDLENBQUM7UUFDOUIsQ0FBQztRQUFDLE9BQU8sS0FBSyxFQUFFLENBQUM7WUFDZixJQUFBLDJDQUFtQixFQUFDLGlCQUFpQixFQUFFLE1BQU0sRUFBRSxFQUFFLEVBQUUsS0FBSyxFQUFFLE9BQU8sRUFBRSxhQUFhLENBQUMsQ0FBQztRQUNwRixDQUFDO0lBQ0gsQ0FBQyxDQUFDO0lBRUYsTUFBTSxJQUFBLDhCQUFnQixFQUFDLEtBQUssQ0FBQyxPQUFPLEVBQUUsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLENBQUMsQ0FBQztJQUNwRSxPQUFPLEVBQUUsaUJBQWlCLEVBQUUsQ0FBQztBQUMvQixDQUFDLENBQUM7QUExQlcsUUFBQSxtQkFBbUIsdUJBMEI5QiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgU1FTQmF0Y2hSZXNwb25zZSwgU1FTRXZlbnQsIFNRU1JlY29yZCB9IGZyb20gJ2F3cy1sYW1iZGEnO1xuaW1wb3J0IHsgcnVuQXRDb25jdXJyZW5jeSB9IGZyb20gJy4vY29yZS9jb25jdXJyZW5jeSc7XG5pbXBvcnQgeyByZXBvcnRSZWNvcmRGYWlsdXJlIH0gZnJvbSAnLi9jb3JlL3JlcG9ydC1yZWNvcmQtZmFpbHVyZSc7XG5pbXBvcnQgdHlwZSB7IFByb2Nlc3NQYXJ0aWFsQmF0Y2hPcHRpb25zIH0gZnJvbSAnLi9jb3JlL3R5cGVzJztcblxuLyoqXG4gKiBSdW5zIGBwcm9jZXNzUmVjb3JkYCBmb3IgZWFjaCBTUVMgcmVjb3JkLiBUaHJvd24gZXJyb3JzIGFyZSBtYXBwZWQgdG9cbiAqIGBiYXRjaEl0ZW1GYWlsdXJlc2A7IHN1Y2Nlc3NmdWwgcmVjb3JkcyBhcmUgbm90IGxpc3RlZC5cbiAqXG4gKiBUaHJvd3MgZnJvbSBgcHJvY2Vzc1JlY29yZGAsIGBtYXBNZXNzYWdlSWRgLCBhbmQgYG9uUmVjb3JkRXJyb3JgIHN0YXkgaW5zaWRlXG4gKiB0aGUgcmVjb3JkIHRoYXQgcmFpc2VkIHRoZW0uIFRoZSByZXR1cm5lZCBwcm9taXNlIHN0aWxsIHJlc29sdmVzLiBXaGVuXG4gKiBgbWFwTWVzc2FnZUlkYCB0aHJvd3MsIHRoYXQgcmVjb3JkIGlzIHJlcG9ydGVkIHdpdGggYHJlY29yZC5tZXNzYWdlSWRgLlxuICpcbiAqIEBwYXJhbSBldmVudCBUaGUgU1FTIExhbWJkYSBldmVudC5cbiAqIEBwYXJhbSBwcm9jZXNzUmVjb3JkIFBlci1yZWNvcmQgaGFuZGxlci4gVGhyb3cgdG8gbWFyayBvbmx5IHRoYXQgcmVjb3JkIGFzIGZhaWxlZC5cbiAqIEBwYXJhbSBvcHRpb25zIE9wdGlvbmFsIGNvbmN1cnJlbmN5LCBlcnJvciBob29rLCBhbmQgbWVzc2FnZSBpZCBtYXBwaW5nLlxuICogQHJldHVybnMgQW4ge0BsaW5rIFNRU0JhdGNoUmVzcG9uc2V9IGxpc3Rpbmcgb25seSBmYWlsZWQgYGl0ZW1JZGVudGlmaWVyYHMuXG4gKiBAdGhyb3dzIHtAbGluayBTcXNQYXJ0aWFsQmF0Y2hQcm9jZXNzb3JSYW5nZUVycm9yfSBXaGVuIGBvcHRpb25zLmNvbmN1cnJlbmN5YCBpcyBsZXNzIHRoYW4gMS5cbiAqIEB0aHJvd3Mge0BsaW5rIFNxc1BhcnRpYWxCYXRjaFByb2Nlc3NvclR5cGVFcnJvcn0gV2hlbiBgb3B0aW9ucy5jb25jdXJyZW5jeWAgaXMgbm90IGEgZmluaXRlIGludGVnZXIuXG4gKi9cbmV4cG9ydCBjb25zdCBwcm9jZXNzUGFydGlhbEJhdGNoID0gYXN5bmMgKFxuICBldmVudDogU1FTRXZlbnQsXG4gIHByb2Nlc3NSZWNvcmQ6IChyZWNvcmQ6IFNRU1JlY29yZCkgPT4gUHJvbWlzZTx2b2lkPixcbiAgb3B0aW9ucz86IFByb2Nlc3NQYXJ0aWFsQmF0Y2hPcHRpb25zLFxuKTogUHJvbWlzZTxTUVNCYXRjaFJlc3BvbnNlPiA9PiB7XG4gIGNvbnN0IGJhdGNoSXRlbUZhaWx1cmVzOiB7IGl0ZW1JZGVudGlmaWVyOiBzdHJpbmcgfVtdID0gW107XG5cbiAgLyoqXG4gICAqIFByb2Nlc3NlcyBvbmUgcmVjb3JkIGFuZCByZWNvcmRzIGEgYmF0Y2ggaXRlbSBmYWlsdXJlIG9uIGVycm9yLlxuICAgKiBJZGVudGlmaWVyIHJlc29sdXRpb24gYW5kIHRoZSBlcnJvciBob29rIHN0YXkgaW5zaWRlIHRoaXMgYm91bmRhcnkuXG4gICAqXG4gICAqIEBwYXJhbSByZWNvcmQgVGhlIFNRUyByZWNvcmQgdG8gcHJvY2Vzcy5cbiAgICovXG4gIGNvbnN0IGhhbmRsZSA9IGFzeW5jIChyZWNvcmQ6IFNRU1JlY29yZCk6IFByb21pc2U8dm9pZD4gPT4ge1xuICAgIGxldCBpZCA9IHJlY29yZC5tZXNzYWdlSWQ7XG5cbiAgICB0cnkge1xuICAgICAgaWQgPSBvcHRpb25zPy5tYXBNZXNzYWdlSWQ/LihyZWNvcmQpID8/IHJlY29yZC5tZXNzYWdlSWQ7XG4gICAgICBhd2FpdCBwcm9jZXNzUmVjb3JkKHJlY29yZCk7XG4gICAgfSBjYXRjaCAoZXJyb3IpIHtcbiAgICAgIHJlcG9ydFJlY29yZEZhaWx1cmUoYmF0Y2hJdGVtRmFpbHVyZXMsIHJlY29yZCwgaWQsIGVycm9yLCBvcHRpb25zPy5vblJlY29yZEVycm9yKTtcbiAgICB9XG4gIH07XG5cbiAgYXdhaXQgcnVuQXRDb25jdXJyZW5jeShldmVudC5SZWNvcmRzLCBvcHRpb25zPy5jb25jdXJyZW5jeSwgaGFuZGxlKTtcbiAgcmV0dXJuIHsgYmF0Y2hJdGVtRmFpbHVyZXMgfTtcbn07XG4iXX0=

package/package.json

@@ -32,6 +32,7 @@
     "organization": false
   },
   "devDependencies": {
+    "@gammarers/projen-projects": "^0.5.7",
     "@stylistic/eslint-plugin": "^2",
     "@types/jest": "^30.0.0",
     "@types/node": "^20",
@@ -73,7 +74,7 @@
   "publishConfig": {
     "access": "public"
   },
-  "version": "0.4.5",
+  "version": "0.5.0",
   "jest": {
     "coverageProvider": "v8",
     "testMatch": [

package/lib/processor/concurrency.d.ts

@@ -1,19 +0,0 @@
-/**
- * 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

@@ -1,77 +0,0 @@
-"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.js

@@ -1,14 +0,0 @@
-"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

@@ -1,18 +0,0 @@
-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

@@ -1,63 +0,0 @@
-"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.js

@@ -1,48 +0,0 @@
-"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,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

package/lib/types/index.js

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