@adtrackify/at-service-common 3.19.8 → 3.19.9

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

@@ -1,907 +0,0 @@
-import { BundledSQSClient } from '../../clients/generic/sqs-bundled-client';
-import { CompressionAlgorithm } from '../../clients/generic/sqs-bundled-client.types';
-import { createSqsLimits, SQS_1MB } from '../../constants/sqs';
-jest.mock('../../helpers/logging-helper', () => ({
-    Logger: {
-        debug: jest.fn(),
-        info: jest.fn(),
-        warn: jest.fn(),
-        error: jest.fn(),
-    },
-}));
-const actualSizeModule = jest.requireActual('../../utils/size');
-const mockSizeInBytes = jest.fn(actualSizeModule.sizeInBytes);
-jest.mock('../../utils/size', () => ({
-    ...jest.requireActual('../../utils/size'),
-    sizeInBytes: (obj) => mockSizeInBytes(obj),
-}));
-function makeTestEvent(id, name = 'test', value) {
-    return { id, name, value };
-}
-describe('BundledSQSClient', () => {
-    let mockSqsClient;
-    let bundledClient;
-    beforeEach(() => {
-        mockSqsClient = {
-            buildAndSendMessagesV2: jest.fn().mockResolvedValue({
-                successCount: 1,
-                failedCount: 0,
-                batchCount: 1,
-                failedMessages: [],
-            }),
-            queueUrl: 'https://sqs.us-east-1.amazonaws.com/123456789/test-queue',
-            limits: createSqsLimits(SQS_1MB),
-        };
-        bundledClient = new BundledSQSClient(mockSqsClient, {
-            compression: CompressionAlgorithm.ZSTD,
-            compressionLevel: 3,
-        });
-    });
-    describe('sendBundled', () => {
-        it('returns empty result for empty items array', async () => {
-            const result = await bundledClient.sendBundled('test-message', []);
-            expect(result.totalItems).toBe(0);
-            expect(result.bundleCount).toBe(0);
-            expect(result.messageCount).toBe(0);
-            expect(mockSqsClient.buildAndSendMessagesV2).not.toHaveBeenCalled();
-        });
-        it('passes delaySeconds through to the underlying send', async () => {
-            const items = [makeTestEvent('1'), makeTestEvent('2')];
-            await bundledClient.sendBundled('test-message', items, 480);
-            expect(mockSqsClient.buildAndSendMessagesV2).toHaveBeenCalledWith('test-message', expect.any(Array), 480);
-        });
-        it('defaults delaySeconds to 0 when omitted', async () => {
-            const items = [makeTestEvent('1')];
-            await bundledClient.sendBundled('test-message', items);
-            expect(mockSqsClient.buildAndSendMessagesV2).toHaveBeenCalledWith('test-message', expect.any(Array), 0);
-        });
-        it('bundles and sends small items', async () => {
-            const items = [makeTestEvent('1'), makeTestEvent('2'), makeTestEvent('3')];
-            const result = await bundledClient.sendBundled('test-message', items);
-            expect(result.totalItems).toBe(3);
-            expect(result.bundleCount).toBeGreaterThanOrEqual(1);
-            expect(mockSqsClient.buildAndSendMessagesV2).toHaveBeenCalledTimes(1);
-            const sentEnvelopes = mockSqsClient.buildAndSendMessagesV2.mock
-                .calls[0][1];
-            expect(sentEnvelopes.length).toBeGreaterThanOrEqual(1);
-            const envelope = sentEnvelopes[0];
-            expect(envelope.v).toBe(1);
-            expect(envelope.c).toBe(CompressionAlgorithm.ZSTD);
-            expect(envelope.n).toBe(3);
-            expect(typeof envelope.p).toBe('string');
-        });
-        it('tracks compression metrics', async () => {
-            const items = Array.from({ length: 100 }, (_, i) => makeTestEvent(`event-${i}`, `name-${i}`, i * 100));
-            const result = await bundledClient.sendBundled('test-message', items);
-            expect(result.metrics.originalSizeBytes).toBeGreaterThan(0);
-            expect(result.metrics.finalSizeBytes).toBeGreaterThan(0);
-            expect(result.metrics.compressionRatio).toBeGreaterThan(1);
-            expect(result.metrics.compressionTimeMs).toBeGreaterThanOrEqual(0);
-        });
-        it('sends items without compression when NONE specified', async () => {
-            const noCompressionClient = new BundledSQSClient(mockSqsClient, {
-                compression: CompressionAlgorithm.NONE,
-            });
-            const items = [makeTestEvent('1')];
-            await noCompressionClient.sendBundled('test-message', items);
-            const sentEnvelopes = mockSqsClient.buildAndSendMessagesV2.mock
-                .calls[0][1];
-            const envelope = sentEnvelopes[0];
-            expect(envelope.c).toBe(CompressionAlgorithm.NONE);
-            expect(Array.isArray(envelope.p)).toBe(true);
-        });
-        it('respects maxItemsPerBundle config', async () => {
-            const client = new BundledSQSClient(mockSqsClient, {
-                compression: CompressionAlgorithm.ZSTD,
-                maxItemsPerBundle: 10,
-            });
-            const items = Array.from({ length: 25 }, (_, i) => makeTestEvent(`${i}`));
-            mockSqsClient.buildAndSendMessagesV2.mockResolvedValue({
-                successCount: 3,
-                failedCount: 0,
-                batchCount: 1,
-                failedMessages: [],
-            });
-            const result = await client.sendBundled('test-message', items);
-            expect(result.totalItems).toBe(25);
-            expect(result.bundleCount).toBeGreaterThanOrEqual(2);
-            const sentEnvelopes = mockSqsClient.buildAndSendMessagesV2.mock
-                .calls[0][1];
-            for (const envelope of sentEnvelopes) {
-                expect(envelope.n).toBeLessThanOrEqual(10);
-            }
-        });
-        it('calculates billable requests based on size', async () => {
-            const items = Array.from({ length: 50 }, (_, i) => makeTestEvent(`${i}`, 'name', i * 10));
-            const result = await bundledClient.sendBundled('test-message', items);
-            expect(result.billableRequests).toBeGreaterThanOrEqual(1);
-        });
-    });
-    describe('retry behavior', () => {
-        it('retries failed messages', async () => {
-            mockSqsClient.buildAndSendMessagesV2
-                .mockResolvedValueOnce({
-                successCount: 0,
-                failedCount: 1,
-                batchCount: 1,
-                failedMessages: [{ v: 1, c: 'zstd', n: 1, p: 'test' }],
-            })
-                .mockResolvedValueOnce({
-                successCount: 1,
-                failedCount: 0,
-                batchCount: 1,
-                failedMessages: [],
-            });
-            const items = [makeTestEvent('1')];
-            const result = await bundledClient.sendBundled('test-message', items);
-            expect(mockSqsClient.buildAndSendMessagesV2).toHaveBeenCalledTimes(2);
-            expect(result.failedBundles).toBe(0);
-        });
-        it('stops retrying after max retries', async () => {
-            mockSqsClient.buildAndSendMessagesV2.mockResolvedValue({
-                successCount: 0,
-                failedCount: 1,
-                batchCount: 1,
-                failedMessages: [{ v: 1, c: 'zstd', n: 1, p: 'test' }],
-            });
-            const items = [makeTestEvent('1')];
-            const result = await bundledClient.sendBundled('test-message', items);
-            expect(mockSqsClient.buildAndSendMessagesV2).toHaveBeenCalledTimes(3);
-            expect(result.failedBundles).toBeGreaterThan(0);
-        });
-    });
-    describe('auto-resize', () => {
-        it('is enabled by default', () => {
-            const client = new BundledSQSClient(mockSqsClient);
-            expect(client.config.autoResize).toBe(true);
-        });
-        it('can be configured to be disabled', () => {
-            const client = new BundledSQSClient(mockSqsClient, {
-                autoResize: false,
-            });
-            expect(client.config.autoResize).toBe(false);
-        });
-    });
-    describe('skippedItems behavior', () => {
-        afterEach(() => {
-            mockSizeInBytes.mockImplementation(actualSizeModule.sizeInBytes);
-        });
-        it('reports skippedItems as 0 when all items sent successfully', async () => {
-            const items = [makeTestEvent('1'), makeTestEvent('2')];
-            const result = await bundledClient.sendBundled('test-message', items);
-            expect(result.skippedItems).toBe(0);
-            expect(result.totalItems).toBe(2);
-            expect(result.failedBundles).toBe(0);
-        });
-        it('tracks skippedItems when autoResize disabled and bundle exceeds limit', async () => {
-            const noResizeClient = new BundledSQSClient(mockSqsClient, {
-                compression: CompressionAlgorithm.ZSTD,
-                autoResize: false,
-            });
-            const items = [makeTestEvent('1'), makeTestEvent('2'), makeTestEvent('3')];
-            mockSizeInBytes.mockImplementation((obj) => {
-                if (typeof obj === 'object' && obj !== null && 'v' in obj) {
-                    return 2000000;
-                }
-                return 100;
-            });
-            const result = await noResizeClient.sendBundled('test-message', items);
-            expect(result.skippedItems).toBe(3);
-            expect(result.totalItems).toBe(3);
-            expect(mockSqsClient.buildAndSendMessagesV2).not.toHaveBeenCalled();
-        });
-        it('tracks skippedItems when single item cannot fit (splitAndRetry terminates)', async () => {
-            const client = new BundledSQSClient(mockSqsClient, {
-                compression: CompressionAlgorithm.ZSTD,
-                autoResize: true,
-            });
-            const items = [makeTestEvent('oversized-item')];
-            mockSizeInBytes.mockImplementation((obj) => {
-                if (typeof obj === 'object' && obj !== null && 'v' in obj) {
-                    return 2000000;
-                }
-                return 100;
-            });
-            const result = await client.sendBundled('test-message', items);
-            expect(result.skippedItems).toBe(1);
-            expect(result.totalItems).toBe(1);
-        });
-        it('reports partial skippedItems when some items are too large', async () => {
-            const client = new BundledSQSClient(mockSqsClient, {
-                compression: CompressionAlgorithm.ZSTD,
-                autoResize: true,
-                maxItemsPerBundle: 1,
-            });
-            const items = [makeTestEvent('small-1'), makeTestEvent('oversized'), makeTestEvent('small-2')];
-            let envelopeValidationCount = 0;
-            mockSizeInBytes.mockImplementation((obj) => {
-                if (typeof obj === 'object' && obj !== null && 'v' in obj) {
-                    envelopeValidationCount++;
-                    if (envelopeValidationCount === 2) {
-                        return 2000000;
-                    }
-                    return 500;
-                }
-                return 100;
-            });
-            const result = await client.sendBundled('test-message', items);
-            expect(result.skippedItems).toBe(1);
-            expect(result.totalItems).toBe(3);
-            expect(mockSqsClient.buildAndSendMessagesV2).toHaveBeenCalled();
-        });
-        it('emptyResult returns skippedItems as 0', async () => {
-            const result = await bundledClient.sendBundled('test-message', []);
-            expect(result.skippedItems).toBe(0);
-            expect(result.totalItems).toBe(0);
-        });
-    });
-    describe('integration: end-to-end bundle flow', () => {
-        it('produces envelopes that unbundleRecords can process', async () => {
-            const { unbundleRecords } = await import('../../clients/generic/sqs-unbundle');
-            const items = [
-                makeTestEvent('event-1', 'purchase', 99.99),
-                makeTestEvent('event-2', 'add_to_cart', 29.99),
-                makeTestEvent('event-3', 'page_view'),
-            ];
-            let capturedEnvelope = null;
-            mockSqsClient.buildAndSendMessagesV2.mockImplementation(async (_type, envelopes) => {
-                capturedEnvelope = envelopes[0];
-                return {
-                    successCount: envelopes.length,
-                    failedCount: 0,
-                    batchCount: 1,
-                    failedMessages: [],
-                };
-            });
-            await bundledClient.sendBundled('test-message', items);
-            expect(capturedEnvelope).not.toBeNull();
-            const sqsRecord = {
-                messageId: 'msg-1',
-                body: JSON.stringify({ messageBody: capturedEnvelope }),
-            };
-            const { items: unbundledItems, stats } = await unbundleRecords([sqsRecord]);
-            expect(unbundledItems).toHaveLength(3);
-            expect(unbundledItems[0]).toEqual({ id: 'event-1', name: 'purchase', value: 99.99 });
-            expect(unbundledItems[1]).toEqual({ id: 'event-2', name: 'add_to_cart', value: 29.99 });
-            expect(unbundledItems[2]).toEqual({ id: 'event-3', name: 'page_view' });
-            expect(stats.bundledSqsRecords).toBe(1);
-        });
-        it('maintains compatibility with large bundles', async () => {
-            const { unbundleRecords } = await import('../../clients/generic/sqs-unbundle');
-            const items = Array.from({ length: 200 }, (_, i) => makeTestEvent(`event-${i}`, `type-${i % 5}`, i * 1.5));
-            let capturedEnvelopes = [];
-            mockSqsClient.buildAndSendMessagesV2.mockImplementation(async (_type, envelopes) => {
-                capturedEnvelopes = envelopes;
-                return {
-                    successCount: envelopes.length,
-                    failedCount: 0,
-                    batchCount: 1,
-                    failedMessages: [],
-                };
-            });
-            await bundledClient.sendBundled('test-message', items);
-            const sqsRecords = capturedEnvelopes.map((env, i) => ({
-                messageId: `msg-${i}`,
-                body: JSON.stringify({ messageBody: env }),
-            }));
-            const { items: unbundledItems } = await unbundleRecords(sqsRecords);
-            expect(unbundledItems).toHaveLength(200);
-            expect(unbundledItems[0].id).toBe('event-0');
-            expect(unbundledItems[199].id).toBe('event-199');
-        });
-    });
-    describe('producer edge cases - real sequences', () => {
-        it('handles 1000 items with real bundling and verifies envelope structure', async () => {
-            const { unbundleRecords } = await import('../../clients/generic/sqs-unbundle');
-            const items = Array.from({ length: 1000 }, (_, i) => ({
-                id: `item-${i}`,
-                name: `payload-${i}`,
-                value: i * 10,
-                data: `extra-data-${i}`,
-            }));
-            const capturedEnvelopes = [];
-            mockSqsClient.buildAndSendMessagesV2.mockImplementation(async (_, envelopes) => {
-                capturedEnvelopes.push(...envelopes);
-                return {
-                    successCount: envelopes.length,
-                    failedCount: 0,
-                    batchCount: 1,
-                    failedMessages: [],
-                };
-            });
-            const result = await bundledClient.sendBundled('test', items);
-            expect(result.totalItems).toBe(1000);
-            expect(capturedEnvelopes.length).toBeGreaterThan(0);
-            let totalItemsInEnvelopes = 0;
-            for (const env of capturedEnvelopes) {
-                expect(env.v).toBe(1);
-                expect(env.c).toBe(CompressionAlgorithm.ZSTD);
-                expect(typeof env.p).toBe('string');
-                expect(typeof env.n).toBe('number');
-                expect(env.n).toBeGreaterThan(0);
-                totalItemsInEnvelopes += env.n;
-            }
-            expect(totalItemsInEnvelopes).toBe(1000);
-            const sqsRecords = capturedEnvelopes.map((env, i) => ({
-                messageId: `msg-${i}`,
-                body: JSON.stringify({ messageBody: env }),
-            }));
-            const { items: unbundledItems } = await unbundleRecords(sqsRecords);
-            expect(unbundledItems).toHaveLength(1000);
-            expect(unbundledItems[0]).toEqual({ id: 'item-0', name: 'payload-0', value: 0, data: 'extra-data-0' });
-            expect(unbundledItems[999]).toEqual({ id: 'item-999', name: 'payload-999', value: 9990, data: 'extra-data-999' });
-        });
-        it('achieves compression effectiveness with repetitive data', async () => {
-            const { unbundleRecords } = await import('../../clients/generic/sqs-unbundle');
-            const repetitiveText = 'AAAAAAAAAA'.repeat(100);
-            const items = Array.from({ length: 100 }, (_, i) => ({
-                id: `item-${i}`,
-                name: 'repetitive-test',
-                value: i,
-                data: repetitiveText,
-            }));
-            const capturedEnvelopes = [];
-            mockSqsClient.buildAndSendMessagesV2.mockImplementation(async (_, envelopes) => {
-                capturedEnvelopes.push(envelopes[0]);
-                return {
-                    successCount: envelopes.length,
-                    failedCount: 0,
-                    batchCount: 1,
-                    failedMessages: [],
-                };
-            });
-            const result = await bundledClient.sendBundled('test', items);
-            expect(result.metrics.compressionRatio).toBeGreaterThan(1);
-            expect(result.metrics.finalSizeBytes).toBeLessThan(result.metrics.originalSizeBytes);
-            expect(result.metrics.compressionRatio).toBeGreaterThan(5);
-            expect(capturedEnvelopes).toHaveLength(1);
-            const envelope = capturedEnvelopes[0];
-            expect(typeof envelope.p).toBe('string');
-            const { items: unbundledItems } = await unbundleRecords([
-                {
-                    messageId: 'msg-1',
-                    body: JSON.stringify({ messageBody: envelope }),
-                },
-            ]);
-            expect(unbundledItems).toHaveLength(100);
-            expect(unbundledItems[0].data).toBe(repetitiveText);
-            expect(unbundledItems[99].data).toBe(repetitiveText);
-        });
-        it('handles various item sizes correctly', async () => {
-            const { unbundleRecords } = await import('../../clients/generic/sqs-unbundle');
-            const tinyItems = Array.from({ length: 10 }, (_, i) => ({
-                id: `tiny-${i}`,
-                name: 't',
-            }));
-            const smallItems = Array.from({ length: 10 }, (_, i) => ({
-                id: `small-${i}`,
-                name: 'small-item',
-                value: i,
-                data: 'x'.repeat(100),
-            }));
-            const mediumItems = Array.from({ length: 10 }, (_, i) => ({
-                id: `medium-${i}`,
-                name: 'medium-item',
-                value: i,
-                data: 'y'.repeat(10000),
-            }));
-            const largerItems = Array.from({ length: 5 }, (_, i) => ({
-                id: `larger-${i}`,
-                name: 'larger-item',
-                value: i,
-                data: 'z'.repeat(100000),
-            }));
-            const allItems = [...tinyItems, ...smallItems, ...mediumItems, ...largerItems];
-            const totalExpectedItems = allItems.length;
-            const capturedEnvelopes = [];
-            mockSqsClient.buildAndSendMessagesV2.mockImplementation(async (_, envelopes) => {
-                capturedEnvelopes.push(...envelopes);
-                return {
-                    successCount: envelopes.length,
-                    failedCount: 0,
-                    batchCount: 1,
-                    failedMessages: [],
-                };
-            });
-            const result = await bundledClient.sendBundled('test', allItems);
-            expect(result.totalItems).toBe(totalExpectedItems);
-            expect(result.skippedItems).toBe(0);
-            const totalInEnvelopes = capturedEnvelopes.reduce((sum, env) => sum + env.n, 0);
-            expect(totalInEnvelopes).toBe(totalExpectedItems);
-            const sqsRecords = capturedEnvelopes.map((env, i) => ({
-                messageId: `msg-${i}`,
-                body: JSON.stringify({ messageBody: env }),
-            }));
-            const { items: unbundledItems } = await unbundleRecords(sqsRecords);
-            expect(unbundledItems).toHaveLength(totalExpectedItems);
-            const unbundledTiny = unbundledItems.filter((item) => item.id.startsWith('tiny-'));
-            const unbundledSmall = unbundledItems.filter((item) => item.id.startsWith('small-'));
-            const unbundledMedium = unbundledItems.filter((item) => item.id.startsWith('medium-'));
-            const unbundledLarger = unbundledItems.filter((item) => item.id.startsWith('larger-'));
-            expect(unbundledTiny).toHaveLength(10);
-            expect(unbundledSmall).toHaveLength(10);
-            expect(unbundledMedium).toHaveLength(10);
-            expect(unbundledLarger).toHaveLength(5);
-            expect(unbundledSmall[0].data).toBe('x'.repeat(100));
-            expect(unbundledMedium[0].data).toBe('y'.repeat(10000));
-            expect(unbundledLarger[0].data).toBe('z'.repeat(100000));
-        });
-        it('preserves unicode and special characters through compression', async () => {
-            const { unbundleRecords } = await import('../../clients/generic/sqs-unbundle');
-            const unicodeItems = [
-                {
-                    id: 'emoji',
-                    name: '🎉🚀💯🔥✨',
-                    data: 'Celebration 🎊 with many emojis 🌟⭐💫',
-                },
-                {
-                    id: 'chinese',
-                    name: '你好世界',
-                    data: '这是一个测试消息，包含中文字符。北京、上海、广州。',
-                },
-                {
-                    id: 'arabic',
-                    name: 'مرحبا بالعالم',
-                    data: 'هذه رسالة اختبار باللغة العربية',
-                },
-                {
-                    id: 'japanese',
-                    name: 'こんにちは世界',
-                    data: 'テスト メッセージです。東京、大阪、京都。',
-                },
-                {
-                    id: 'korean',
-                    name: '안녕하세요 세계',
-                    data: '테스트 메시지입니다. 서울, 부산, 인천.',
-                },
-                {
-                    id: 'special-symbols',
-                    name: '†‡§¶•‰™©®',
-                    data: 'Special: «»‹› ′″ ∞∑∏√∫ ≤≥≠≈ αβγδε',
-                },
-                {
-                    id: 'mixed-unicode',
-                    name: 'Mixed: Ñ ü ö ä ß',
-                    data: 'Ümlauts: äöüÄÖÜß — dashes—and–more Ç ñ ¡¿',
-                },
-                {
-                    id: 'mathematical',
-                    name: '∀x∈ℝ: x² ≥ 0',
-                    data: 'Math: ∫₀^∞ e^(-x²) dx = √π/2, ∑_{n=1}^{∞} 1/n² = π²/6',
-                },
-                {
-                    id: 'currency',
-                    name: '€£¥₹₽¢',
-                    data: 'Prices: $100, €85, £70, ¥10000, ₹8000, ₽7500',
-                },
-                {
-                    id: 'newlines-tabs',
-                    name: 'control\tchars',
-                    data: 'Line 1\nLine 2\rLine 3\r\nLine 4\tTabbed',
-                },
-            ];
-            let capturedEnvelope = null;
-            mockSqsClient.buildAndSendMessagesV2.mockImplementation(async (_, envelopes) => {
-                capturedEnvelope = envelopes[0];
-                return {
-                    successCount: envelopes.length,
-                    failedCount: 0,
-                    batchCount: 1,
-                    failedMessages: [],
-                };
-            });
-            const result = await bundledClient.sendBundled('test', unicodeItems);
-            expect(result.totalItems).toBe(unicodeItems.length);
-            expect(result.skippedItems).toBe(0);
-            expect(capturedEnvelope).not.toBeNull();
-            const { items: unbundledItems } = await unbundleRecords([
-                {
-                    messageId: 'msg-1',
-                    body: JSON.stringify({ messageBody: capturedEnvelope }),
-                },
-            ]);
-            expect(unbundledItems).toHaveLength(unicodeItems.length);
-            for (let i = 0; i < unicodeItems.length; i++) {
-                expect(unbundledItems[i]).toEqual(unicodeItems[i]);
-            }
-            const emojiItem = unbundledItems.find((item) => item.id === 'emoji');
-            expect(emojiItem?.name).toBe('🎉🚀💯🔥✨');
-            const chineseItem = unbundledItems.find((item) => item.id === 'chinese');
-            expect(chineseItem?.name).toBe('你好世界');
-            const arabicItem = unbundledItems.find((item) => item.id === 'arabic');
-            expect(arabicItem?.name).toBe('مرحبا بالعالم');
-        });
-        it('preserves deeply nested object structures', async () => {
-            const { unbundleRecords } = await import('../../clients/generic/sqs-unbundle');
-            const nestedItems = [
-                {
-                    id: 'deep-nested',
-                    name: 'deep',
-                    nested: {
-                        level1: {
-                            level2: {
-                                level3: {
-                                    level4: {
-                                        level5: {
-                                            level6: {
-                                                value: 'deep-value',
-                                                number: 12345,
-                                                boolean: true,
-                                            },
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-                {
-                    id: 'array-of-objects',
-                    name: 'arrays',
-                    items: [
-                        { subId: 'sub-1', data: { nested: { value: 'a' } } },
-                        { subId: 'sub-2', data: { nested: { value: 'b' } } },
-                        { subId: 'sub-3', data: { nested: { value: 'c' } } },
-                    ],
-                },
-                {
-                    id: 'mixed-structures',
-                    name: 'mixed',
-                    config: {
-                        settings: {
-                            features: ['feature-1', 'feature-2', 'feature-3'],
-                            metadata: {
-                                tags: {
-                                    primary: ['tag-a', 'tag-b'],
-                                    secondary: {
-                                        group1: ['tag-c', 'tag-d'],
-                                        group2: ['tag-e', 'tag-f'],
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-                {
-                    id: 'null-undefined-handling',
-                    name: 'nulls',
-                    value: null,
-                    nested: {
-                        nullField: null,
-                        emptyObject: {},
-                        emptyArray: [],
-                        zeroValue: 0,
-                        falseValue: false,
-                        emptyString: '',
-                    },
-                },
-                {
-                    id: 'large-array',
-                    name: 'large-array',
-                    items: Array.from({ length: 100 }, (_, i) => ({
-                        index: i,
-                        data: `item-${i}`,
-                        nested: { level: 1, value: i * 2 },
-                    })),
-                },
-            ];
-            let capturedEnvelope = null;
-            mockSqsClient.buildAndSendMessagesV2.mockImplementation(async (_, envelopes) => {
-                capturedEnvelope = envelopes[0];
-                return {
-                    successCount: envelopes.length,
-                    failedCount: 0,
-                    batchCount: 1,
-                    failedMessages: [],
-                };
-            });
-            const genericClient = new BundledSQSClient(mockSqsClient, {
-                compression: CompressionAlgorithm.ZSTD,
-            });
-            const result = await genericClient.sendBundled('test', nestedItems);
-            expect(result.totalItems).toBe(nestedItems.length);
-            expect(result.skippedItems).toBe(0);
-            const { items: unbundledItems } = await unbundleRecords([
-                {
-                    messageId: 'msg-1',
-                    body: JSON.stringify({ messageBody: capturedEnvelope }),
-                },
-            ]);
-            expect(unbundledItems).toHaveLength(nestedItems.length);
-            const deepItem = unbundledItems.find((item) => item.id === 'deep-nested');
-            expect(deepItem?.nested?.level1?.level2?.level3?.level4?.level5?.level6?.value).toBe('deep-value');
-            expect(deepItem?.nested?.level1?.level2?.level3?.level4?.level5?.level6?.number).toBe(12345);
-            expect(deepItem?.nested?.level1?.level2?.level3?.level4?.level5?.level6?.boolean).toBe(true);
-            const arrayItem = unbundledItems.find((item) => item.id === 'array-of-objects');
-            expect(arrayItem?.items?.length).toBe(3);
-            expect(arrayItem?.items?.[0]?.data?.nested?.value).toBe('a');
-            expect(arrayItem?.items?.[2]?.data?.nested?.value).toBe('c');
-            const mixedItem = unbundledItems.find((item) => item.id === 'mixed-structures');
-            expect(mixedItem?.config?.settings?.features).toEqual(['feature-1', 'feature-2', 'feature-3']);
-            expect(mixedItem?.config?.settings?.metadata?.tags?.secondary?.group2).toEqual(['tag-e', 'tag-f']);
-            const nullItem = unbundledItems.find((item) => item.id === 'null-undefined-handling');
-            expect(nullItem?.value).toBeNull();
-            expect(nullItem?.nested?.nullField).toBeNull();
-            expect(nullItem?.nested?.emptyObject).toEqual({});
-            expect(nullItem?.nested?.emptyArray).toEqual([]);
-            expect(nullItem?.nested?.zeroValue).toBe(0);
-            expect(nullItem?.nested?.falseValue).toBe(false);
-            expect(nullItem?.nested?.emptyString).toBe('');
-            const largeArrayItem = unbundledItems.find((item) => item.id === 'large-array');
-            expect(largeArrayItem?.items).toHaveLength(100);
-            expect(largeArrayItem?.items?.[0]).toEqual({ index: 0, data: 'item-0', nested: { level: 1, value: 0 } });
-            expect(largeArrayItem?.items?.[99]).toEqual({ index: 99, data: 'item-99', nested: { level: 1, value: 198 } });
-        });
-        it('handles exactly 1 item', async () => {
-            const { unbundleRecords } = await import('../../clients/generic/sqs-unbundle');
-            const items = [{ id: 'single', name: 'only-one', value: 42 }];
-            const capturedEnvelopes = [];
-            mockSqsClient.buildAndSendMessagesV2.mockImplementation(async (_, envelopes) => {
-                capturedEnvelopes.push(envelopes[0]);
-                return {
-                    successCount: envelopes.length,
-                    failedCount: 0,
-                    batchCount: 1,
-                    failedMessages: [],
-                };
-            });
-            const result = await bundledClient.sendBundled('test', items);
-            expect(result.totalItems).toBe(1);
-            expect(result.bundleCount).toBe(1);
-            expect(result.messageCount).toBe(1);
-            expect(capturedEnvelopes).toHaveLength(1);
-            expect(capturedEnvelopes[0].n).toBe(1);
-            const { items: unbundledItems } = await unbundleRecords([
-                {
-                    messageId: 'msg-1',
-                    body: JSON.stringify({ messageBody: capturedEnvelopes[0] }),
-                },
-            ]);
-            expect(unbundledItems).toHaveLength(1);
-            expect(unbundledItems[0]).toEqual(items[0]);
-        });
-        it('handles exactly maxItemsPerBundle items', async () => {
-            const { unbundleRecords } = await import('../../clients/generic/sqs-unbundle');
-            const maxItems = 50;
-            const client = new BundledSQSClient(mockSqsClient, {
-                compression: CompressionAlgorithm.ZSTD,
-                maxItemsPerBundle: maxItems,
-            });
-            const items = Array.from({ length: maxItems }, (_, i) => ({
-                id: `item-${i}`,
-                name: `name-${i}`,
-                value: i,
-            }));
-            const capturedEnvelopes = [];
-            mockSqsClient.buildAndSendMessagesV2.mockImplementation(async (_, envelopes) => {
-                capturedEnvelopes.push(...envelopes);
-                return {
-                    successCount: envelopes.length,
-                    failedCount: 0,
-                    batchCount: 1,
-                    failedMessages: [],
-                };
-            });
-            const result = await client.sendBundled('test', items);
-            expect(result.totalItems).toBe(maxItems);
-            expect(capturedEnvelopes).toHaveLength(1);
-            expect(capturedEnvelopes[0].n).toBe(maxItems);
-            const sqsRecords = capturedEnvelopes.map((env, i) => ({
-                messageId: `msg-${i}`,
-                body: JSON.stringify({ messageBody: env }),
-            }));
-            const { items: unbundledItems } = await unbundleRecords(sqsRecords);
-            expect(unbundledItems).toHaveLength(maxItems);
-        });
-        it('handles maxItemsPerBundle + 1 items (splits correctly)', async () => {
-            const { unbundleRecords } = await import('../../clients/generic/sqs-unbundle');
-            const maxItems = 50;
-            const client = new BundledSQSClient(mockSqsClient, {
-                compression: CompressionAlgorithm.ZSTD,
-                maxItemsPerBundle: maxItems,
-            });
-            const items = Array.from({ length: maxItems + 1 }, (_, i) => ({
-                id: `item-${i}`,
-                name: `name-${i}`,
-                value: i,
-            }));
-            const capturedEnvelopes = [];
-            mockSqsClient.buildAndSendMessagesV2.mockImplementation(async (_, envelopes) => {
-                capturedEnvelopes.push(...envelopes);
-                return {
-                    successCount: envelopes.length,
-                    failedCount: 0,
-                    batchCount: 1,
-                    failedMessages: [],
-                };
-            });
-            const result = await client.sendBundled('test', items);
-            expect(result.totalItems).toBe(maxItems + 1);
-            expect(capturedEnvelopes).toHaveLength(2);
-            expect(capturedEnvelopes[0].n).toBe(maxItems);
-            expect(capturedEnvelopes[1].n).toBe(1);
-            const sqsRecords = capturedEnvelopes.map((env, i) => ({
-                messageId: `msg-${i}`,
-                body: JSON.stringify({ messageBody: env }),
-            }));
-            const { items: unbundledItems } = await unbundleRecords(sqsRecords);
-            expect(unbundledItems).toHaveLength(maxItems + 1);
-        });
-        it('handles uncompressed mode (NONE) with various data', async () => {
-            const { unbundleRecords } = await import('../../clients/generic/sqs-unbundle');
-            const noCompressionClient = new BundledSQSClient(mockSqsClient, {
-                compression: CompressionAlgorithm.NONE,
-            });
-            const items = Array.from({ length: 50 }, (_, i) => ({
-                id: `uncompressed-${i}`,
-                name: `test-${i}`,
-                value: i * 100,
-                data: `Some data for item ${i}`,
-            }));
-            const capturedEnvelopes = [];
-            mockSqsClient.buildAndSendMessagesV2.mockImplementation(async (_, envelopes) => {
-                capturedEnvelopes.push(envelopes[0]);
-                return {
-                    successCount: envelopes.length,
-                    failedCount: 0,
-                    batchCount: 1,
-                    failedMessages: [],
-                };
-            });
-            const result = await noCompressionClient.sendBundled('test', items);
-            expect(result.totalItems).toBe(50);
-            expect(capturedEnvelopes).toHaveLength(1);
-            const envelope = capturedEnvelopes[0];
-            expect(envelope.c).toBe(CompressionAlgorithm.NONE);
-            expect(Array.isArray(envelope.p)).toBe(true);
-            expect(envelope.p.length).toBe(50);
-            expect(result.metrics.compressionRatio).toBeCloseTo(1, 0);
-            const { items: unbundledItems } = await unbundleRecords([
-                {
-                    messageId: 'msg-1',
-                    body: JSON.stringify({ messageBody: envelope }),
-                },
-            ]);
-            expect(unbundledItems).toHaveLength(50);
-            expect(unbundledItems[0]).toEqual(items[0]);
-            expect(unbundledItems[49]).toEqual(items[49]);
-        });
-        it('produces correct metrics for a large mixed batch', async () => {
-            const items = Array.from({ length: 500 }, (_, i) => ({
-                id: `metric-test-${i}`,
-                name: `item-${i % 10}`,
-                value: i,
-                data: i % 5 === 0 ? 'repeated-data'.repeat(100) : `unique-${i}`,
-            }));
-            const capturedEnvelopes = [];
-            mockSqsClient.buildAndSendMessagesV2.mockImplementation(async (_, envelopes) => {
-                capturedEnvelopes.push(...envelopes);
-                return {
-                    successCount: envelopes.length,
-                    failedCount: 0,
-                    batchCount: 1,
-                    failedMessages: [],
-                };
-            });
-            const result = await bundledClient.sendBundled('test', items);
-            expect(result.totalItems).toBe(500);
-            expect(result.metrics.originalSizeBytes).toBeGreaterThan(0);
-            expect(result.metrics.finalSizeBytes).toBeGreaterThan(0);
-            expect(result.metrics.compressionRatio).toBeGreaterThan(1);
-            expect(result.metrics.compressionTimeMs).toBeGreaterThanOrEqual(0);
-            expect(result.metrics.avgItemsPerBundle).toBeGreaterThan(0);
-            const expectedAvg = items.length / capturedEnvelopes.length;
-            expect(result.metrics.avgItemsPerBundle).toBeCloseTo(expectedAvg, 1);
-            expect(result.billableRequests).toBeGreaterThanOrEqual(1);
-        });
-        it('handles items with special JSON edge cases', async () => {
-            const { unbundleRecords } = await import('../../clients/generic/sqs-unbundle');
-            const edgeCaseItems = [
-                {
-                    id: 'large-numbers',
-                    name: 'numbers',
-                    bigInt: 9007199254740991,
-                    scientific: 1.23e10,
-                    decimal: 0.1 + 0.2,
-                    negative: -999999,
-                    zero: 0,
-                    negativeZero: -0,
-                },
-                {
-                    id: 'special-strings',
-                    name: 'strings',
-                    data: JSON.stringify({ nested: 'json' }),
-                    withQuotes: 'He said "hello"',
-                    withBackslash: 'path\\to\\file',
-                    withSlash: 'https://example.com/path',
-                },
-                {
-                    id: 'boolean-variants',
-                    name: 'booleans',
-                    trueVal: true,
-                    falseVal: false,
-                    truthy: 1,
-                    falsy: 0,
-                },
-                {
-                    id: 'dates-as-strings',
-                    name: 'dates',
-                    isoDate: '2024-01-15T10:30:00.000Z',
-                    timestamp: 1705315800000,
-                },
-            ];
-            let capturedEnvelope = null;
-            mockSqsClient.buildAndSendMessagesV2.mockImplementation(async (_, envelopes) => {
-                capturedEnvelope = envelopes[0];
-                return {
-                    successCount: envelopes.length,
-                    failedCount: 0,
-                    batchCount: 1,
-                    failedMessages: [],
-                };
-            });
-            const genericClient = new BundledSQSClient(mockSqsClient, {
-                compression: CompressionAlgorithm.ZSTD,
-            });
-            const result = await genericClient.sendBundled('test', edgeCaseItems);
-            expect(result.totalItems).toBe(edgeCaseItems.length);
-            expect(result.skippedItems).toBe(0);
-            const { items: unbundledItems } = await unbundleRecords([
-                {
-                    messageId: 'msg-1',
-                    body: JSON.stringify({ messageBody: capturedEnvelope }),
-                },
-            ]);
-            expect(unbundledItems).toHaveLength(edgeCaseItems.length);
-            const numbersItem = unbundledItems.find((item) => item.id === 'large-numbers');
-            expect(numbersItem?.bigInt).toBe(9007199254740991);
-            expect(numbersItem?.scientific).toBe(1.23e10);
-            expect(numbersItem?.negative).toBe(-999999);
-            expect(numbersItem?.zero).toBe(0);
-            const stringsItem = unbundledItems.find((item) => item.id === 'special-strings');
-            expect(stringsItem?.data).toBe(JSON.stringify({ nested: 'json' }));
-            expect(stringsItem?.withQuotes).toBe('He said "hello"');
-            expect(stringsItem?.withBackslash).toBe('path\\to\\file');
-            const booleansItem = unbundledItems.find((item) => item.id === 'boolean-variants');
-            expect(booleansItem?.trueVal).toBe(true);
-            expect(booleansItem?.falseVal).toBe(false);
-        });
-        it('handles concurrent sends without interference', async () => {
-            const batch1 = Array.from({ length: 100 }, (_, i) => ({
-                id: `batch1-${i}`,
-                name: 'batch-one',
-                value: i,
-            }));
-            const batch2 = Array.from({ length: 100 }, (_, i) => ({
-                id: `batch2-${i}`,
-                name: 'batch-two',
-                value: i * 2,
-            }));
-            const batch3 = Array.from({ length: 100 }, (_, i) => ({
-                id: `batch3-${i}`,
-                name: 'batch-three',
-                value: i * 3,
-            }));
-            mockSqsClient.buildAndSendMessagesV2.mockImplementation(async (_, envelopes) => {
-                return {
-                    successCount: envelopes.length,
-                    failedCount: 0,
-                    batchCount: 1,
-                    failedMessages: [],
-                };
-            });
-            const [result1, result2, result3] = await Promise.all([
-                bundledClient.sendBundled('test', batch1),
-                bundledClient.sendBundled('test', batch2),
-                bundledClient.sendBundled('test', batch3),
-            ]);
-            expect(result1.totalItems).toBe(100);
-            expect(result2.totalItems).toBe(100);
-            expect(result3.totalItems).toBe(100);
-            expect(result1.skippedItems).toBe(0);
-            expect(result2.skippedItems).toBe(0);
-            expect(result3.skippedItems).toBe(0);
-        });
-    });
-});
-//# sourceMappingURL=sqs-bundled-client.spec.js.map