@adtrackify/at-service-common 4.0.0 → 4.0.2

package/dist/esm/__tests__/clients/dynamodb-client.spec.d.ts

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

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

@@ -1,193 +1,193 @@
-import { DynamoDbClient } from '../../clients/generic/dynamodb-client';
-jest.mock('@aws-sdk/client-dynamodb', () => ({
-    DynamoDBClient: jest.fn().mockImplementation(() => ({})),
-    QueryOutput: {},
-}));
-jest.mock('@aws-sdk/lib-dynamodb', () => ({
-    DynamoDBDocument: {
-        from: jest.fn().mockReturnValue({
-            get: jest.fn(),
-            put: jest.fn(),
-            query: jest.fn(),
-            batchGet: jest.fn(),
-            batchWrite: jest.fn(),
-        }),
-    },
-}));
-jest.mock('../../helpers/logging-helper.js', () => ({
-    Logger: {
-        info: jest.fn(),
-        warn: jest.fn(),
-        error: jest.fn(),
-        debug: jest.fn(),
-    },
-}));
-jest.mock('@adtrackify/at-shared-utils', () => ({
-    chunkArray: jest.fn((arr, size) => {
-        const chunks = [];
-        for (let i = 0; i < arr.length; i += size) {
-            chunks.push(arr.slice(i, i + size));
-        }
-        return chunks;
-    }),
-}));
-describe('DynamoDbClient', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    afterEach(() => {
-        jest.restoreAllMocks();
-    });
-    describe('safeQueryByGSI', () => {
-        it('returns results on successful query', async () => {
-            const mockResults = [{ id: '1' }, { id: '2' }];
-            jest.spyOn(DynamoDbClient, 'queryAll').mockResolvedValueOnce(mockResults);
-            const result = await DynamoDbClient.safeQueryByGSI('test-table', 'gsi-name', 'accountId', 'acc-123');
-            expect(result).toEqual(mockResults);
-            expect(DynamoDbClient.queryAll).toHaveBeenCalledWith({
-                TableName: 'test-table',
-                IndexName: 'gsi-name',
-                KeyConditionExpression: 'accountId = :value',
-                ExpressionAttributeValues: { ':value': 'acc-123' },
-            });
-        });
-        it('returns null when query throws error', async () => {
-            jest.spyOn(DynamoDbClient, 'queryAll').mockRejectedValueOnce(new Error('DynamoDB error'));
-            const result = await DynamoDbClient.safeQueryByGSI('test-table', 'gsi-name', 'accountId', 'acc-123');
-            expect(result).toBeNull();
-        });
-    });
-    describe('safeBatchQueryByGSI', () => {
-        it('returns empty array for empty input', async () => {
-            const result = await DynamoDbClient.safeBatchQueryByGSI('test-table', 'gsi-name', 'accountId', []);
-            expect(result).toEqual([]);
-        });
-        it('returns results for single value', async () => {
-            const mockResults = [{ id: '1', accountId: 'acc-1' }];
-            jest.spyOn(DynamoDbClient, 'safeQueryByGSI').mockResolvedValueOnce(mockResults);
-            const result = await DynamoDbClient.safeBatchQueryByGSI('test-table', 'gsi-name', 'accountId', ['acc-1']);
-            expect(result).toEqual(mockResults);
-            expect(DynamoDbClient.safeQueryByGSI).toHaveBeenCalledTimes(1);
-            expect(DynamoDbClient.safeQueryByGSI).toHaveBeenCalledWith('test-table', 'gsi-name', 'accountId', 'acc-1');
-        });
-        it('returns combined results for multiple values', async () => {
-            const results1 = [{ id: '1', accountId: 'acc-1' }];
-            const results2 = [{ id: '2', accountId: 'acc-2' }, { id: '3', accountId: 'acc-2' }];
-            jest.spyOn(DynamoDbClient, 'safeQueryByGSI')
-                .mockResolvedValueOnce(results1)
-                .mockResolvedValueOnce(results2);
-            const result = await DynamoDbClient.safeBatchQueryByGSI('test-table', 'gsi-name', 'accountId', ['acc-1', 'acc-2']);
-            expect(result).toEqual([...results1, ...results2]);
-            expect(DynamoDbClient.safeQueryByGSI).toHaveBeenCalledTimes(2);
-        });
-        it('deduplicates input values', async () => {
-            const mockResults = [{ id: '1', accountId: 'acc-1' }];
-            jest.spyOn(DynamoDbClient, 'safeQueryByGSI').mockResolvedValue(mockResults);
-            await DynamoDbClient.safeBatchQueryByGSI('test-table', 'gsi-name', 'accountId', ['acc-1', 'acc-1', 'acc-1']);
-            expect(DynamoDbClient.safeQueryByGSI).toHaveBeenCalledTimes(1);
-        });
-        it('handles null results from inner calls gracefully', async () => {
-            const results1 = [{ id: '1', accountId: 'acc-1' }];
-            jest.spyOn(DynamoDbClient, 'safeQueryByGSI')
-                .mockResolvedValueOnce(results1)
-                .mockResolvedValueOnce(null);
-            const result = await DynamoDbClient.safeBatchQueryByGSI('test-table', 'gsi-name', 'accountId', ['acc-1', 'acc-2']);
-            expect(result).toEqual(results1);
-        });
-        it('respects concurrency parameter by chunking queries', async () => {
-            const mockResults = [{ id: '1' }];
-            jest.spyOn(DynamoDbClient, 'safeQueryByGSI').mockResolvedValue(mockResults);
-            const values = Array.from({ length: 15 }, (_, i) => `acc-${i}`);
-            await DynamoDbClient.safeBatchQueryByGSI('test-table', 'gsi-name', 'accountId', values, 5);
-            expect(DynamoDbClient.safeQueryByGSI).toHaveBeenCalledTimes(15);
-        });
-        it('handles all queries returning null gracefully', async () => {
-            jest.spyOn(DynamoDbClient, 'safeQueryByGSI')
-                .mockResolvedValueOnce(null)
-                .mockResolvedValueOnce(null);
-            const result = await DynamoDbClient.safeBatchQueryByGSI('test-table', 'gsi-name', 'accountId', ['acc-1', 'acc-2']);
-            expect(result).toEqual([]);
-        });
-    });
-    describe('safeBatchGet', () => {
-        let mockBatchGet;
-        beforeEach(() => {
-            const { DynamoDBDocument } = require('@aws-sdk/lib-dynamodb');
-            mockBatchGet = DynamoDBDocument.from().batchGet;
-        });
-        it('returns empty array for empty keys', async () => {
-            const result = await DynamoDbClient.safeBatchGet('test-table', []);
-            expect(result).toEqual([]);
-            expect(mockBatchGet).not.toHaveBeenCalled();
-        });
-        it('returns results for successful batch get', async () => {
-            const mockItems = [{ id: '1' }, { id: '2' }];
-            mockBatchGet.mockResolvedValueOnce({
-                Responses: { 'test-table': mockItems },
-            });
-            const result = await DynamoDbClient.safeBatchGet('test-table', [{ id: '1' }, { id: '2' }]);
-            expect(result).toEqual(mockItems);
-        });
-        it('handles unprocessed keys without retry (fail-open)', async () => {
-            const mockItems = [{ id: '1' }];
-            mockBatchGet.mockResolvedValueOnce({
-                Responses: { 'test-table': mockItems },
-                UnprocessedKeys: { 'test-table': { Keys: [{ id: '2' }] } },
-            });
-            const result = await DynamoDbClient.safeBatchGet('test-table', [{ id: '1' }, { id: '2' }]);
-            expect(result).toEqual(mockItems);
-            expect(mockBatchGet).toHaveBeenCalledTimes(1);
-        });
-        it('returns empty array on error (fail-open)', async () => {
-            mockBatchGet.mockRejectedValueOnce(new Error('DynamoDB error'));
-            const result = await DynamoDbClient.safeBatchGet('test-table', [{ id: '1' }]);
-            expect(result).toEqual([]);
-        });
-        it('handles >100 keys by chunking', async () => {
-            const keys = Array.from({ length: 150 }, (_, i) => ({ id: `${i}` }));
-            const chunk1Items = Array.from({ length: 100 }, (_, i) => ({ id: `${i}` }));
-            const chunk2Items = Array.from({ length: 50 }, (_, i) => ({ id: `${100 + i}` }));
-            mockBatchGet
-                .mockResolvedValueOnce({ Responses: { 'test-table': chunk1Items } })
-                .mockResolvedValueOnce({ Responses: { 'test-table': chunk2Items } });
-            const result = await DynamoDbClient.safeBatchGet('test-table', keys);
-            expect(mockBatchGet).toHaveBeenCalledTimes(2);
-            expect(result).toHaveLength(150);
-        });
-    });
-    describe('safeBatchWrite', () => {
-        let mockBatchWrite;
-        beforeEach(() => {
-            const { DynamoDBDocument } = require('@aws-sdk/lib-dynamodb');
-            mockBatchWrite = DynamoDBDocument.from().batchWrite;
-        });
-        it('does nothing for empty items', async () => {
-            await DynamoDbClient.safeBatchWrite('test-table', []);
-            expect(mockBatchWrite).not.toHaveBeenCalled();
-        });
-        it('writes items successfully', async () => {
-            mockBatchWrite.mockResolvedValueOnce({});
-            await DynamoDbClient.safeBatchWrite('test-table', [{ id: '1' }, { id: '2' }]);
-            expect(mockBatchWrite).toHaveBeenCalledTimes(1);
-            expect(mockBatchWrite).toHaveBeenCalledWith({
-                RequestItems: {
-                    'test-table': [
-                        { PutRequest: { Item: { id: '1' } } },
-                        { PutRequest: { Item: { id: '2' } } },
-                    ],
-                },
-            });
-        });
-        it('handles >25 items by chunking', async () => {
-            const items = Array.from({ length: 30 }, (_, i) => ({ id: `${i}` }));
-            mockBatchWrite.mockResolvedValue({});
-            await DynamoDbClient.safeBatchWrite('test-table', items);
-            expect(mockBatchWrite).toHaveBeenCalledTimes(2);
-        });
-        it('swallows errors (fail-open)', async () => {
-            mockBatchWrite.mockRejectedValueOnce(new Error('DynamoDB error'));
-            await expect(DynamoDbClient.safeBatchWrite('test-table', [{ id: '1' }])).resolves.toBeUndefined();
-        });
-    });
-});
+import { DynamoDbClient } from '../../clients/generic/dynamodb-client';
+jest.mock('@aws-sdk/client-dynamodb', () => ({
+    DynamoDBClient: jest.fn().mockImplementation(() => ({})),
+    QueryOutput: {},
+}));
+jest.mock('@aws-sdk/lib-dynamodb', () => ({
+    DynamoDBDocument: {
+        from: jest.fn().mockReturnValue({
+            get: jest.fn(),
+            put: jest.fn(),
+            query: jest.fn(),
+            batchGet: jest.fn(),
+            batchWrite: jest.fn(),
+        }),
+    },
+}));
+jest.mock('../../helpers/logging-helper.js', () => ({
+    Logger: {
+        info: jest.fn(),
+        warn: jest.fn(),
+        error: jest.fn(),
+        debug: jest.fn(),
+    },
+}));
+jest.mock('@adtrackify/at-shared-utils', () => ({
+    chunkArray: jest.fn((arr, size) => {
+        const chunks = [];
+        for (let i = 0; i < arr.length; i += size) {
+            chunks.push(arr.slice(i, i + size));
+        }
+        return chunks;
+    }),
+}));
+describe('DynamoDbClient', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    describe('safeQueryByGSI', () => {
+        it('returns results on successful query', async () => {
+            const mockResults = [{ id: '1' }, { id: '2' }];
+            jest.spyOn(DynamoDbClient, 'queryAll').mockResolvedValueOnce(mockResults);
+            const result = await DynamoDbClient.safeQueryByGSI('test-table', 'gsi-name', 'accountId', 'acc-123');
+            expect(result).toEqual(mockResults);
+            expect(DynamoDbClient.queryAll).toHaveBeenCalledWith({
+                TableName: 'test-table',
+                IndexName: 'gsi-name',
+                KeyConditionExpression: 'accountId = :value',
+                ExpressionAttributeValues: { ':value': 'acc-123' },
+            });
+        });
+        it('returns null when query throws error', async () => {
+            jest.spyOn(DynamoDbClient, 'queryAll').mockRejectedValueOnce(new Error('DynamoDB error'));
+            const result = await DynamoDbClient.safeQueryByGSI('test-table', 'gsi-name', 'accountId', 'acc-123');
+            expect(result).toBeNull();
+        });
+    });
+    describe('safeBatchQueryByGSI', () => {
+        it('returns empty array for empty input', async () => {
+            const result = await DynamoDbClient.safeBatchQueryByGSI('test-table', 'gsi-name', 'accountId', []);
+            expect(result).toEqual([]);
+        });
+        it('returns results for single value', async () => {
+            const mockResults = [{ id: '1', accountId: 'acc-1' }];
+            jest.spyOn(DynamoDbClient, 'safeQueryByGSI').mockResolvedValueOnce(mockResults);
+            const result = await DynamoDbClient.safeBatchQueryByGSI('test-table', 'gsi-name', 'accountId', ['acc-1']);
+            expect(result).toEqual(mockResults);
+            expect(DynamoDbClient.safeQueryByGSI).toHaveBeenCalledTimes(1);
+            expect(DynamoDbClient.safeQueryByGSI).toHaveBeenCalledWith('test-table', 'gsi-name', 'accountId', 'acc-1');
+        });
+        it('returns combined results for multiple values', async () => {
+            const results1 = [{ id: '1', accountId: 'acc-1' }];
+            const results2 = [{ id: '2', accountId: 'acc-2' }, { id: '3', accountId: 'acc-2' }];
+            jest.spyOn(DynamoDbClient, 'safeQueryByGSI')
+                .mockResolvedValueOnce(results1)
+                .mockResolvedValueOnce(results2);
+            const result = await DynamoDbClient.safeBatchQueryByGSI('test-table', 'gsi-name', 'accountId', ['acc-1', 'acc-2']);
+            expect(result).toEqual([...results1, ...results2]);
+            expect(DynamoDbClient.safeQueryByGSI).toHaveBeenCalledTimes(2);
+        });
+        it('deduplicates input values', async () => {
+            const mockResults = [{ id: '1', accountId: 'acc-1' }];
+            jest.spyOn(DynamoDbClient, 'safeQueryByGSI').mockResolvedValue(mockResults);
+            await DynamoDbClient.safeBatchQueryByGSI('test-table', 'gsi-name', 'accountId', ['acc-1', 'acc-1', 'acc-1']);
+            expect(DynamoDbClient.safeQueryByGSI).toHaveBeenCalledTimes(1);
+        });
+        it('handles null results from inner calls gracefully', async () => {
+            const results1 = [{ id: '1', accountId: 'acc-1' }];
+            jest.spyOn(DynamoDbClient, 'safeQueryByGSI')
+                .mockResolvedValueOnce(results1)
+                .mockResolvedValueOnce(null);
+            const result = await DynamoDbClient.safeBatchQueryByGSI('test-table', 'gsi-name', 'accountId', ['acc-1', 'acc-2']);
+            expect(result).toEqual(results1);
+        });
+        it('respects concurrency parameter by chunking queries', async () => {
+            const mockResults = [{ id: '1' }];
+            jest.spyOn(DynamoDbClient, 'safeQueryByGSI').mockResolvedValue(mockResults);
+            const values = Array.from({ length: 15 }, (_, i) => `acc-${i}`);
+            await DynamoDbClient.safeBatchQueryByGSI('test-table', 'gsi-name', 'accountId', values, 5);
+            expect(DynamoDbClient.safeQueryByGSI).toHaveBeenCalledTimes(15);
+        });
+        it('handles all queries returning null gracefully', async () => {
+            jest.spyOn(DynamoDbClient, 'safeQueryByGSI')
+                .mockResolvedValueOnce(null)
+                .mockResolvedValueOnce(null);
+            const result = await DynamoDbClient.safeBatchQueryByGSI('test-table', 'gsi-name', 'accountId', ['acc-1', 'acc-2']);
+            expect(result).toEqual([]);
+        });
+    });
+    describe('safeBatchGet', () => {
+        let mockBatchGet;
+        beforeEach(() => {
+            const { DynamoDBDocument } = require('@aws-sdk/lib-dynamodb');
+            mockBatchGet = DynamoDBDocument.from().batchGet;
+        });
+        it('returns empty array for empty keys', async () => {
+            const result = await DynamoDbClient.safeBatchGet('test-table', []);
+            expect(result).toEqual([]);
+            expect(mockBatchGet).not.toHaveBeenCalled();
+        });
+        it('returns results for successful batch get', async () => {
+            const mockItems = [{ id: '1' }, { id: '2' }];
+            mockBatchGet.mockResolvedValueOnce({
+                Responses: { 'test-table': mockItems },
+            });
+            const result = await DynamoDbClient.safeBatchGet('test-table', [{ id: '1' }, { id: '2' }]);
+            expect(result).toEqual(mockItems);
+        });
+        it('handles unprocessed keys without retry (fail-open)', async () => {
+            const mockItems = [{ id: '1' }];
+            mockBatchGet.mockResolvedValueOnce({
+                Responses: { 'test-table': mockItems },
+                UnprocessedKeys: { 'test-table': { Keys: [{ id: '2' }] } },
+            });
+            const result = await DynamoDbClient.safeBatchGet('test-table', [{ id: '1' }, { id: '2' }]);
+            expect(result).toEqual(mockItems);
+            expect(mockBatchGet).toHaveBeenCalledTimes(1);
+        });
+        it('returns empty array on error (fail-open)', async () => {
+            mockBatchGet.mockRejectedValueOnce(new Error('DynamoDB error'));
+            const result = await DynamoDbClient.safeBatchGet('test-table', [{ id: '1' }]);
+            expect(result).toEqual([]);
+        });
+        it('handles >100 keys by chunking', async () => {
+            const keys = Array.from({ length: 150 }, (_, i) => ({ id: `${i}` }));
+            const chunk1Items = Array.from({ length: 100 }, (_, i) => ({ id: `${i}` }));
+            const chunk2Items = Array.from({ length: 50 }, (_, i) => ({ id: `${100 + i}` }));
+            mockBatchGet
+                .mockResolvedValueOnce({ Responses: { 'test-table': chunk1Items } })
+                .mockResolvedValueOnce({ Responses: { 'test-table': chunk2Items } });
+            const result = await DynamoDbClient.safeBatchGet('test-table', keys);
+            expect(mockBatchGet).toHaveBeenCalledTimes(2);
+            expect(result).toHaveLength(150);
+        });
+    });
+    describe('safeBatchWrite', () => {
+        let mockBatchWrite;
+        beforeEach(() => {
+            const { DynamoDBDocument } = require('@aws-sdk/lib-dynamodb');
+            mockBatchWrite = DynamoDBDocument.from().batchWrite;
+        });
+        it('does nothing for empty items', async () => {
+            await DynamoDbClient.safeBatchWrite('test-table', []);
+            expect(mockBatchWrite).not.toHaveBeenCalled();
+        });
+        it('writes items successfully', async () => {
+            mockBatchWrite.mockResolvedValueOnce({});
+            await DynamoDbClient.safeBatchWrite('test-table', [{ id: '1' }, { id: '2' }]);
+            expect(mockBatchWrite).toHaveBeenCalledTimes(1);
+            expect(mockBatchWrite).toHaveBeenCalledWith({
+                RequestItems: {
+                    'test-table': [
+                        { PutRequest: { Item: { id: '1' } } },
+                        { PutRequest: { Item: { id: '2' } } },
+                    ],
+                },
+            });
+        });
+        it('handles >25 items by chunking', async () => {
+            const items = Array.from({ length: 30 }, (_, i) => ({ id: `${i}` }));
+            mockBatchWrite.mockResolvedValue({});
+            await DynamoDbClient.safeBatchWrite('test-table', items);
+            expect(mockBatchWrite).toHaveBeenCalledTimes(2);
+        });
+        it('swallows errors (fail-open)', async () => {
+            mockBatchWrite.mockRejectedValueOnce(new Error('DynamoDB error'));
+            await expect(DynamoDbClient.safeBatchWrite('test-table', [{ id: '1' }])).resolves.toBeUndefined();
+        });
+    });
+});
 //# sourceMappingURL=dynamodb-client.spec.js.map

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

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