@adtrackify/at-service-common 3.17.8 → 3.18.1

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

@@ -0,0 +1,909 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const sqs_bundled_client_1 = require("../../clients/generic/sqs-bundled-client");
+const sqs_bundled_client_types_1 = require("../../clients/generic/sqs-bundled-client.types");
+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',
+        };
+        bundledClient = new sqs_bundled_client_1.BundledSQSClient(mockSqsClient, {
+            compression: sqs_bundled_client_types_1.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('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(sqs_bundled_client_types_1.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 sqs_bundled_client_1.BundledSQSClient(mockSqsClient, {
+                compression: sqs_bundled_client_types_1.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(sqs_bundled_client_types_1.CompressionAlgorithm.NONE);
+            expect(Array.isArray(envelope.p)).toBe(true);
+        });
+        it('respects maxItemsPerBundle config', async () => {
+            const client = new sqs_bundled_client_1.BundledSQSClient(mockSqsClient, {
+                compression: sqs_bundled_client_types_1.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 sqs_bundled_client_1.BundledSQSClient(mockSqsClient);
+            expect(client.config.autoResize).toBe(true);
+        });
+        it('can be configured to be disabled', () => {
+            const client = new sqs_bundled_client_1.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 sqs_bundled_client_1.BundledSQSClient(mockSqsClient, {
+                compression: sqs_bundled_client_types_1.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 sqs_bundled_client_1.BundledSQSClient(mockSqsClient, {
+                compression: sqs_bundled_client_types_1.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 sqs_bundled_client_1.BundledSQSClient(mockSqsClient, {
+                compression: sqs_bundled_client_types_1.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 Promise.resolve().then(() => __importStar(require('../../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.bundledRecords).toBe(1);
+        });
+        it('maintains compatibility with large bundles', async () => {
+            const { unbundleRecords } = await Promise.resolve().then(() => __importStar(require('../../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 Promise.resolve().then(() => __importStar(require('../../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(sqs_bundled_client_types_1.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 Promise.resolve().then(() => __importStar(require('../../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 Promise.resolve().then(() => __importStar(require('../../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 Promise.resolve().then(() => __importStar(require('../../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 Promise.resolve().then(() => __importStar(require('../../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 sqs_bundled_client_1.BundledSQSClient(mockSqsClient, {
+                compression: sqs_bundled_client_types_1.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 Promise.resolve().then(() => __importStar(require('../../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 Promise.resolve().then(() => __importStar(require('../../clients/generic/sqs-unbundle')));
+            const maxItems = 50;
+            const client = new sqs_bundled_client_1.BundledSQSClient(mockSqsClient, {
+                compression: sqs_bundled_client_types_1.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 Promise.resolve().then(() => __importStar(require('../../clients/generic/sqs-unbundle')));
+            const maxItems = 50;
+            const client = new sqs_bundled_client_1.BundledSQSClient(mockSqsClient, {
+                compression: sqs_bundled_client_types_1.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 Promise.resolve().then(() => __importStar(require('../../clients/generic/sqs-unbundle')));
+            const noCompressionClient = new sqs_bundled_client_1.BundledSQSClient(mockSqsClient, {
+                compression: sqs_bundled_client_types_1.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(sqs_bundled_client_types_1.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 Promise.resolve().then(() => __importStar(require('../../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 sqs_bundled_client_1.BundledSQSClient(mockSqsClient, {
+                compression: sqs_bundled_client_types_1.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