@adtrackify/at-service-common 3.18.7 → 3.18.9

package/dist/cjs/__tests__/clients/sqs-unbundle.spec.js

@@ -3,6 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const sqs_unbundle_1 = require("../../clients/generic/sqs-unbundle");
 const sqs_bundled_client_types_1 = require("../../clients/generic/sqs-bundled-client.types");
 const compression_1 = require("../../utils/compression");
+const node_zlib_1 = require("node:zlib");
+const node_util_1 = require("node:util");
+const gzipAsync = (0, node_util_1.promisify)(node_zlib_1.gzip);
 jest.mock('../../helpers/logging-helper', () => ({
     Logger: {
         debug: jest.fn(),
@@ -41,6 +44,18 @@ async function makeCompressedEnvelope(items, level = 3) {
         p: base64,
     };
 }
+async function makeGzipCompressedEnvelope(items) {
+    const json = JSON.stringify(items);
+    const compressed = await gzipAsync(Buffer.from(json, 'utf8'));
+    const base64 = compressed.toString('base64');
+    return {
+        v: 1,
+        c: sqs_bundled_client_types_1.CompressionAlgorithm.GZIP,
+        n: items.length,
+        s: json.length,
+        p: base64,
+    };
+}
 describe('isBundledEnvelope', () => {
     it('returns true for valid bundled envelope with NONE compression', () => {
         const envelope = makeBundledEnvelope([makeTestEvent('1')]);
@@ -63,8 +78,12 @@ describe('isBundledEnvelope', () => {
         const envelope = { v: 2, c: 'none', n: 1, p: [] };
         expect((0, sqs_unbundle_1.isBundledEnvelope)(envelope)).toBe(false);
     });
+    it('returns true for valid bundled envelope with GZIP compression', async () => {
+        const envelope = await makeGzipCompressedEnvelope([makeTestEvent('1')]);
+        expect((0, sqs_unbundle_1.isBundledEnvelope)(envelope)).toBe(true);
+    });
     it('returns false for invalid compression algorithm', () => {
-        const envelope = { v: 1, c: 'gzip', n: 1, p: [] };
+        const envelope = { v: 1, c: 'lz4', n: 1, p: [] };
         expect((0, sqs_unbundle_1.isBundledEnvelope)(envelope)).toBe(false);
     });
     it('returns false for missing count', () => {
@@ -114,6 +133,27 @@ describe('unbundleMessage', () => {
         const envelope = { v: 1, c: 'zstd', n: 1, p: [] };
         await expect((0, sqs_unbundle_1.unbundleMessage)(envelope)).rejects.toThrow('Invalid bundle: zstd compression but payload is not a string');
     });
+    it('unbundles GZIP compressed envelope', async () => {
+        const items = [makeTestEvent('1'), makeTestEvent('2'), makeTestEvent('3')];
+        const envelope = await makeGzipCompressedEnvelope(items);
+        const result = await (0, sqs_unbundle_1.unbundleMessage)(envelope);
+        expect(result).toHaveLength(3);
+        expect(result[0].eventId).toBe('1');
+        expect(result[1].eventId).toBe('2');
+        expect(result[2].eventId).toBe('3');
+    });
+    it('unbundles large batches with GZIP compression', async () => {
+        const items = Array.from({ length: 500 }, (_, i) => makeTestEvent(`event-${i}`, `event_${i}`, i * 10));
+        const envelope = await makeGzipCompressedEnvelope(items);
+        const result = await (0, sqs_unbundle_1.unbundleMessage)(envelope);
+        expect(result).toHaveLength(500);
+        expect(result[0].eventId).toBe('event-0');
+        expect(result[499].eventId).toBe('event-499');
+    });
+    it('throws on invalid payload type for GZIP compression', async () => {
+        const envelope = { v: 1, c: 'gzip', n: 1, p: [] };
+        await expect((0, sqs_unbundle_1.unbundleMessage)(envelope)).rejects.toThrow('Invalid bundle: gzip compression but payload is not a string');
+    });
 });
 describe('unbundleRecords', () => {
     describe('legacy (non-bundled) messages', () => {
@@ -203,6 +243,37 @@ describe('unbundleRecords', () => {
             expect(stats.totalItems).toBe(500);
         });
     });
+    describe('bundled messages (GZIP compression - CF Worker)', () => {
+        it('unbundles GZIP compressed envelope', async () => {
+            const items = [makeTestEvent('g1'), makeTestEvent('g2')];
+            const envelope = await makeGzipCompressedEnvelope(items);
+            const record = makeSqsRecord({ messageBody: envelope });
+            const { items: result, stats } = await (0, sqs_unbundle_1.unbundleRecords)([record]);
+            expect(result).toHaveLength(2);
+            expect(result[0].eventId).toBe('g1');
+            expect(result[1].eventId).toBe('g2');
+            expect(stats.bundledSqsRecords).toBe(1);
+        });
+        it('handles large GZIP compressed bundles (500 items)', async () => {
+            const items = Array.from({ length: 500 }, (_, i) => makeTestEvent(`item-${i}`));
+            const envelope = await makeGzipCompressedEnvelope(items);
+            const record = makeSqsRecord({ messageBody: envelope });
+            const { items: result, stats } = await (0, sqs_unbundle_1.unbundleRecords)([record]);
+            expect(result).toHaveLength(500);
+            expect(stats.bundledSqsRecords).toBe(1);
+            expect(stats.totalItems).toBe(500);
+        });
+        it('maps all items from GZIP bundle to same messageId', async () => {
+            const items = [makeTestEvent('x1'), makeTestEvent('x2'), makeTestEvent('x3')];
+            const envelope = await makeGzipCompressedEnvelope(items);
+            const record = makeSqsRecord({ messageBody: envelope }, 'gzip-bundle-msg-1');
+            const { items: result, recordMap } = await (0, sqs_unbundle_1.unbundleRecords)([record]);
+            expect(result).toHaveLength(3);
+            expect(recordMap.get(result[0])).toBe('gzip-bundle-msg-1');
+            expect(recordMap.get(result[1])).toBe('gzip-bundle-msg-1');
+            expect(recordMap.get(result[2])).toBe('gzip-bundle-msg-1');
+        });
+    });
     describe('mixed message formats', () => {
         it('handles mix of legacy and bundled messages', async () => {
             const legacyEvent = makeTestEvent('legacy-1');
@@ -235,6 +306,29 @@ describe('unbundleRecords', () => {
             expect(stats.bundledSqsRecords).toBe(2);
             expect(stats.totalItems).toBe(3);
         });
+        it('handles mix of ZSTD, GZIP, and legacy messages', async () => {
+            const legacyEvent = makeTestEvent('legacy-1');
+            const zstdItems = [makeTestEvent('zstd-1'), makeTestEvent('zstd-2')];
+            const gzipItems = [makeTestEvent('gzip-1'), makeTestEvent('gzip-2'), makeTestEvent('gzip-3')];
+            const zstdEnvelope = await makeCompressedEnvelope(zstdItems);
+            const gzipEnvelope = await makeGzipCompressedEnvelope(gzipItems);
+            const records = [
+                makeSqsRecord(legacyEvent, 'msg-legacy'),
+                makeSqsRecord({ messageBody: zstdEnvelope }, 'msg-zstd'),
+                makeSqsRecord({ messageBody: gzipEnvelope }, 'msg-gzip'),
+            ];
+            const { items, stats, recordMap } = await (0, sqs_unbundle_1.unbundleRecords)(records);
+            expect(items).toHaveLength(6);
+            expect(stats.legacySqsRecords).toBe(1);
+            expect(stats.bundledSqsRecords).toBe(2);
+            expect(stats.totalItems).toBe(6);
+            expect(recordMap.get(items[0])).toBe('msg-legacy');
+            expect(recordMap.get(items[1])).toBe('msg-zstd');
+            expect(recordMap.get(items[2])).toBe('msg-zstd');
+            expect(recordMap.get(items[3])).toBe('msg-gzip');
+            expect(recordMap.get(items[4])).toBe('msg-gzip');
+            expect(recordMap.get(items[5])).toBe('msg-gzip');
+        });
     });
     describe('error handling', () => {
         it('returns failed messageId for invalid JSON', async () => {
@@ -246,7 +340,7 @@ describe('unbundleRecords', () => {
             expect(stats.failedRecords).toBe(1);
             expect(stats.legacySqsRecords).toBe(1);
         });
-        it('returns failed messageId for corrupt compressed data', async () => {
+        it('returns failed messageId for corrupt ZSTD compressed data', async () => {
             const corruptEnvelope = {
                 v: 1,
                 c: sqs_bundled_client_types_1.CompressionAlgorithm.ZSTD,
@@ -263,6 +357,23 @@ describe('unbundleRecords', () => {
             expect(failedMessageIds).toContain('msg-corrupt');
             expect(stats.failedRecords).toBe(1);
         });
+        it('returns failed messageId for corrupt GZIP compressed data', async () => {
+            const corruptEnvelope = {
+                v: 1,
+                c: sqs_bundled_client_types_1.CompressionAlgorithm.GZIP,
+                n: 10,
+                p: 'dGhpcyBpcyBub3QgdmFsaWQgZ3ppcA==',
+            };
+            const records = [
+                makeSqsRecord({ messageBody: corruptEnvelope }, 'msg-corrupt-gzip'),
+                makeSqsRecord(makeTestEvent('valid'), 'msg-valid'),
+            ];
+            const { items, failedMessageIds, stats } = await (0, sqs_unbundle_1.unbundleRecords)(records);
+            expect(items).toHaveLength(1);
+            expect(items[0].eventId).toBe('valid');
+            expect(failedMessageIds).toContain('msg-corrupt-gzip');
+            expect(stats.failedRecords).toBe(1);
+        });
         it('returns empty result for all failed records', async () => {
             const records = [makeSqsRecord('invalid-1', 'msg-1'), makeSqsRecord('invalid-2', 'msg-2')];
             const { items, failedMessageIds, stats } = await (0, sqs_unbundle_1.unbundleRecords)(records);
@@ -278,7 +389,7 @@ describe('unbundleRecords', () => {
             expect(stats.totalRecords).toBe(0);
             expect(stats.totalItems).toBe(0);
         });
-        it('rejects payload exceeding max decompressed size', async () => {
+        it('rejects ZSTD payload exceeding max decompressed size', async () => {
             const largeItems = Array.from({ length: 1000 }, (_, i) => ({
                 id: `item-${i}`,
                 data: 'x'.repeat(1000),
@@ -291,6 +402,19 @@ describe('unbundleRecords', () => {
             expect(failedMessageIds).toContain('msg-too-large');
             expect(stats.failedRecords).toBe(1);
         });
+        it('rejects GZIP payload exceeding max decompressed size (post-decompress check)', async () => {
+            const largeItems = Array.from({ length: 1000 }, (_, i) => ({
+                id: `item-${i}`,
+                data: 'x'.repeat(1000),
+            }));
+            const envelope = await makeGzipCompressedEnvelope(largeItems);
+            const record = makeSqsRecord({ messageBody: envelope }, 'msg-too-large-gzip');
+            const { failedMessageIds, stats } = await (0, sqs_unbundle_1.unbundleRecords)([record], {
+                maxDecompressedSizeBytes: 100 * 1024,
+            });
+            expect(failedMessageIds).toContain('msg-too-large-gzip');
+            expect(stats.failedRecords).toBe(1);
+        });
         it('fails on invalid base64 in compressed payload', async () => {
             const badEnvelope = {
                 v: 1,
@@ -328,7 +452,7 @@ describe('unbundleRecords', () => {
         });
     });
     describe('timeout protection', () => {
-        it('respects timeoutMs option', async () => {
+        it('respects timeoutMs option for ZSTD', async () => {
             const items = [makeTestEvent('1')];
             const envelope = await makeCompressedEnvelope(items);
             const record = makeSqsRecord({ messageBody: envelope });
@@ -338,6 +462,16 @@ describe('unbundleRecords', () => {
             expect(result).toHaveLength(1);
             expect(failedMessageIds).toHaveLength(0);
         });
+        it('respects timeoutMs option for GZIP', async () => {
+            const items = [makeTestEvent('1')];
+            const envelope = await makeGzipCompressedEnvelope(items);
+            const record = makeSqsRecord({ messageBody: envelope });
+            const { items: result, failedMessageIds } = await (0, sqs_unbundle_1.unbundleRecords)([record], {
+                timeoutMs: 5000,
+            });
+            expect(result).toHaveLength(1);
+            expect(failedMessageIds).toHaveLength(0);
+        });
         it('passes timeoutMs through to decompression', async () => {
             const items = [makeTestEvent('1')];
             const envelope = await makeCompressedEnvelope(items);
@@ -352,7 +486,7 @@ describe('unbundleRecords', () => {
             expect(error.timeoutMs).toBe(5000);
             expect(error.message).toContain('timed out after 5000ms');
         });
-        it('includes timeout info in failure logging', async () => {
+        it('includes timeout info in failure logging for ZSTD', async () => {
             const corruptEnvelope = {
                 v: 1,
                 c: sqs_bundled_client_types_1.CompressionAlgorithm.ZSTD,
@@ -366,6 +500,20 @@ describe('unbundleRecords', () => {
             });
             expect(failedMessageIds).toContain('msg-timeout-test');
         });
+        it('includes timeout info in failure logging for GZIP', async () => {
+            const corruptEnvelope = {
+                v: 1,
+                c: sqs_bundled_client_types_1.CompressionAlgorithm.GZIP,
+                n: 1,
+                s: 100,
+                p: 'dGhpcyBpcyBub3QgdmFsaWQgZ3ppcA==',
+            };
+            const record = makeSqsRecord({ messageBody: corruptEnvelope }, 'msg-gzip-timeout-test');
+            const { failedMessageIds } = await (0, sqs_unbundle_1.unbundleRecords)([record], {
+                timeoutMs: 5000,
+            });
+            expect(failedMessageIds).toContain('msg-gzip-timeout-test');
+        });
     });
     describe('end-to-end: producer bundle → consumer unbundle', () => {
         it('simulates full bundle → unbundle flow with compression', async () => {
@@ -774,5 +922,308 @@ describe('unbundleRecords', () => {
             expect(stats.totalItems).toBe(0);
         });
     });
+    describe('GZIP comprehensive tests', () => {
+        describe('GZIP pre-decompression bomb protection', () => {
+            it('rejects GZIP with fake ISIZE claiming huge size BEFORE decompression starts', async () => {
+                const gzipHeader = Buffer.from([0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03]);
+                const emptyDeflate = Buffer.from([0x03, 0x00]);
+                const crc32 = Buffer.from([0x00, 0x00, 0x00, 0x00]);
+                const fakeIsize = Buffer.alloc(4);
+                fakeIsize.writeUInt32LE(100 * 1024 * 1024, 0);
+                const fakeGzip = Buffer.concat([gzipHeader, emptyDeflate, crc32, fakeIsize]);
+                const base64 = fakeGzip.toString('base64');
+                const bombEnvelope = {
+                    v: 1,
+                    c: sqs_bundled_client_types_1.CompressionAlgorithm.GZIP,
+                    n: 1,
+                    s: 100,
+                    p: base64,
+                };
+                const record = makeSqsRecord({ messageBody: bombEnvelope }, 'msg-gzip-bomb');
+                const { failedMessageIds, stats } = await (0, sqs_unbundle_1.unbundleRecords)([record], {
+                    maxDecompressedSizeBytes: 10 * 1024 * 1024,
+                });
+                expect(failedMessageIds).toContain('msg-gzip-bomb');
+                expect(stats.failedRecords).toBe(1);
+            });
+            it('allows GZIP with ISIZE within limit', async () => {
+                const items = [makeTestEvent('valid-1')];
+                const envelope = await makeGzipCompressedEnvelope(items);
+                const record = makeSqsRecord({ messageBody: envelope }, 'msg-gzip-valid');
+                const { items: result, failedMessageIds } = await (0, sqs_unbundle_1.unbundleRecords)([record], {
+                    maxDecompressedSizeBytes: 10 * 1024 * 1024,
+                });
+                expect(result).toHaveLength(1);
+                expect(failedMessageIds).toHaveLength(0);
+            });
+            it('pre-check catches bomb even when ISIZE is exactly at limit + 1', async () => {
+                const limit = 1000;
+                const gzipHeader = Buffer.from([0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03]);
+                const emptyDeflate = Buffer.from([0x03, 0x00]);
+                const crc32 = Buffer.from([0x00, 0x00, 0x00, 0x00]);
+                const fakeIsize = Buffer.alloc(4);
+                fakeIsize.writeUInt32LE(limit + 1, 0);
+                const fakeGzip = Buffer.concat([gzipHeader, emptyDeflate, crc32, fakeIsize]);
+                const base64 = fakeGzip.toString('base64');
+                const bombEnvelope = {
+                    v: 1,
+                    c: sqs_bundled_client_types_1.CompressionAlgorithm.GZIP,
+                    n: 1,
+                    s: 100,
+                    p: base64,
+                };
+                const record = makeSqsRecord({ messageBody: bombEnvelope }, 'msg-boundary-bomb');
+                const { failedMessageIds } = await (0, sqs_unbundle_1.unbundleRecords)([record], {
+                    maxDecompressedSizeBytes: limit,
+                });
+                expect(failedMessageIds).toContain('msg-boundary-bomb');
+            });
+        });
+        describe('empty GZIP bundle', () => {
+            it('unbundles empty GZIP compressed array', async () => {
+                const envelope = await makeGzipCompressedEnvelope([]);
+                const record = makeSqsRecord({ messageBody: envelope }, 'msg-empty-gzip');
+                const { items, stats } = await (0, sqs_unbundle_1.unbundleRecords)([record]);
+                expect(items).toHaveLength(0);
+                expect(stats.bundledSqsRecords).toBe(1);
+                expect(stats.totalItems).toBe(0);
+            });
+        });
+        describe('Unicode characters in GZIP payload', () => {
+            it('preserves emoji through GZIP compression', async () => {
+                const items = [
+                    { eventId: 'emoji-1', content: '🎉🚀💻🌍✨' },
+                    { eventId: 'emoji-2', content: '👋🏽👨‍👩‍👧‍👦🏳️‍🌈' },
+                ];
+                const envelope = await makeGzipCompressedEnvelope(items);
+                const record = makeSqsRecord({ messageBody: envelope });
+                const { items: result } = await (0, sqs_unbundle_1.unbundleRecords)([record]);
+                expect(result).toHaveLength(2);
+                expect(result[0].content).toBe('🎉🚀💻🌍✨');
+                expect(result[1].content).toBe('👋🏽👨‍👩‍👧‍👦🏳️‍🌈');
+            });
+            it('preserves CJK characters through GZIP compression', async () => {
+                const items = [
+                    { eventId: 'cjk-1', content: '中文测试：欢迎使用' },
+                    { eventId: 'cjk-2', content: 'こんにちは世界 ひらがな カタカナ' },
+                    { eventId: 'cjk-3', content: '안녕하세요 세계' },
+                ];
+                const envelope = await makeGzipCompressedEnvelope(items);
+                const record = makeSqsRecord({ messageBody: envelope });
+                const { items: result } = await (0, sqs_unbundle_1.unbundleRecords)([record]);
+                expect(result).toHaveLength(3);
+                expect(result[0].content).toBe('中文测试：欢迎使用');
+                expect(result[1].content).toBe('こんにちは世界 ひらがな カタカナ');
+                expect(result[2].content).toBe('안녕하세요 세계');
+            });
+            it('preserves special characters and mixed scripts through GZIP compression', async () => {
+                const items = [
+                    { eventId: 'special-1', content: '∑∫∂∇ε → ∞ × ∈ ⊆ ∀∃' },
+                    { eventId: 'special-2', content: 'العربية: مرحبا بكم' },
+                    { eventId: 'mixed', content: 'Hello 世界 🌏 مرحبا Привет' },
+                    { eventId: 'combining', content: 'e\u0301 n\u0303 c\u0327' },
+                ];
+                const envelope = await makeGzipCompressedEnvelope(items);
+                const record = makeSqsRecord({ messageBody: envelope });
+                const { items: result } = await (0, sqs_unbundle_1.unbundleRecords)([record]);
+                expect(result).toHaveLength(4);
+                for (let i = 0; i < items.length; i++) {
+                    expect(result[i].content).toBe(items[i].content);
+                    const originalBytes = Buffer.from(items[i].content, 'utf8');
+                    const recoveredBytes = Buffer.from(result[i].content, 'utf8');
+                    expect(recoveredBytes.equals(originalBytes)).toBe(true);
+                }
+            });
+        });
+        describe('GZIP with invalid magic bytes', () => {
+            it('fails gracefully for buffer with wrong magic bytes', async () => {
+                const wrongMagic = Buffer.from([0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03]);
+                const filler = Buffer.alloc(10);
+                const invalidGzip = Buffer.concat([wrongMagic, filler]);
+                const base64 = invalidGzip.toString('base64');
+                const badEnvelope = {
+                    v: 1,
+                    c: sqs_bundled_client_types_1.CompressionAlgorithm.GZIP,
+                    n: 1,
+                    s: 100,
+                    p: base64,
+                };
+                const record = makeSqsRecord({ messageBody: badEnvelope }, 'msg-wrong-magic');
+                const { failedMessageIds } = await (0, sqs_unbundle_1.unbundleRecords)([record]);
+                expect(failedMessageIds).toContain('msg-wrong-magic');
+            });
+            it('fails gracefully for buffer starting with valid magic but corrupted data', async () => {
+                const validMagic = Buffer.from([0x1f, 0x8b]);
+                const garbage = Buffer.from('this is not valid gzip data after magic');
+                const invalidGzip = Buffer.concat([validMagic, garbage]);
+                const base64 = invalidGzip.toString('base64');
+                const badEnvelope = {
+                    v: 1,
+                    c: sqs_bundled_client_types_1.CompressionAlgorithm.GZIP,
+                    n: 1,
+                    s: 100,
+                    p: base64,
+                };
+                const record = makeSqsRecord({ messageBody: badEnvelope }, 'msg-corrupt-gzip');
+                const { failedMessageIds } = await (0, sqs_unbundle_1.unbundleRecords)([record]);
+                expect(failedMessageIds).toContain('msg-corrupt-gzip');
+            });
+        });
+        describe('GZIP minimum size edge cases', () => {
+            it('handles buffer exactly 18 bytes (minimum valid)', async () => {
+                const minBuffer = Buffer.alloc(18);
+                minBuffer[0] = 0x1f;
+                minBuffer[1] = 0x8b;
+                const size = (0, compression_1.getGzipUncompressedSize)(minBuffer);
+                expect(size).toBe(0);
+            });
+            it('returns undefined for buffer exactly 17 bytes (too small)', async () => {
+                const tooSmall = Buffer.alloc(17);
+                tooSmall[0] = 0x1f;
+                tooSmall[1] = 0x8b;
+                const size = (0, compression_1.getGzipUncompressedSize)(tooSmall);
+                expect(size).toBeUndefined();
+            });
+            it('fails gracefully for 17-byte GZIP envelope', async () => {
+                const tooSmall = Buffer.alloc(17);
+                tooSmall[0] = 0x1f;
+                tooSmall[1] = 0x8b;
+                const base64 = tooSmall.toString('base64');
+                const badEnvelope = {
+                    v: 1,
+                    c: sqs_bundled_client_types_1.CompressionAlgorithm.GZIP,
+                    n: 1,
+                    s: 100,
+                    p: base64,
+                };
+                const record = makeSqsRecord({ messageBody: badEnvelope }, 'msg-too-small');
+                const { failedMessageIds } = await (0, sqs_unbundle_1.unbundleRecords)([record]);
+                expect(failedMessageIds).toContain('msg-too-small');
+            });
+        });
+        describe('GZIP timeout protection', () => {
+            it('CompressionTimeoutError has correct properties', () => {
+                const error = new compression_1.CompressionTimeoutError(compression_1.CompressionOperation.DECOMPRESS, 100);
+                expect(error).toBeInstanceOf(Error);
+                expect(error.name).toBe('CompressionTimeoutError');
+                expect(error.operation).toBe('decompress');
+                expect(error.timeoutMs).toBe(100);
+                expect(error.message).toContain('timed out after 100ms');
+            });
+            it('GZIP decompression respects timeout option', async () => {
+                const items = [makeTestEvent('timeout-test')];
+                const envelope = await makeGzipCompressedEnvelope(items);
+                const record = makeSqsRecord({ messageBody: envelope });
+                const { items: result, failedMessageIds } = await (0, sqs_unbundle_1.unbundleRecords)([record], {
+                    timeoutMs: 10000,
+                });
+                expect(result).toHaveLength(1);
+                expect(failedMessageIds).toHaveLength(0);
+            });
+        });
+        describe('large GZIP near SQS limit', () => {
+            it('decompresses large GZIP bundle near 256KB compressed', async () => {
+                const items = Array.from({ length: 200 }, (_, i) => ({
+                    eventId: `large-${i}`,
+                    name: 'page_view',
+                    data: `repeated-content-for-compression-${i}-`.repeat(50),
+                    value: i * 1.5,
+                }));
+                const envelope = await makeGzipCompressedEnvelope(items);
+                const compressedSize = Buffer.byteLength(JSON.stringify(envelope.p), 'utf8');
+                console.log(`Large GZIP test: compressed payload ~${Math.round(compressedSize / 1024)}KB`);
+                const record = makeSqsRecord({ messageBody: envelope }, 'msg-large-gzip');
+                const { items: result, failedMessageIds } = await (0, sqs_unbundle_1.unbundleRecords)([record]);
+                expect(failedMessageIds).toHaveLength(0);
+                expect(result).toHaveLength(200);
+                expect(result[0].eventId).toBe('large-0');
+                expect(result[199].eventId).toBe('large-199');
+            });
+            it('handles GZIP with maximum decompressed size exactly at limit', async () => {
+                const items = [{ eventId: 'boundary', data: 'x'.repeat(5000) }];
+                const envelope = await makeGzipCompressedEnvelope(items);
+                const record = makeSqsRecord({ messageBody: envelope });
+                const { items: result, failedMessageIds } = await (0, sqs_unbundle_1.unbundleRecords)([record], {
+                    maxDecompressedSizeBytes: 10 * 1024,
+                });
+                expect(failedMessageIds).toHaveLength(0);
+                expect(result).toHaveLength(1);
+            });
+        });
+    });
+});
+describe('getGzipUncompressedSize', () => {
+    it('returns correct size for valid GZIP', async () => {
+        const originalData = 'Hello, World! This is a test.';
+        const compressed = await gzipAsync(Buffer.from(originalData, 'utf8'));
+        const size = (0, compression_1.getGzipUncompressedSize)(compressed);
+        expect(size).toBe(Buffer.byteLength(originalData, 'utf8'));
+    });
+    it('returns correct size for larger payload', async () => {
+        const originalData = 'x'.repeat(10000);
+        const compressed = await gzipAsync(Buffer.from(originalData, 'utf8'));
+        const size = (0, compression_1.getGzipUncompressedSize)(compressed);
+        expect(size).toBe(10000);
+    });
+    it('returns undefined for buffer too small', () => {
+        const tooSmall = Buffer.alloc(17);
+        tooSmall[0] = 0x1f;
+        tooSmall[1] = 0x8b;
+        expect((0, compression_1.getGzipUncompressedSize)(tooSmall)).toBeUndefined();
+    });
+    it('returns undefined for wrong magic bytes', () => {
+        const wrongMagic = Buffer.alloc(20);
+        wrongMagic[0] = 0x00;
+        wrongMagic[1] = 0x00;
+        expect((0, compression_1.getGzipUncompressedSize)(wrongMagic)).toBeUndefined();
+    });
+    it('returns undefined for empty buffer', () => {
+        expect((0, compression_1.getGzipUncompressedSize)(Buffer.alloc(0))).toBeUndefined();
+    });
+    it('returns undefined for single byte buffer', () => {
+        expect((0, compression_1.getGzipUncompressedSize)(Buffer.from([0x1f]))).toBeUndefined();
+    });
+    it('returns undefined for buffer with only magic bytes', () => {
+        expect((0, compression_1.getGzipUncompressedSize)(Buffer.from([0x1f, 0x8b]))).toBeUndefined();
+    });
+    it('returns 0 for GZIP with ISIZE = 0', () => {
+        const buffer = Buffer.alloc(18);
+        buffer[0] = 0x1f;
+        buffer[1] = 0x8b;
+        const size = (0, compression_1.getGzipUncompressedSize)(buffer);
+        expect(size).toBe(0);
+    });
+    it('reads ISIZE correctly as little-endian', async () => {
+        const buffer = Buffer.alloc(18);
+        buffer[0] = 0x1f;
+        buffer[1] = 0x8b;
+        buffer.writeUInt32LE(0x12345678, 14);
+        const size = (0, compression_1.getGzipUncompressedSize)(buffer);
+        expect(size).toBe(0x12345678);
+    });
+    it('handles maximum 32-bit ISIZE value', () => {
+        const buffer = Buffer.alloc(18);
+        buffer[0] = 0x1f;
+        buffer[1] = 0x8b;
+        buffer.writeUInt32LE(0xffffffff, 14);
+        const size = (0, compression_1.getGzipUncompressedSize)(buffer);
+        expect(size).toBe(0xffffffff);
+    });
+    it('correctly extracts size from real GZIP data', async () => {
+        const testSizes = [1, 10, 100, 1000, 50000];
+        for (const testSize of testSizes) {
+            const originalData = 'a'.repeat(testSize);
+            const compressed = await gzipAsync(Buffer.from(originalData, 'utf8'));
+            const size = (0, compression_1.getGzipUncompressedSize)(compressed);
+            expect(size).toBe(testSize);
+        }
+    });
+    it('handles JSON array compression correctly', async () => {
+        const items = [{ id: 1 }, { id: 2 }, { id: 3 }];
+        const json = JSON.stringify(items);
+        const compressed = await gzipAsync(Buffer.from(json, 'utf8'));
+        const size = (0, compression_1.getGzipUncompressedSize)(compressed);
+        expect(size).toBe(Buffer.byteLength(json, 'utf8'));
+    });
 });
 //# sourceMappingURL=sqs-unbundle.spec.js.map