@message-queue-toolkit/sqs 22.6.0 → 22.7.0

package/README.md

@@ -2400,6 +2400,225 @@ import { SQS_RESOURCE_CURRENT_QUEUE } from '@message-queue-toolkit/sqs'
 
 The library is designed to be testable:
 
+### TestSqsPublisher - Testing Utility for Invalid Messages
+
+`TestSqsPublisher` is a specialized testing utility that allows you to publish arbitrary messages to SQS queues **without any validation**. This is useful for:
+
+- Testing error handling with invalid/malformed messages
+- Testing edge cases without schema constraints
+- Integration testing with arbitrary test data
+- Verifying consumer behavior with non-standard messages
+
+**⚠️ IMPORTANT: This is a testing utility only. Do not use in production code.**
+
+#### Features
+
+- ✅ **No validation** - Bypasses Zod schemas, deduplication, and payload offloading
+- ✅ **Flexible queue targeting** - Accepts `queueUrl`, `queueName`, consumer, or publisher instances
+- ✅ **FIFO support** - Works with both standard and FIFO queues
+- ✅ **Simple API** - One publisher instance can publish to any queue
+
+#### Basic Usage
+
+```typescript
+import { TestSqsPublisher } from '@message-queue-toolkit/sqs'
+import { SQSClient } from '@aws-sdk/client-sqs'
+
+const sqsClient = new SQSClient({ region: 'us-east-1' })
+const testPublisher = new TestSqsPublisher(sqsClient)
+
+// Publish to a queue by URL
+await testPublisher.publish(
+  { any: 'data', without: 'validation' },
+  { queueUrl: 'https://sqs.us-east-1.amazonaws.com/123456789012/my-queue' }
+)
+
+// Publish to a queue by name
+await testPublisher.publish(
+  { incomplete: 'message' },
+  { queueName: 'my-queue' }
+)
+```
+
+#### Publishing to Consumer's Queue
+
+Extract the queue URL from an existing consumer:
+
+```typescript
+const consumer = new UserEventsConsumer(sqsClient, userService)
+await consumer.init()
+
+const testPublisher = new TestSqsPublisher(sqsClient)
+
+// Publish directly to the consumer's queue
+await testPublisher.publish(
+  {
+    invalid: 'schema',
+    missing: 'required fields',
+  },
+  { consumer }
+)
+```
+
+#### Publishing to Publisher's Queue
+
+Extract the queue URL from an existing publisher:
+
+```typescript
+const regularPublisher = new UserEventsPublisher(sqsClient)
+await regularPublisher.init()
+
+const testPublisher = new TestSqsPublisher(sqsClient)
+
+// Publish to the same queue without validation
+await testPublisher.publish(
+  { totally: 'arbitrary', data: true },
+  { publisher: regularPublisher }
+)
+```
+
+#### Testing Invalid Message Handling
+
+```typescript
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+
+describe('Consumer Error Handling', () => {
+  let sqsClient: SQSClient
+  let consumer: UserEventsConsumer
+  let testPublisher: TestSqsPublisher
+
+  beforeEach(async () => {
+    sqsClient = new SQSClient({
+      endpoint: 'http://localhost:4566',  // LocalStack
+      region: 'us-east-1',
+    })
+
+    consumer = new UserEventsConsumer(sqsClient, userService, {
+      handlerSpy: true,
+    })
+    await consumer.start()
+
+    testPublisher = new TestSqsPublisher(sqsClient)
+  })
+
+  afterEach(async () => {
+    await consumer.close()
+  })
+
+  it('handles message with missing required fields', async () => {
+    // Publish invalid message
+    await testPublisher.publish(
+      {
+        // Missing: id, messageType, timestamp
+        someData: 'incomplete',
+      },
+      { consumer }  // Publish to consumer's queue
+    )
+
+    // Wait briefly for processing
+    await new Promise(resolve => setTimeout(resolve, 1000))
+
+    // Verify consumer handled the error gracefully
+    // (e.g., sent to DLQ, logged error, etc.)
+    expect(errorLogger.errors).toContainEqual(
+      expect.objectContaining({
+        message: expect.stringContaining('Invalid message format'),
+      })
+    )
+  })
+
+  it('handles message with wrong data types', async () => {
+    await testPublisher.publish(
+      {
+        id: 123,  // Should be string
+        messageType: null,  // Should be string literal
+        userId: ['not', 'a', 'string'],  // Should be string
+      },
+      { consumer }
+    )
+
+    await new Promise(resolve => setTimeout(resolve, 1000))
+
+    // Verify error handling
+    expect(validationErrors).toHaveLength(1)
+  })
+
+  it('handles completely malformed messages', async () => {
+    await testPublisher.publish(
+      {
+        totally: 'random',
+        nested: { deeply: { data: [1, 2, 3] } },
+        unexpected: true,
+      },
+      { consumer }
+    )
+
+    await new Promise(resolve => setTimeout(resolve, 1000))
+
+    // Message should be rejected and sent to DLQ
+    expect(dlqMessages).toHaveLength(1)
+  })
+})
+```
+
+#### FIFO Queue Testing
+
+```typescript
+it('publishes to FIFO queue with MessageGroupId', async () => {
+  const testPublisher = new TestSqsPublisher(sqsClient)
+
+  await testPublisher.publish(
+    { test: 'fifo-message' },
+    {
+      queueUrl: 'https://sqs.us-east-1.amazonaws.com/123456789012/my-queue.fifo',
+      MessageGroupId: 'test-group',
+      MessageDeduplicationId: 'unique-id-123',
+    }
+  )
+
+  // Verify message was published
+  const result = await consumer.handlerSpy.waitForMessage(
+    (msg) => msg.test === 'fifo-message',
+    'consumed'
+  )
+
+  expect(result).toBeDefined()
+})
+```
+
+#### API Reference
+
+```typescript
+class TestSqsPublisher {
+  constructor(sqsClient: SQSClient)
+
+  /**
+   * Publish a message to an SQS queue without validation
+   * @param payload - Any JSON-serializable object
+   * @param options - Queue targeting and FIFO options
+   */
+  async publish(
+    payload: any,
+    options:
+      | { queueUrl: string; MessageGroupId?: string; MessageDeduplicationId?: string }
+      | { queueName: string; MessageGroupId?: string; MessageDeduplicationId?: string }
+      | { consumer: AbstractSqsConsumer<any, any, any, any, any>; MessageGroupId?: string; MessageDeduplicationId?: string }
+      | { publisher: AbstractSqsPublisher<any>; MessageGroupId?: string; MessageDeduplicationId?: string }
+  ): Promise<void>
+}
+```
+
+**When to use `TestSqsPublisher`:**
+- ✅ Testing error handling and edge cases
+- ✅ Integration tests with invalid data
+- ✅ Testing consumer resilience
+- ✅ Debugging message processing issues
+
+**When NOT to use `TestSqsPublisher`:**
+- ❌ Production code
+- ❌ Publishing valid messages (use regular publishers)
+- ❌ Messages that need validation, deduplication, or offloading
+
 ### Integration Tests
 
 ```typescript

package/dist/fakes/TestSqsPublisher.d.ts

@@ -0,0 +1,127 @@
+import type { SQSClient } from '@aws-sdk/client-sqs';
+import type { AbstractSqsConsumer } from '../sqs/AbstractSqsConsumer.ts';
+import type { AbstractSqsPublisher } from '../sqs/AbstractSqsPublisher.ts';
+/**
+ * Options for publishing messages with TestSqsPublisher.
+ * Supports multiple mutually exclusive ways to specify the target queue.
+ */
+export type TestSqsPublishOptions = {
+    queueUrl: string;
+    queueName?: never;
+    consumer?: never;
+    publisher?: never;
+    MessageGroupId?: string;
+    MessageDeduplicationId?: string;
+} | {
+    queueName: string;
+    queueUrl?: never;
+    consumer?: never;
+    publisher?: never;
+    MessageGroupId?: string;
+    MessageDeduplicationId?: string;
+} | {
+    consumer: AbstractSqsConsumer<any, any, any, any, any>;
+    queueUrl?: never;
+    queueName?: never;
+    publisher?: never;
+    MessageGroupId?: string;
+    MessageDeduplicationId?: string;
+} | {
+    publisher: AbstractSqsPublisher<any>;
+    queueUrl?: never;
+    queueName?: never;
+    consumer?: never;
+    MessageGroupId?: string;
+    MessageDeduplicationId?: string;
+};
+/**
+ * TestSqsPublisher - A testing utility for publishing arbitrary messages to SQS queues without validation.
+ *
+ * This publisher bypasses all message validation, schema checking, deduplication, and payload offloading
+ * to enable testing edge cases, invalid messages, and integration scenarios.
+ *
+ * **IMPORTANT: This is a testing utility only. Do not use in production code.**
+ *
+ * Features:
+ * - Publish any JSON-serializable payload to any SQS queue
+ * - No Zod schema validation
+ * - No message deduplication
+ * - No payload offloading
+ * - Accept queueUrl string or consumer/publisher instance per publish call
+ * - Automatically resolve queueUrl from consumer/publisher
+ * - Support FIFO queue options (MessageGroupId, MessageDeduplicationId)
+ *
+ * @example
+ * ```typescript
+ * // Create a single publisher for all queues
+ * const publisher = new TestSqsPublisher(sqsClient)
+ *
+ * // Publish to different queues
+ * await publisher.publish({ any: 'data' }, { queueUrl: 'https://sqs...' })
+ * await publisher.publish({ test: 'message' }, { queueName: 'my-queue' })
+ * await publisher.publish({ test: 'message' }, { consumer: myConsumer })
+ * await publisher.publish({ other: 'data' }, { publisher: myPublisher })
+ *
+ * // FIFO queue with options
+ * await publisher.publish(
+ *   { test: 'message' },
+ *   {
+ *     queueUrl: 'https://sqs.../my-queue.fifo',
+ *     MessageGroupId: 'group1',
+ *     MessageDeduplicationId: 'unique-id'
+ *   }
+ * )
+ * ```
+ */
+export declare class TestSqsPublisher {
+    private readonly sqsClient;
+    /**
+     * Creates a new TestSqsPublisher instance.
+     *
+     * @param sqsClient - AWS SQS client instance
+     */
+    constructor(sqsClient: SQSClient);
+    /**
+     * Publishes a message to an SQS queue without any validation.
+     *
+     * @param payload - Any JSON-serializable object to publish
+     * @param options - Queue and message options
+     * @param options.queueUrl - Direct queue URL (mutually exclusive with queueName/consumer/publisher)
+     * @param options.queueName - Queue name to resolve to URL (mutually exclusive with queueUrl/consumer/publisher)
+     * @param options.consumer - Consumer instance to extract queue URL from (mutually exclusive with queueUrl/queueName/publisher)
+     * @param options.publisher - Publisher instance to extract queue URL from (mutually exclusive with queueUrl/queueName/consumer)
+     * @param options.MessageGroupId - Required for FIFO queues (queue name ends with .fifo)
+     * @param options.MessageDeduplicationId - Optional deduplication ID for FIFO queues
+     *
+     * @returns Promise that resolves when message is published
+     * @throws {Error} If none of queueUrl/queueName/consumer/publisher is provided
+     * @throws {Error} If consumer/publisher has not been initialized (no queueUrl available)
+     * @throws {Error} If SQS publish fails
+     *
+     * @example
+     * ```typescript
+     * // Using with a queue URL
+     * await publisher.publish({ test: 'data' }, { queueUrl: 'https://sqs...' })
+     *
+     * // Using with a queue name
+     * await publisher.publish({ test: 'data' }, { queueName: 'my-queue' })
+     *
+     * // Using with a consumer
+     * await publisher.publish({ test: 'data' }, { consumer: myConsumer })
+     *
+     * // Using with a publisher
+     * await publisher.publish({ test: 'data' }, { publisher: myPublisher })
+     *
+     * // FIFO queue
+     * await publisher.publish(
+     *   { test: 'data' },
+     *   {
+     *     queueUrl: 'https://sqs.../queue.fifo',
+     *     MessageGroupId: 'group1',
+     *     MessageDeduplicationId: 'unique-id'
+     *   }
+     * )
+     * ```
+     */
+    publish(payload: unknown, options: TestSqsPublishOptions): Promise<void>;
+}

package/dist/fakes/TestSqsPublisher.js

@@ -0,0 +1,137 @@
+import { SendMessageCommand } from '@aws-sdk/client-sqs';
+import { getQueueUrl } from "../utils/sqsUtils.js";
+/**
+ * TestSqsPublisher - A testing utility for publishing arbitrary messages to SQS queues without validation.
+ *
+ * This publisher bypasses all message validation, schema checking, deduplication, and payload offloading
+ * to enable testing edge cases, invalid messages, and integration scenarios.
+ *
+ * **IMPORTANT: This is a testing utility only. Do not use in production code.**
+ *
+ * Features:
+ * - Publish any JSON-serializable payload to any SQS queue
+ * - No Zod schema validation
+ * - No message deduplication
+ * - No payload offloading
+ * - Accept queueUrl string or consumer/publisher instance per publish call
+ * - Automatically resolve queueUrl from consumer/publisher
+ * - Support FIFO queue options (MessageGroupId, MessageDeduplicationId)
+ *
+ * @example
+ * ```typescript
+ * // Create a single publisher for all queues
+ * const publisher = new TestSqsPublisher(sqsClient)
+ *
+ * // Publish to different queues
+ * await publisher.publish({ any: 'data' }, { queueUrl: 'https://sqs...' })
+ * await publisher.publish({ test: 'message' }, { queueName: 'my-queue' })
+ * await publisher.publish({ test: 'message' }, { consumer: myConsumer })
+ * await publisher.publish({ other: 'data' }, { publisher: myPublisher })
+ *
+ * // FIFO queue with options
+ * await publisher.publish(
+ *   { test: 'message' },
+ *   {
+ *     queueUrl: 'https://sqs.../my-queue.fifo',
+ *     MessageGroupId: 'group1',
+ *     MessageDeduplicationId: 'unique-id'
+ *   }
+ * )
+ * ```
+ */
+export class TestSqsPublisher {
+    sqsClient;
+    /**
+     * Creates a new TestSqsPublisher instance.
+     *
+     * @param sqsClient - AWS SQS client instance
+     */
+    constructor(sqsClient) {
+        this.sqsClient = sqsClient;
+    }
+    /**
+     * Publishes a message to an SQS queue without any validation.
+     *
+     * @param payload - Any JSON-serializable object to publish
+     * @param options - Queue and message options
+     * @param options.queueUrl - Direct queue URL (mutually exclusive with queueName/consumer/publisher)
+     * @param options.queueName - Queue name to resolve to URL (mutually exclusive with queueUrl/consumer/publisher)
+     * @param options.consumer - Consumer instance to extract queue URL from (mutually exclusive with queueUrl/queueName/publisher)
+     * @param options.publisher - Publisher instance to extract queue URL from (mutually exclusive with queueUrl/queueName/consumer)
+     * @param options.MessageGroupId - Required for FIFO queues (queue name ends with .fifo)
+     * @param options.MessageDeduplicationId - Optional deduplication ID for FIFO queues
+     *
+     * @returns Promise that resolves when message is published
+     * @throws {Error} If none of queueUrl/queueName/consumer/publisher is provided
+     * @throws {Error} If consumer/publisher has not been initialized (no queueUrl available)
+     * @throws {Error} If SQS publish fails
+     *
+     * @example
+     * ```typescript
+     * // Using with a queue URL
+     * await publisher.publish({ test: 'data' }, { queueUrl: 'https://sqs...' })
+     *
+     * // Using with a queue name
+     * await publisher.publish({ test: 'data' }, { queueName: 'my-queue' })
+     *
+     * // Using with a consumer
+     * await publisher.publish({ test: 'data' }, { consumer: myConsumer })
+     *
+     * // Using with a publisher
+     * await publisher.publish({ test: 'data' }, { publisher: myPublisher })
+     *
+     * // FIFO queue
+     * await publisher.publish(
+     *   { test: 'data' },
+     *   {
+     *     queueUrl: 'https://sqs.../queue.fifo',
+     *     MessageGroupId: 'group1',
+     *     MessageDeduplicationId: 'unique-id'
+     *   }
+     * )
+     * ```
+     */
+    async publish(payload, options) {
+        let queueUrl;
+        if (options.queueUrl) {
+            queueUrl = options.queueUrl;
+        }
+        else if (options.queueName) {
+            // Resolve queue name to URL
+            const result = await getQueueUrl(this.sqsClient, options.queueName);
+            if (result.error) {
+                throw result.error;
+            }
+            queueUrl = result.result;
+        }
+        else if (options.consumer) {
+            // Extract queueUrl from consumer
+            // @ts-expect-error - Accessing protected property for testing purposes
+            const consumerQueueUrl = options.consumer.queueUrl;
+            if (!consumerQueueUrl) {
+                throw new Error('Consumer has not been initialized. Call consumer.init() before passing it to TestSqsPublisher.publish().');
+            }
+            queueUrl = consumerQueueUrl;
+        }
+        else if (options.publisher) {
+            // Extract queueUrl from publisher
+            // @ts-expect-error - Accessing protected property for testing purposes
+            const publisherQueueUrl = options.publisher.queueUrl;
+            if (!publisherQueueUrl) {
+                throw new Error('Publisher has not been initialized. Call publisher.init() or publisher.publish() before passing it to TestSqsPublisher.publish().');
+            }
+            queueUrl = publisherQueueUrl;
+        }
+        else {
+            throw new Error('Either queueUrl, queueName, consumer, or publisher must be provided in options');
+        }
+        const command = new SendMessageCommand({
+            QueueUrl: queueUrl,
+            MessageBody: JSON.stringify(payload),
+            MessageGroupId: options.MessageGroupId,
+            MessageDeduplicationId: options.MessageDeduplicationId,
+        });
+        await this.sqsClient.send(command);
+    }
+}
+//# sourceMappingURL=TestSqsPublisher.js.map

package/dist/fakes/TestSqsPublisher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"TestSqsPublisher.js","sourceRoot":"","sources":["../../lib/fakes/TestSqsPublisher.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAA;AAIxD,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AAoDlD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,MAAM,OAAO,gBAAgB;IACV,SAAS,CAAW;IAErC;;;;OAIG;IACH,YAAY,SAAoB;QAC9B,IAAI,CAAC,SAAS,GAAG,SAAS,CAAA;IAC5B,CAAC;IAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAyCG;IACH,KAAK,CAAC,OAAO,CAAC,OAAgB,EAAE,OAA8B;QAC5D,IAAI,QAAgB,CAAA;QAEpB,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC;YACrB,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAA;QAC7B,CAAC;aAAM,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;YAC7B,4BAA4B;YAC5B,MAAM,MAAM,GAAG,MAAM,WAAW,CAAC,IAAI,CAAC,SAAS,EAAE,OAAO,CAAC,SAAS,CAAC,CAAA;YACnE,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC;gBACjB,MAAM,MAAM,CAAC,KAAK,CAAA;YACpB,CAAC;YACD,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAA;QAC1B,CAAC;aAAM,IAAI,OAAO,CAAC,QAAQ,EAAE,CAAC;YAC5B,iCAAiC;YACjC,uEAAuE;YACvE,MAAM,gBAAgB,GAAG,OAAO,CAAC,QAAQ,CAAC,QAA8B,CAAA;YACxE,IAAI,CAAC,gBAAgB,EAAE,CAAC;gBACtB,MAAM,IAAI,KAAK,CACb,0GAA0G,CAC3G,CAAA;YACH,CAAC;YACD,QAAQ,GAAG,gBAAgB,CAAA;QAC7B,CAAC;aAAM,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC;YAC7B,kCAAkC;YAClC,uEAAuE;YACvE,MAAM,iBAAiB,GAAG,OAAO,CAAC,SAAS,CAAC,QAA8B,CAAA;YAC1E,IAAI,CAAC,iBAAiB,EAAE,CAAC;gBACvB,MAAM,IAAI,KAAK,CACb,mIAAmI,CACpI,CAAA;YACH,CAAC;YACD,QAAQ,GAAG,iBAAiB,CAAA;QAC9B,CAAC;aAAM,CAAC;YACN,MAAM,IAAI,KAAK,CACb,gFAAgF,CACjF,CAAA;QACH,CAAC;QAED,MAAM,OAAO,GAAG,IAAI,kBAAkB,CAAC;YACrC,QAAQ,EAAE,QAAQ;YAClB,WAAW,EAAE,IAAI,CAAC,SAAS,CAAC,OAAO,CAAC;YACpC,cAAc,EAAE,OAAO,CAAC,cAAc;YACtC,sBAAsB,EAAE,OAAO,CAAC,sBAAsB;SACvD,CAAC,CAAA;QAEF,MAAM,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,OAAO,CAAC,CAAA;IACpC,CAAC;CACF"}

package/dist/index.d.ts

@@ -1,5 +1,6 @@
 export { SqsConsumerErrorResolver } from './errors/SqsConsumerErrorResolver.ts';
 export { FakeConsumerErrorResolver } from './fakes/FakeConsumerErrorResolver.ts';
+export { TestSqsPublisher, type TestSqsPublishOptions } from './fakes/TestSqsPublisher.ts';
 export type { SQSConsumerDependencies, SQSConsumerOptions } from './sqs/AbstractSqsConsumer.ts';
 export { AbstractSqsConsumer } from './sqs/AbstractSqsConsumer.ts';
 export type { SQSMessageOptions, SQSPublisherOptions } from './sqs/AbstractSqsPublisher.ts';

package/dist/index.js

@@ -1,5 +1,6 @@
 export { SqsConsumerErrorResolver } from "./errors/SqsConsumerErrorResolver.js";
 export { FakeConsumerErrorResolver } from "./fakes/FakeConsumerErrorResolver.js";
+export { TestSqsPublisher } from "./fakes/TestSqsPublisher.js";
 export { AbstractSqsConsumer } from "./sqs/AbstractSqsConsumer.js";
 export { AbstractSqsPublisher, OFFLOADED_PAYLOAD_SIZE_ATTRIBUTE, } from "./sqs/AbstractSqsPublisher.js";
 export { SQS_MESSAGE_MAX_SIZE, SQS_RESOURCE_ANY, SQS_RESOURCE_CURRENT_QUEUE, } from "./sqs/AbstractSqsService.js";

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../lib/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,sCAAsC,CAAA;AAC/E,OAAO,EAAE,yBAAyB,EAAE,MAAM,sCAAsC,CAAA;AAEhF,OAAO,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAA;AAGlE,OAAO,EACL,oBAAoB,EACpB,gCAAgC,GACjC,MAAM,+BAA+B,CAAA;AACtC,OAAO,EAEL,oBAAoB,EACpB,gBAAgB,EAChB,0BAA0B,GAO3B,MAAM,6BAA6B,CAAA;AAEpC,OAAO,EACL,uBAAuB,EACvB,wBAAwB,EACxB,wBAAwB,GAGzB,MAAM,qCAAqC,CAAA;AAC5C,OAAO,EAAE,gCAAgC,EAAE,MAAM,yBAAyB,CAAA;AAC1E,OAAO,EACL,kCAAkC,EAClC,sBAAsB,EACtB,sBAAsB,GACvB,MAAM,8BAA8B,CAAA;AACrC,OAAO,EAAE,SAAS,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAA;AACxE,OAAO,EAAE,qBAAqB,EAAE,MAAM,mCAAmC,CAAA;AACzE,OAAO,EACL,WAAW,EACX,4BAA4B,EAC5B,WAAW,EACX,eAAe,EACf,kBAAkB,EAClB,WAAW,EACX,eAAe,EACf,gCAAgC,EAChC,8BAA8B,EAC9B,qBAAqB,GACtB,MAAM,qBAAqB,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../lib/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,sCAAsC,CAAA;AAC/E,OAAO,EAAE,yBAAyB,EAAE,MAAM,sCAAsC,CAAA;AAChF,OAAO,EAAE,gBAAgB,EAA8B,MAAM,6BAA6B,CAAA;AAE1F,OAAO,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAA;AAGlE,OAAO,EACL,oBAAoB,EACpB,gCAAgC,GACjC,MAAM,+BAA+B,CAAA;AACtC,OAAO,EAEL,oBAAoB,EACpB,gBAAgB,EAChB,0BAA0B,GAO3B,MAAM,6BAA6B,CAAA;AAEpC,OAAO,EACL,uBAAuB,EACvB,wBAAwB,EACxB,wBAAwB,GAGzB,MAAM,qCAAqC,CAAA;AAC5C,OAAO,EAAE,gCAAgC,EAAE,MAAM,yBAAyB,CAAA;AAC1E,OAAO,EACL,kCAAkC,EAClC,sBAAsB,EACtB,sBAAsB,GACvB,MAAM,8BAA8B,CAAA;AACrC,OAAO,EAAE,SAAS,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAA;AACxE,OAAO,EAAE,qBAAqB,EAAE,MAAM,mCAAmC,CAAA;AACzE,OAAO,EACL,WAAW,EACX,4BAA4B,EAC5B,WAAW,EACX,eAAe,EACf,kBAAkB,EAClB,WAAW,EACX,eAAe,EACf,gCAAgC,EAChC,8BAA8B,EAC9B,qBAAqB,GACtB,MAAM,qBAAqB,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@message-queue-toolkit/sqs",
-    "version": "22.6.0",
+    "version": "22.7.0",
     "private": false,
     "license": "MIT",
     "description": "SQS adapter for message-queue-toolkit",