@outbox-event-bus/dynamodb-aws-sdk-outbox 1.0.0

package/README.md

@@ -0,0 +1,469 @@
+# DynamoDB AWS SDK Outbox Adapter
+
+![npm version](https://img.shields.io/npm/v/@outbox-event-bus/dynamodb-aws-sdk-outbox?style=flat-square&color=2563eb)
+![npm downloads](https://img.shields.io/npm/dm/@outbox-event-bus/dynamodb-aws-sdk-outbox?style=flat-square&color=2563eb)
+![license](https://img.shields.io/npm/l/@outbox-event-bus/dynamodb-aws-sdk-outbox?style=flat-square&color=2563eb)
+
+> **Reliable, Serverless-First Event Storage for DynamoDB**
+
+The DynamoDB adapter for `outbox-event-bus` provides a high-performance, resilient outbox implementation designed specifically for AWS environments. It leverages DynamoDB's native scalability, TTL features, and Global Secondary Indices (GSIs) to ensure zero event loss even under intense load.
+
+---
+
+## How it Works
+
+The adapter persists events in a DynamoDB table and uses a Global Secondary Index (GSI) to efficiently track event progression.
+
+```mermaid
+graph LR
+    A[emit] --> B{DynamoDB Table}
+    B -- Pending --> C[Poller]
+    C -- Claim --> D[Processing]
+    D -- Success --> E[Completed / Removed]
+    D -- Error --> F[Retry / Failed]
+```
+
+### Why DynamoDB?
+- **Zero Connection Pools**: Unlike RDS, DynamoDB handles HTTP connections natively—perfect for AWS Lambda.
+- **Auto-Scaling**: Seamlessly scales from 0 to millions of events without managing IOPS.
+- **Fine-Grained IAM**: Security-first approach with native AWS authentication.
+
+---
+
+## Quick Start
+
+### 1. Installation
+
+```bash
+npm install @outbox-event-bus/dynamodb-aws-sdk-outbox
+```
+
+### 2. Prepare Your Table
+
+Create a DynamoDB table with an `id` partition key and a GSI for status tracking.
+
+| Component | Attribute | Type | Detail |
+| :--- | :--- | :--- | :--- |
+| **Table PK** | `id` | String | Unique Event ID |
+| **GSI PK** | `status` | String | `created`, `active`, etc. |
+| **GSI SK** | `gsiSortKey` | Number | Unix timestamp for ordering |
+
+### 3. Initialize & Start
+
+```typescript
+import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
+import { DynamoDBAwsSdkOutbox } from '@outbox-event-bus/dynamodb-aws-sdk-outbox';
+import { OutboxEventBus } from 'outbox-event-bus';
+
+const outbox = new DynamoDBAwsSdkOutbox({
+  client: new DynamoDBClient({ region: 'us-east-1' }),
+  tableName: 'my-events-table',
+  statusIndexName: 'status-gsiSortKey-index' // Name of your GSI
+});
+
+const bus = new OutboxEventBus(outbox, (error: OutboxError) => {
+  const event = error.context?.event;
+  console.error('Event failed:', event?.type, error);
+});
+
+bus.start();
+```
+
+---
+
+## Feature Highlights
+
+- **Atomic Transactions**: Emit events and update your business data in a single atomic operation.
+- **Optimistic Locking**: Guarantees "at-least-once" delivery without double-processing, even with multiple workers.
+- **Zombie Recovery**: Automatically detects and restarts events that got stuck due to Lambda timeouts or crashes.
+- **Batch Processing**: Groups event updates into efficient `BatchWriteItem` requests.
+
+---
+
+## Concurrency & Locking
+
+This adapter uses **Optimistic Locking** via Conditional Writes to ensure safe concurrent processing.
+
+-   **Atomic Claims**: The adapter uses `ConditionExpression` (e.g., `attribute_not_exists(locked_by)`) to claim events.
+-   **Multiple Workers**: You can safely run multiple instances (e.g., Lambda functions).
+-   **No Duplicates**: DynamoDB guarantees that only one worker can successfully claim a specific event.
+
+## How-to Guides
+
+### Transactional Writes (AsyncLocalStorage)
+
+The recommended way to use the outbox is with `AsyncLocalStorage`. This allows you to collect multiple database operations and an event into a single atomic transaction.
+
+```typescript
+import { TransactWriteCommand } from '@aws-sdk/lib-dynamodb';
+import { AsyncLocalStorage } from 'node:async_hooks';
+
+const als = new AsyncLocalStorage<any>();
+const outbox = new DynamoDBAwsSdkOutbox({
+  client,
+  tableName: 'events',
+  getCollector: () => als.getStore() // Link the outbox to the current store
+});
+
+async function createUser(user: any) {
+  const transactionItems: any[] = [];
+  
+  await als.run({ push: (item) => transactionItems.push(item) }, async () => {
+    // 1. Business Logic
+    transactionItems.push({ Put: { TableName: 'Users', Item: user } });
+
+    // 2. Emit Event (automatically attached to transactionItems via collector)
+    await bus.emit({ id: '...', type: 'user.created', payload: user });
+
+    // 3. Commit
+    await client.send(new TransactWriteCommand({ TransactItems: transactionItems }));
+  });
+}
+```
+
+### Manual Transaction Collection
+
+If you prefer explicit over implicit, you can pass a collection array directly.
+
+```typescript
+const items: any[] = [];
+items.push({ Put: { TableName: 'Data', Item: { id: 1 } } });
+
+// The second argument is the collector
+await bus.emit({ type: 'item.updated', payload: { id: 1 } }, items);
+
+await client.send(new TransactWriteCommand({ TransactItems: items }));
+```
+
+---
+
+## Configuration Reference
+
+### `DynamoDBAwsSdkOutboxConfig`
+
+```typescript
+interface DynamoDBAwsSdkOutboxConfig extends OutboxConfig {
+  // DynamoDB-specific options
+  client: DynamoDBClient;              // AWS SDK v3 Client instance
+  tableName: string;                   // DynamoDB table name
+  statusIndexName?: string;            // GSI name (default: 'status-gsiSortKey-index')
+  getCollector?: () => any[] | undefined; // Transaction collector getter
+  // Inherited from OutboxConfig
+  batchSize?: number;                  // Events per poll (default: 50)
+  pollIntervalMs?: number;             // Polling interval (default: 1000ms)
+  processingTimeoutMs?: number;        // Processing timeout (default: 30000ms)
+  maxRetries?: number;                 // Max retry attempts (default: 5)
+  baseBackoffMs?: number;              // Base backoff delay (default: 1000ms)
+  maxErrorBackoffMs?: number;          // Max polling error backoff (default: 30000ms)
+}
+```
+
+> [!NOTE]
+> All adapters inherit base configuration options from `OutboxConfig`. See the [API Reference](https://github.com/dunika/outbox-event-bus/blob/main/docs/API_REFERENCE.md#base-outbox-configuration) for details on inherited options.
+
+| Option | Type | Default | Description |
+| :--- | :--- | :--- | :--- |
+| `client` | `DynamoDBClient` | **Required** | AWS SDK v3 Client instance. |
+| `tableName` | `string` | **Required** | The DynamoDB table name. |
+| `statusIndexName` | `string` | `'status-gsiSortKey-index'` | The name of the GSI used for polling. |
+| `getCollector` | `() => any[] \| undefined` | - | Transaction collector getter for atomic writes. |
+| `batchSize` | `number` | `50` | Number of events to claim per poll. |
+| `pollIntervalMs` | `number` | `1000` | Delay between poll cycles. |
+| `processingTimeoutMs`| `number` | `30000` | After this time, a 'PROCESSING' event is considered stuck. |
+| `maxRetries` | `number` | `5` | Maximum attempts for a failed event. |
+| `baseBackoffMs` | `number` | `1000` | Base delay for exponential backoff. |
+| `maxErrorBackoffMs` | `number` | `30000` | Maximum backoff delay after polling errors. |
+
+---
+
+## API Reference
+
+### `DynamoDBAwsSdkOutbox`
+
+```typescript
+class DynamoDBAwsSdkOutbox implements IOutbox<any[]>
+```
+
+#### Constructor
+
+```typescript
+constructor(config: DynamoDBAwsSdkOutboxConfig)
+```
+
+Creates a new DynamoDB outbox adapter using AWS SDK v3.
+
+**Parameters:**
+- `config`: Configuration object (see [Configuration Reference](#configuration-reference))
+
+**Example:**
+```typescript
+const outbox = new DynamoDBAwsSdkOutbox({
+  client: new DynamoDBClient({ region: 'us-east-1' }),
+  tableName: 'my-events-table',
+  statusIndexName: 'status-index',
+  batchSize: 100
+});
+```
+
+---
+
+#### Methods
+
+##### `publish(events: BusEvent[], transaction?: any[]): Promise<void>`
+
+Publishes events to the outbox. If a `transaction` collector array is provided, events are added to it for atomic writes. Otherwise, events are written immediately.
+
+**Parameters:**
+- `events`: Array of events to publish
+- `transaction`: Optional collector array for TransactWriteCommand
+
+**Example:**
+```typescript
+// Direct publish
+await outbox.publish([
+  { id: '1', type: 'user.created', payload: user, occurredAt: new Date() }
+]);
+
+// With transaction collector
+const items: any[] = [];
+await outbox.publish([event], items);
+await client.send(new TransactWriteCommand({ TransactItems: items }));
+```
+
+---
+
+##### `getFailedEvents(): Promise<FailedBusEvent[]>`
+
+Retrieves up to 100 failed events, ordered by occurrence time (newest first).
+
+**Returns:** Array of `FailedBusEvent` objects with error details and retry count.
+
+**Example:**
+```typescript
+const failed = await outbox.getFailedEvents();
+for (const event of failed) {
+  console.log(`Event ${event.id} failed ${event.retryCount} times`);
+  console.log(`Last error: ${event.error}`);
+}
+```
+
+---
+
+##### `retryEvents(eventIds: string[]): Promise<void>`
+
+Resets failed events to `created` status for retry. Clears retry count, error message, and next retry timestamp.
+
+**Parameters:**
+- `eventIds`: Array of event IDs to retry
+
+**Example:**
+```typescript
+const failed = await outbox.getFailedEvents();
+await outbox.retryEvents(failed.map(e => e.id));
+```
+
+---
+
+##### `start(handler: (event: BusEvent) => Promise<void>, onError: ErrorHandler): void`
+
+Starts the polling service to process events.
+
+**Parameters:**
+- `handler`: Async function to process each event
+- `onError`: Error handler called when event processing fails
+
+**Example:**
+```typescript
+outbox.start(
+  async (event) => {
+    console.log('Processing:', event);
+    // Your event handling logic
+  },
+  (err, event) => {
+    console.error('Failed to process event:', err, event);
+  }
+);
+```
+
+---
+
+##### `stop(): Promise<void>`
+
+Stops the polling service gracefully and waits for in-flight events to complete.
+
+**Example:**
+```typescript
+await outbox.stop();
+```
+
+---
+
+## IAM Permissions
+
+Your application's IAM role needs the following permissions:
+
+```json
+{
+  "Version": "2012-10-17",
+  "Statement": [
+    {
+      "Effect": "Allow",
+      "Action": ["dynamodb:PutItem", "dynamodb:GetItem", "dynamodb:UpdateItem"],
+      "Resource": "arn:aws:dynamodb:*:*:table/YOUR_TABLE/index/YOUR_GSI"
+    },
+    {
+      "Effect": "Allow",
+      "Action": ["dynamodb:Query"],
+      "Resource": "arn:aws:dynamodb:*:*:table/YOUR_TABLE/index/YOUR_GSI"
+    }
+  ]
+}
+```
+
+---
+
+## Troubleshooting
+
+### Events Not Moving
+
+**Symptom**: Events are stuck in `created` status and never get processed.
+
+**Causes**:
+1. `statusIndexName` doesn't match the actual GSI name in DynamoDB
+2. GSI not created or still being built
+3. Polling service not started
+
+**Solution**:
+```typescript
+// 1. Verify GSI name matches
+const outbox = new DynamoDBAwsSdkOutbox({
+  client,
+  tableName: 'my-events',
+  statusIndexName: 'status-gsiSortKey-index' // Must match actual GSI name
+});
+
+// 2. Check GSI status in AWS Console or CLI
+// aws dynamodb describe-table --table-name my-events
+
+// 3. Ensure bus is started
+bus.start();
+```
+
+---
+
+### ConditionalCheckFailedException
+
+**Symptom**: Seeing `ConditionalCheckFailedException` errors in logs.
+
+**Cause**: Multiple workers trying to claim the same event simultaneously (expected behavior).
+
+**Solution**: This is **normal and expected**! The adapter uses optimistic locking to prevent duplicate processing. The error means another worker successfully claimed the event first. No action needed—the adapter handles this gracefully.
+
+---
+
+### Slow Polling / High Latency
+
+**Symptom**: Events take a long time to process after being emitted.
+
+**Causes**:
+1. Low Read Capacity Units (RCU) on the GSI
+2. Small `batchSize` setting
+3. Long `pollIntervalMs`
+
+**Solution**:
+```typescript
+// 1. Increase batch size for higher throughput
+const outbox = new DynamoDBAwsSdkOutbox({
+  client,
+  tableName: 'events',
+  batchSize: 100, // Process more events per poll (default: 50)
+  pollIntervalMs: 500 // Poll more frequently (default: 1000ms)
+});
+
+// 2. Check and increase RCU on your GSI in AWS Console
+// Recommended: Use On-Demand billing mode for auto-scaling
+```
+
+---
+
+### Duplicate Event Processing
+
+**Symptom**: Event handlers are being called multiple times for the same event.
+
+**Cause**: The outbox guarantees "at-least-once" delivery. Duplicates can occur due to:
+- Worker crashes during processing
+- Network timeouts
+- Publisher retries
+
+**Solution**: Make your event handlers **idempotent**:
+```typescript
+bus.on('order.created', async (event) => {
+  // Use event ID for deduplication
+  const existing = await db.getOrder(event.payload.orderId);
+  if (existing) {
+    console.log('Order already processed, skipping');
+    return;
+  }
+  
+  await db.createOrder(event.payload);
+});
+```
+
+---
+
+### ProvisionedThroughputExceededException
+
+**Symptom**: `ProvisionedThroughputExceededException` errors during high load.
+
+**Cause**: Write or read capacity exceeded on table or GSI.
+
+**Solution**:
+```typescript
+// Option 1: Switch to On-Demand billing mode (recommended)
+// aws dynamodb update-table --table-name events --billing-mode PAY_PER_REQUEST
+
+// Option 2: Increase provisioned capacity
+// aws dynamodb update-table --table-name events \
+//   --provisioned-throughput ReadCapacityUnits=100,WriteCapacityUnits=100
+
+// Option 3: Reduce polling frequency temporarily
+const outbox = new DynamoDBAwsSdkOutbox({
+  client,
+  tableName: 'events',
+  pollIntervalMs: 2000, // Reduce polling frequency
+  batchSize: 25 // Reduce batch size
+});
+```
+
+---
+
+### Events Stuck in active
+
+**Symptom**: Events remain in `active` status indefinitely.
+
+**Cause**: Worker crashed or Lambda timed out during processing.
+
+**Solution**: The adapter automatically recovers stuck events based on `processingTimeoutMs`. To force immediate recovery:
+
+```typescript
+// Stuck events are automatically reclaimed after processingTimeoutMs
+const outbox = new DynamoDBAwsSdkOutbox({
+  client,
+  tableName: 'events',
+  processingTimeoutMs: 30000 // Adjust based on handler complexity (default: 30s)
+});
+
+// Manual recovery: Query and reset stuck events
+const response = await client.send(new QueryCommand({
+  TableName: 'events',
+  IndexName: 'status-gsiSortKey-index',
+  KeyConditionExpression: "#status = :active AND gsiSortKey <= :now",
+  ExpressionAttributeNames: { 
+    "#status": "status"
+  },
+  ExpressionAttributeValues: {
+    ":active": { S: 'active' },
+    ":now": { N: String(Date.now()) }
+  }
+}));
+```

package/dist/index.cjs

@@ -0,0 +1,224 @@
+let _aws_sdk_client_dynamodb = require("@aws-sdk/client-dynamodb");
+let _aws_sdk_lib_dynamodb = require("@aws-sdk/lib-dynamodb");
+let outbox_event_bus = require("outbox-event-bus");
+let node_async_hooks = require("node:async_hooks");
+
+//#region src/dynamodb-aws-sdk-outbox.ts
+const DYNAMODB_TRANSACTION_LIMIT = 100;
+var DynamoDBAwsSdkOutbox = class {
+	config;
+	docClient;
+	poller;
+	constructor(config) {
+		this.config = {
+			batchSize: config.batchSize ?? 50,
+			pollIntervalMs: config.pollIntervalMs ?? 1e3,
+			maxRetries: config.maxRetries ?? 5,
+			baseBackoffMs: config.baseBackoffMs ?? 1e3,
+			processingTimeoutMs: config.processingTimeoutMs ?? 3e4,
+			maxErrorBackoffMs: config.maxErrorBackoffMs ?? 3e4,
+			tableName: config.tableName,
+			statusIndexName: config.statusIndexName ?? "status-gsiSortKey-index",
+			client: config.client,
+			getCollector: config.getCollector
+		};
+		this.docClient = _aws_sdk_lib_dynamodb.DynamoDBDocumentClient.from(config.client, { marshallOptions: { removeUndefinedValues: true } });
+		this.poller = new outbox_event_bus.PollingService({
+			pollIntervalMs: this.config.pollIntervalMs,
+			baseBackoffMs: this.config.baseBackoffMs,
+			maxErrorBackoffMs: this.config.maxErrorBackoffMs,
+			performMaintenance: () => this.recoverStuckEvents(),
+			processBatch: (handler) => this.processBatch(handler)
+		});
+	}
+	async publish(events, transaction) {
+		if (events.length === 0) return;
+		if (events.length > DYNAMODB_TRANSACTION_LIMIT) throw new outbox_event_bus.BatchSizeLimitError(DYNAMODB_TRANSACTION_LIMIT, events.length);
+		const collector = transaction ?? this.config.getCollector?.();
+		const items = events.map((event) => {
+			return { Put: {
+				TableName: this.config.tableName,
+				Item: {
+					id: event.id,
+					type: event.type,
+					payload: event.payload,
+					occurredAt: event.occurredAt.toISOString(),
+					status: outbox_event_bus.EventStatus.CREATED,
+					retryCount: 0,
+					gsiSortKey: event.occurredAt.getTime()
+				}
+			} };
+		});
+		if (collector) {
+			const itemsInCollector = collector.items?.length ?? 0;
+			if (itemsInCollector + items.length > DYNAMODB_TRANSACTION_LIMIT) throw new outbox_event_bus.BatchSizeLimitError(DYNAMODB_TRANSACTION_LIMIT, itemsInCollector + items.length);
+			for (const item of items) collector.push(item);
+		} else await this.docClient.send(new _aws_sdk_lib_dynamodb.TransactWriteCommand({ TransactItems: items }));
+	}
+	async getFailedEvents() {
+		const result = await this.docClient.send(new _aws_sdk_lib_dynamodb.QueryCommand({
+			TableName: this.config.tableName,
+			IndexName: this.config.statusIndexName,
+			KeyConditionExpression: "#status = :status",
+			ExpressionAttributeNames: { "#status": "status" },
+			ExpressionAttributeValues: { ":status": outbox_event_bus.EventStatus.FAILED },
+			Limit: 100,
+			ScanIndexForward: false
+		}));
+		if (!result.Items) return [];
+		return result.Items.map((item) => {
+			const event = {
+				id: item.id,
+				type: item.type,
+				payload: item.payload,
+				occurredAt: this.parseOccurredAt(item.occurredAt),
+				retryCount: item.retryCount || 0
+			};
+			if (item.lastError) event.error = item.lastError;
+			if (item.startedOn) event.lastAttemptAt = new Date(item.startedOn);
+			return event;
+		});
+	}
+	async retryEvents(eventIds) {
+		if (eventIds.length === 0) return;
+		await Promise.all(eventIds.map((id) => this.docClient.send(new _aws_sdk_lib_dynamodb.UpdateCommand({
+			TableName: this.config.tableName,
+			Key: { id },
+			UpdateExpression: "SET #status = :pending, retryCount = :zero, gsiSortKey = :now REMOVE lastError, nextRetryAt, startedOn",
+			ExpressionAttributeNames: { "#status": "status" },
+			ExpressionAttributeValues: {
+				":pending": outbox_event_bus.EventStatus.CREATED,
+				":zero": 0,
+				":now": Date.now()
+			}
+		}))));
+	}
+	start(handler, onError) {
+		this.poller.start(handler, onError);
+	}
+	async stop() {
+		await this.poller.stop();
+	}
+	async processBatch(handler) {
+		const now = Date.now();
+		const result = await this.docClient.send(new _aws_sdk_lib_dynamodb.QueryCommand({
+			TableName: this.config.tableName,
+			IndexName: this.config.statusIndexName,
+			KeyConditionExpression: "#status = :status AND gsiSortKey <= :now",
+			ExpressionAttributeNames: { "#status": "status" },
+			ExpressionAttributeValues: {
+				":status": outbox_event_bus.EventStatus.CREATED,
+				":now": now
+			},
+			Limit: this.config.batchSize
+		}));
+		if (!result.Items || result.Items.length === 0) return;
+		for (const item of result.Items) {
+			const event = {
+				id: item.id,
+				type: item.type,
+				payload: item.payload,
+				occurredAt: this.parseOccurredAt(item.occurredAt)
+			};
+			try {
+				await this.markEventAsProcessing(item.id, now);
+				await handler(event);
+				await this.markEventAsCompleted(event.id);
+			} catch (error) {
+				if (error instanceof _aws_sdk_client_dynamodb.ConditionalCheckFailedException) continue;
+				const newRetryCount = (item.retryCount || 0) + 1;
+				(0, outbox_event_bus.reportEventError)(this.poller.onError, error, event, newRetryCount, this.config.maxRetries);
+				await this.markEventAsFailed(item.id, newRetryCount, error);
+			}
+		}
+	}
+	parseOccurredAt(occurredAt) {
+		if (occurredAt instanceof Date) return occurredAt;
+		if (typeof occurredAt === "string") return new Date(occurredAt);
+		return /* @__PURE__ */ new Date();
+	}
+	async markEventAsProcessing(id, now) {
+		await this.docClient.send(new _aws_sdk_lib_dynamodb.UpdateCommand({
+			TableName: this.config.tableName,
+			Key: { id },
+			UpdateExpression: "SET #status = :processing, gsiSortKey = :timeoutAt, startedOn = :now",
+			ExpressionAttributeNames: { "#status": "status" },
+			ExpressionAttributeValues: {
+				":processing": outbox_event_bus.EventStatus.ACTIVE,
+				":timeoutAt": now + this.config.processingTimeoutMs,
+				":now": now
+			}
+		}));
+	}
+	async markEventAsCompleted(id) {
+		await this.docClient.send(new _aws_sdk_lib_dynamodb.UpdateCommand({
+			TableName: this.config.tableName,
+			Key: { id },
+			UpdateExpression: "SET #status = :completed, completedOn = :now REMOVE gsiSortKey",
+			ExpressionAttributeNames: { "#status": "status" },
+			ExpressionAttributeValues: {
+				":completed": outbox_event_bus.EventStatus.COMPLETED,
+				":now": Date.now()
+			}
+		}));
+	}
+	async markEventAsFailed(id, retryCount, error) {
+		const isFinalFailure = retryCount >= this.config.maxRetries;
+		const status = isFinalFailure ? outbox_event_bus.EventStatus.FAILED : outbox_event_bus.EventStatus.CREATED;
+		const errorMsg = (0, outbox_event_bus.formatErrorMessage)(error);
+		const now = Date.now();
+		const updateExpression = isFinalFailure ? "SET #status = :status, retryCount = :rc, lastError = :err, nextRetryAt = :now REMOVE gsiSortKey" : "SET #status = :status, retryCount = :rc, lastError = :err, gsiSortKey = :nextAttempt";
+		const expressionAttributeValues = {
+			":status": status,
+			":rc": retryCount,
+			":err": errorMsg
+		};
+		if (isFinalFailure) expressionAttributeValues[":now"] = now;
+		else expressionAttributeValues[":nextAttempt"] = now + this.poller.calculateBackoff(retryCount);
+		await this.docClient.send(new _aws_sdk_lib_dynamodb.UpdateCommand({
+			TableName: this.config.tableName,
+			Key: { id },
+			UpdateExpression: updateExpression,
+			ExpressionAttributeNames: { "#status": "status" },
+			ExpressionAttributeValues: expressionAttributeValues
+		}));
+	}
+	async recoverStuckEvents() {
+		const now = Date.now();
+		const result = await this.docClient.send(new _aws_sdk_lib_dynamodb.QueryCommand({
+			TableName: this.config.tableName,
+			IndexName: this.config.statusIndexName,
+			KeyConditionExpression: "#status = :status AND gsiSortKey <= :now",
+			ExpressionAttributeNames: { "#status": "status" },
+			ExpressionAttributeValues: {
+				":status": outbox_event_bus.EventStatus.ACTIVE,
+				":now": now
+			}
+		}));
+		if (result.Items && result.Items.length > 0) await Promise.all(result.Items.map((item) => this.markEventAsFailed(item.id, (item.retryCount || 0) + 1, "Processing timeout")));
+	}
+};
+
+//#endregion
+//#region src/transaction-storage.ts
+const dynamodbAwsSdkTransactionStorage = new node_async_hooks.AsyncLocalStorage();
+async function withDynamoDBAwsSdkTransaction(fn) {
+	const items = [];
+	const collector = {
+		push: (item) => items.push(item),
+		get items() {
+			return items;
+		}
+	};
+	return dynamodbAwsSdkTransactionStorage.run(collector, () => fn(collector));
+}
+function getDynamoDBAwsSdkCollector() {
+	return () => dynamodbAwsSdkTransactionStorage.getStore();
+}
+
+//#endregion
+exports.DynamoDBAwsSdkOutbox = DynamoDBAwsSdkOutbox;
+exports.dynamodbAwsSdkTransactionStorage = dynamodbAwsSdkTransactionStorage;
+exports.getDynamoDBAwsSdkCollector = getDynamoDBAwsSdkCollector;
+exports.withDynamoDBAwsSdkTransaction = withDynamoDBAwsSdkTransaction;
+//# sourceMappingURL=index.cjs.map