@adtrackify/at-service-common 3.18.10 → 3.18.12

package/dist/esm/__tests__/clients/sqs-client.spec.js

@@ -1,190 +1,190 @@
-import { SQSClient } from '../../clients/generic/sqs-client.js';
-import { SQS_1MB } from '../../constants/sqs.js';
-const mockBatchResponse = (successCount, failedEntries = []) => ({
-    Successful: Array.from({ length: successCount }, (_, i) => ({
-        Id: String(i),
-        MessageId: `msg-${i}`,
-        MD5OfMessageBody: 'abc',
-    })),
-    Failed: failedEntries,
-    $metadata: {},
-});
-describe('SQSClient', () => {
-    let sqsClient;
-    beforeEach(() => {
-        sqsClient = new SQSClient('us-east-1', '123456789012', 'test-queue');
-        jest.clearAllMocks();
-    });
-    describe('buildAndSendBatchWithEntryDelays', () => {
-        it('should return empty result for empty entries', async () => {
-            const result = await sqsClient.buildAndSendBatchWithEntryDelays([]);
-            expect(result.sentCount).toBe(0);
-            expect(result.failedCount).toBe(0);
-            expect(result.responses).toEqual([]);
-        });
-        it('should return empty result for null/undefined entries', async () => {
-            const result = await sqsClient.buildAndSendBatchWithEntryDelays(null);
-            expect(result.sentCount).toBe(0);
-            expect(result.failedCount).toBe(0);
-        });
-        it('should send a single message with correct delay', async () => {
-            const sendMessageBatchMock = jest.fn().mockResolvedValue(mockBatchResponse(1));
-            sqsClient.sqs.sendMessageBatch = sendMessageBatchMock;
-            const result = await sqsClient.buildAndSendBatchWithEntryDelays([
-                { messageType: 'testType', messageBody: { key: 'value' }, delaySeconds: 30 },
-            ]);
-            expect(sendMessageBatchMock).toHaveBeenCalledTimes(1);
-            const callArgs = sendMessageBatchMock.mock.calls[0][0];
-            expect(callArgs.Entries).toHaveLength(1);
-            expect(callArgs.Entries[0].DelaySeconds).toBe(30);
-            expect(result.sentCount).toBe(1);
-            expect(result.failedCount).toBe(0);
-        });
-        it('should handle exactly 10 messages in a single batch', async () => {
-            const sendMessageBatchMock = jest.fn().mockResolvedValue(mockBatchResponse(10));
-            sqsClient.sqs.sendMessageBatch = sendMessageBatchMock;
-            const entries = Array.from({ length: 10 }, (_, i) => ({
-                messageType: 'testType',
-                messageBody: { index: i },
-                delaySeconds: i * 10,
-            }));
-            const result = await sqsClient.buildAndSendBatchWithEntryDelays(entries);
-            expect(sendMessageBatchMock).toHaveBeenCalledTimes(1);
-            expect(result.sentCount).toBe(10);
-            expect(result.failedCount).toBe(0);
-        });
-        it('should split 11+ messages into multiple batches sent concurrently', async () => {
-            const sendMessageBatchMock = jest.fn().mockImplementation((params) => {
-                const count = params.Entries?.length ?? 0;
-                return Promise.resolve(mockBatchResponse(count));
-            });
-            sqsClient.sqs.sendMessageBatch = sendMessageBatchMock;
-            const entries = Array.from({ length: 15 }, (_, i) => ({
-                messageType: 'testType',
-                messageBody: { index: i },
-                delaySeconds: i,
-            }));
-            const result = await sqsClient.buildAndSendBatchWithEntryDelays(entries);
-            expect(sendMessageBatchMock).toHaveBeenCalledTimes(2);
-            expect(result.sentCount).toBe(15);
-            expect(result.failedCount).toBe(0);
-        });
-        it('should apply per-entry delay values correctly', async () => {
-            const sendMessageBatchMock = jest.fn().mockResolvedValue(mockBatchResponse(3));
-            sqsClient.sqs.sendMessageBatch = sendMessageBatchMock;
-            const entries = [
-                { messageType: 'typeA', messageBody: { a: 1 }, delaySeconds: 0 },
-                { messageType: 'typeB', messageBody: { b: 2 }, delaySeconds: 60 },
-                { messageType: 'typeC', messageBody: { c: 3 }, delaySeconds: 900 },
-            ];
-            await sqsClient.buildAndSendBatchWithEntryDelays(entries);
-            const callArgs = sendMessageBatchMock.mock.calls[0][0];
-            expect(callArgs.Entries[0].DelaySeconds).toBe(0);
-            expect(callArgs.Entries[1].DelaySeconds).toBe(60);
-            expect(callArgs.Entries[2].DelaySeconds).toBe(900);
-        });
-        it('should default delaySeconds to 0 when not provided', async () => {
-            const sendMessageBatchMock = jest.fn().mockResolvedValue(mockBatchResponse(1));
-            sqsClient.sqs.sendMessageBatch = sendMessageBatchMock;
-            await sqsClient.buildAndSendBatchWithEntryDelays([{ messageType: 'testType', messageBody: { key: 'value' } }]);
-            const callArgs = sendMessageBatchMock.mock.calls[0][0];
-            expect(callArgs.Entries[0].DelaySeconds).toBe(0);
-        });
-        it('should count partial batch failures correctly', async () => {
-            const sendMessageBatchMock = jest.fn().mockResolvedValue({
-                ...mockBatchResponse(1),
-                Failed: [{ Id: '1', SenderFault: true, Code: 'InternalError', Message: 'fail' }],
-            });
-            sqsClient.sqs.sendMessageBatch = sendMessageBatchMock;
-            const result = await sqsClient.buildAndSendBatchWithEntryDelays([
-                { messageType: 'typeA', messageBody: { a: 1 } },
-                { messageType: 'typeB', messageBody: { b: 2 } },
-            ]);
-            expect(result.sentCount).toBe(1);
-            expect(result.failedCount).toBe(1);
-        });
-        it('should handle complete batch rejection gracefully', async () => {
-            const sendMessageBatchMock = jest.fn().mockRejectedValue(new Error('Network error'));
-            sqsClient.sqs.sendMessageBatch = sendMessageBatchMock;
-            const entries = Array.from({ length: 5 }, (_, i) => ({
-                messageType: 'testType',
-                messageBody: { index: i },
-            }));
-            const result = await sqsClient.buildAndSendBatchWithEntryDelays(entries);
-            expect(result.sentCount).toBe(0);
-            expect(result.failedCount).toBe(10);
-        });
-        it('should split batches when total payload exceeds 1 MiB', async () => {
-            const client1MB = new SQSClient('us-east-1', '123456789012', 'test-queue', { maxMessageSizeBytes: SQS_1MB });
-            const sendMessageBatchMock = jest.fn().mockImplementation((params) => {
-                const count = params.Entries?.length ?? 0;
-                return Promise.resolve(mockBatchResponse(count));
-            });
-            client1MB.sqs.sendMessageBatch = sendMessageBatchMock;
-            const largePayload = 'x'.repeat(300000);
-            const entries = Array.from({ length: 5 }, (_, i) => ({
-                messageType: 'testType',
-                messageBody: { index: i, data: largePayload },
-            }));
-            const result = await client1MB.buildAndSendBatchWithEntryDelays(entries);
-            expect(sendMessageBatchMock.mock.calls.length).toBeGreaterThan(1);
-            expect(result.sentCount).toBe(5);
-            expect(result.failedCount).toBe(0);
-        });
-        it('should skip oversized individual messages and count as failed', async () => {
-            const sendMessageBatchMock = jest.fn().mockImplementation((params) => {
-                const count = params.Entries?.length ?? 0;
-                return Promise.resolve(mockBatchResponse(count));
-            });
-            sqsClient.sqs.sendMessageBatch = sendMessageBatchMock;
-            const oversizedPayload = 'x'.repeat(1100000);
-            const entries = [
-                { messageType: 'small', messageBody: { data: 'small' } },
-                { messageType: 'oversized', messageBody: { data: oversizedPayload } },
-                { messageType: 'small2', messageBody: { data: 'small2' } },
-            ];
-            const result = await sqsClient.buildAndSendBatchWithEntryDelays(entries);
-            expect(sendMessageBatchMock).toHaveBeenCalledTimes(1);
-            expect(result.sentCount).toBe(2);
-            expect(result.failedCount).toBe(1);
-        });
-    });
-    describe('sendMessages', () => {
-        it('should return empty result for empty messages', async () => {
-            const result = await sqsClient.sendMessages([]);
-            expect(result.sentCount).toBe(0);
-            expect(result.failedCount).toBe(0);
-            expect(result.responses).toEqual([]);
-        });
-        it('should split batches when total payload exceeds 1 MiB', async () => {
-            const client1MB = new SQSClient('us-east-1', '123456789012', 'test-queue', { maxMessageSizeBytes: SQS_1MB });
-            const sendMessageBatchMock = jest.fn().mockImplementation((params) => {
-                const count = params.Entries?.length ?? 0;
-                return Promise.resolve(mockBatchResponse(count));
-            });
-            client1MB.sqs.sendMessageBatch = sendMessageBatchMock;
-            const largePayload = 'x'.repeat(300000);
-            const messages = Array.from({ length: 5 }, (_, i) => ({
-                index: i,
-                data: largePayload,
-            }));
-            const result = await client1MB.sendMessages(messages);
-            expect(sendMessageBatchMock.mock.calls.length).toBeGreaterThan(1);
-            expect(result.sentCount).toBe(5);
-        });
-        it('should skip oversized individual messages and count as failed', async () => {
-            const sendMessageBatchMock = jest.fn().mockImplementation((params) => {
-                const count = params.Entries?.length ?? 0;
-                return Promise.resolve(mockBatchResponse(count));
-            });
-            sqsClient.sqs.sendMessageBatch = sendMessageBatchMock;
-            const oversizedPayload = 'x'.repeat(1100000);
-            const messages = [{ data: 'small' }, { data: oversizedPayload }, { data: 'small2' }];
-            const result = await sqsClient.sendMessages(messages);
-            expect(sendMessageBatchMock).toHaveBeenCalledTimes(1);
-            expect(result.sentCount).toBe(2);
-            expect(result.failedCount).toBe(1);
-        });
-    });
-});
+import { SQSClient } from '../../clients/generic/sqs-client.js';
+import { SQS_1MB } from '../../constants/sqs.js';
+const mockBatchResponse = (successCount, failedEntries = []) => ({
+    Successful: Array.from({ length: successCount }, (_, i) => ({
+        Id: String(i),
+        MessageId: `msg-${i}`,
+        MD5OfMessageBody: 'abc',
+    })),
+    Failed: failedEntries,
+    $metadata: {},
+});
+describe('SQSClient', () => {
+    let sqsClient;
+    beforeEach(() => {
+        sqsClient = new SQSClient('us-east-1', '123456789012', 'test-queue');
+        jest.clearAllMocks();
+    });
+    describe('buildAndSendBatchWithEntryDelays', () => {
+        it('should return empty result for empty entries', async () => {
+            const result = await sqsClient.buildAndSendBatchWithEntryDelays([]);
+            expect(result.sentCount).toBe(0);
+            expect(result.failedCount).toBe(0);
+            expect(result.responses).toEqual([]);
+        });
+        it('should return empty result for null/undefined entries', async () => {
+            const result = await sqsClient.buildAndSendBatchWithEntryDelays(null);
+            expect(result.sentCount).toBe(0);
+            expect(result.failedCount).toBe(0);
+        });
+        it('should send a single message with correct delay', async () => {
+            const sendMessageBatchMock = jest.fn().mockResolvedValue(mockBatchResponse(1));
+            sqsClient.sqs.sendMessageBatch = sendMessageBatchMock;
+            const result = await sqsClient.buildAndSendBatchWithEntryDelays([
+                { messageType: 'testType', messageBody: { key: 'value' }, delaySeconds: 30 },
+            ]);
+            expect(sendMessageBatchMock).toHaveBeenCalledTimes(1);
+            const callArgs = sendMessageBatchMock.mock.calls[0][0];
+            expect(callArgs.Entries).toHaveLength(1);
+            expect(callArgs.Entries[0].DelaySeconds).toBe(30);
+            expect(result.sentCount).toBe(1);
+            expect(result.failedCount).toBe(0);
+        });
+        it('should handle exactly 10 messages in a single batch', async () => {
+            const sendMessageBatchMock = jest.fn().mockResolvedValue(mockBatchResponse(10));
+            sqsClient.sqs.sendMessageBatch = sendMessageBatchMock;
+            const entries = Array.from({ length: 10 }, (_, i) => ({
+                messageType: 'testType',
+                messageBody: { index: i },
+                delaySeconds: i * 10,
+            }));
+            const result = await sqsClient.buildAndSendBatchWithEntryDelays(entries);
+            expect(sendMessageBatchMock).toHaveBeenCalledTimes(1);
+            expect(result.sentCount).toBe(10);
+            expect(result.failedCount).toBe(0);
+        });
+        it('should split 11+ messages into multiple batches sent concurrently', async () => {
+            const sendMessageBatchMock = jest.fn().mockImplementation((params) => {
+                const count = params.Entries?.length ?? 0;
+                return Promise.resolve(mockBatchResponse(count));
+            });
+            sqsClient.sqs.sendMessageBatch = sendMessageBatchMock;
+            const entries = Array.from({ length: 15 }, (_, i) => ({
+                messageType: 'testType',
+                messageBody: { index: i },
+                delaySeconds: i,
+            }));
+            const result = await sqsClient.buildAndSendBatchWithEntryDelays(entries);
+            expect(sendMessageBatchMock).toHaveBeenCalledTimes(2);
+            expect(result.sentCount).toBe(15);
+            expect(result.failedCount).toBe(0);
+        });
+        it('should apply per-entry delay values correctly', async () => {
+            const sendMessageBatchMock = jest.fn().mockResolvedValue(mockBatchResponse(3));
+            sqsClient.sqs.sendMessageBatch = sendMessageBatchMock;
+            const entries = [
+                { messageType: 'typeA', messageBody: { a: 1 }, delaySeconds: 0 },
+                { messageType: 'typeB', messageBody: { b: 2 }, delaySeconds: 60 },
+                { messageType: 'typeC', messageBody: { c: 3 }, delaySeconds: 900 },
+            ];
+            await sqsClient.buildAndSendBatchWithEntryDelays(entries);
+            const callArgs = sendMessageBatchMock.mock.calls[0][0];
+            expect(callArgs.Entries[0].DelaySeconds).toBe(0);
+            expect(callArgs.Entries[1].DelaySeconds).toBe(60);
+            expect(callArgs.Entries[2].DelaySeconds).toBe(900);
+        });
+        it('should default delaySeconds to 0 when not provided', async () => {
+            const sendMessageBatchMock = jest.fn().mockResolvedValue(mockBatchResponse(1));
+            sqsClient.sqs.sendMessageBatch = sendMessageBatchMock;
+            await sqsClient.buildAndSendBatchWithEntryDelays([{ messageType: 'testType', messageBody: { key: 'value' } }]);
+            const callArgs = sendMessageBatchMock.mock.calls[0][0];
+            expect(callArgs.Entries[0].DelaySeconds).toBe(0);
+        });
+        it('should count partial batch failures correctly', async () => {
+            const sendMessageBatchMock = jest.fn().mockResolvedValue({
+                ...mockBatchResponse(1),
+                Failed: [{ Id: '1', SenderFault: true, Code: 'InternalError', Message: 'fail' }],
+            });
+            sqsClient.sqs.sendMessageBatch = sendMessageBatchMock;
+            const result = await sqsClient.buildAndSendBatchWithEntryDelays([
+                { messageType: 'typeA', messageBody: { a: 1 } },
+                { messageType: 'typeB', messageBody: { b: 2 } },
+            ]);
+            expect(result.sentCount).toBe(1);
+            expect(result.failedCount).toBe(1);
+        });
+        it('should handle complete batch rejection gracefully', async () => {
+            const sendMessageBatchMock = jest.fn().mockRejectedValue(new Error('Network error'));
+            sqsClient.sqs.sendMessageBatch = sendMessageBatchMock;
+            const entries = Array.from({ length: 5 }, (_, i) => ({
+                messageType: 'testType',
+                messageBody: { index: i },
+            }));
+            const result = await sqsClient.buildAndSendBatchWithEntryDelays(entries);
+            expect(result.sentCount).toBe(0);
+            expect(result.failedCount).toBe(10);
+        });
+        it('should split batches when total payload exceeds 1 MiB', async () => {
+            const client1MB = new SQSClient('us-east-1', '123456789012', 'test-queue', { maxMessageSizeBytes: SQS_1MB });
+            const sendMessageBatchMock = jest.fn().mockImplementation((params) => {
+                const count = params.Entries?.length ?? 0;
+                return Promise.resolve(mockBatchResponse(count));
+            });
+            client1MB.sqs.sendMessageBatch = sendMessageBatchMock;
+            const largePayload = 'x'.repeat(300000);
+            const entries = Array.from({ length: 5 }, (_, i) => ({
+                messageType: 'testType',
+                messageBody: { index: i, data: largePayload },
+            }));
+            const result = await client1MB.buildAndSendBatchWithEntryDelays(entries);
+            expect(sendMessageBatchMock.mock.calls.length).toBeGreaterThan(1);
+            expect(result.sentCount).toBe(5);
+            expect(result.failedCount).toBe(0);
+        });
+        it('should skip oversized individual messages and count as failed', async () => {
+            const sendMessageBatchMock = jest.fn().mockImplementation((params) => {
+                const count = params.Entries?.length ?? 0;
+                return Promise.resolve(mockBatchResponse(count));
+            });
+            sqsClient.sqs.sendMessageBatch = sendMessageBatchMock;
+            const oversizedPayload = 'x'.repeat(1100000);
+            const entries = [
+                { messageType: 'small', messageBody: { data: 'small' } },
+                { messageType: 'oversized', messageBody: { data: oversizedPayload } },
+                { messageType: 'small2', messageBody: { data: 'small2' } },
+            ];
+            const result = await sqsClient.buildAndSendBatchWithEntryDelays(entries);
+            expect(sendMessageBatchMock).toHaveBeenCalledTimes(1);
+            expect(result.sentCount).toBe(2);
+            expect(result.failedCount).toBe(1);
+        });
+    });
+    describe('sendMessages', () => {
+        it('should return empty result for empty messages', async () => {
+            const result = await sqsClient.sendMessages([]);
+            expect(result.sentCount).toBe(0);
+            expect(result.failedCount).toBe(0);
+            expect(result.responses).toEqual([]);
+        });
+        it('should split batches when total payload exceeds 1 MiB', async () => {
+            const client1MB = new SQSClient('us-east-1', '123456789012', 'test-queue', { maxMessageSizeBytes: SQS_1MB });
+            const sendMessageBatchMock = jest.fn().mockImplementation((params) => {
+                const count = params.Entries?.length ?? 0;
+                return Promise.resolve(mockBatchResponse(count));
+            });
+            client1MB.sqs.sendMessageBatch = sendMessageBatchMock;
+            const largePayload = 'x'.repeat(300000);
+            const messages = Array.from({ length: 5 }, (_, i) => ({
+                index: i,
+                data: largePayload,
+            }));
+            const result = await client1MB.sendMessages(messages);
+            expect(sendMessageBatchMock.mock.calls.length).toBeGreaterThan(1);
+            expect(result.sentCount).toBe(5);
+        });
+        it('should skip oversized individual messages and count as failed', async () => {
+            const sendMessageBatchMock = jest.fn().mockImplementation((params) => {
+                const count = params.Entries?.length ?? 0;
+                return Promise.resolve(mockBatchResponse(count));
+            });
+            sqsClient.sqs.sendMessageBatch = sendMessageBatchMock;
+            const oversizedPayload = 'x'.repeat(1100000);
+            const messages = [{ data: 'small' }, { data: oversizedPayload }, { data: 'small2' }];
+            const result = await sqsClient.sendMessages(messages);
+            expect(sendMessageBatchMock).toHaveBeenCalledTimes(1);
+            expect(result.sentCount).toBe(2);
+            expect(result.failedCount).toBe(1);
+        });
+    });
+});
 //# sourceMappingURL=sqs-client.spec.js.map

package/dist/esm/__tests__/clients/sqs-unbundle.spec.d.ts

@@ -1 +1 @@
-export {};
+export {};