@adtrackify/at-service-common 4.0.25 → 4.0.28

package/dist/esm/__tests__/clients/sqs-bundling-contracts.spec.js

@@ -1,539 +1,539 @@
-import * as zlib from 'zlib';
-import { promisify } from 'util';
-import { unbundleRecords } from '../../clients/generic/sqs-unbundle';
-const gzip = promisify(zlib.gzip);
-const MESSAGE_TYPES = {
-    TRACKING_EVENT_COLLECT: 'TRACKING_EVENT_COLLECT',
-    SESSION_EVENT_COLLECT: 'SESSION_EVENT_COLLECT',
-    LOG_EVENT_COLLECT: 'LOG_EVENT_COLLECT',
-};
-async function createBundledMessage(messageType, items) {
-    const json = JSON.stringify(items);
-    const uncompressedBuffer = Buffer.from(json, 'utf-8');
-    const compressedBuffer = await gzip(uncompressedBuffer);
-    const base64 = compressedBuffer.toString('base64');
-    const envelope = {
-        v: 1,
-        c: 'gzip',
-        n: items.length,
-        p: base64,
-        s: uncompressedBuffer.length,
-    };
-    const wrapped = {
-        messageId: crypto.randomUUID(),
-        messageType,
-        messageTime: new Date().toISOString(),
-        messageBody: envelope,
-    };
-    return wrapped;
-}
-function createSQSRecord(messageBody, messageId) {
-    return {
-        messageId: messageId ?? crypto.randomUUID(),
-        receiptHandle: 'test-receipt-handle',
-        body: messageBody,
-        attributes: {
-            ApproximateReceiveCount: '1',
-            SentTimestamp: Date.now().toString(),
-            SenderId: 'test-sender',
-            ApproximateFirstReceiveTimestamp: Date.now().toString(),
-        },
-        messageAttributes: {},
-        md5OfBody: 'test-md5',
-        eventSource: 'aws:sqs',
-        eventSourceARN: 'arn:aws:sqs:us-east-1:123456789:test-queue',
-        awsRegion: 'us-east-1',
-    };
-}
-describe('Producer-Consumer Contract Tests', () => {
-    describe('TRACKING_EVENT_COLLECT Contract', () => {
-        it('producer creates valid InternalSQSMessage<BundledEnvelope> structure', async () => {
-            const trackingEvents = [
-                {
-                    pixelId: 'px_test_001',
-                    id: 'evt_001',
-                    trackingEvent: {
-                        name: 'PageView',
-                        context: { properties: { page: '/products' } },
-                        data: { url: 'https://example.com/products' },
-                    },
-                    edgeContext: {
-                        ipAddress: '192.168.1.1',
-                        userAgent: 'Mozilla/5.0',
-                        requestHeaders: { 'cf-connecting-ip': '192.168.1.1' },
-                    },
-                },
-                {
-                    pixelId: 'px_test_002',
-                    id: 'evt_002',
-                    _encrypted: 'base64_encrypted_payload',
-                },
-            ];
-            const bundledMessage = await createBundledMessage(MESSAGE_TYPES.TRACKING_EVENT_COLLECT, trackingEvents);
-            expect(bundledMessage).toMatchObject({
-                messageId: expect.any(String),
-                messageType: 'TRACKING_EVENT_COLLECT',
-                messageTime: expect.any(String),
-                messageBody: {
-                    v: 1,
-                    c: 'gzip',
-                    n: 2,
-                    p: expect.any(String),
-                    s: expect.any(Number),
-                },
-            });
-            expect(new Date(bundledMessage.messageTime).toISOString()).toBe(bundledMessage.messageTime);
-        });
-        it('consumer unbundleRecords extracts items matching TrackingEventCollectMessage', async () => {
-            const originalItems = [
-                {
-                    pixelId: 'px_tracking_001',
-                    id: 'evt_tracking_001',
-                    trackingEvent: {
-                        name: 'AddToCart',
-                        eventName: 'add_to_cart',
-                        context: {
-                            properties: {
-                                sessionId: 'sess_001',
-                                page: { path: '/products/widget' },
-                            },
-                        },
-                        data: {
-                            productId: 'prod_001',
-                            value: 29.99,
-                            currency: 'USD',
-                        },
-                    },
-                    edgeContext: {
-                        ipAddress: '10.0.0.1',
-                        userAgent: 'Chrome/120',
-                        requestHeaders: {
-                            'cf-connecting-ip': '10.0.0.1',
-                            'user-agent': 'Chrome/120',
-                            'accept-language': 'en-US',
-                        },
-                        cf: { country: 'US', colo: 'SJC' },
-                    },
-                },
-                {
-                    pixelId: 'px_tracking_002',
-                    _encrypted: 'encrypted_payload_base64',
-                    edgeContext: {
-                        ipAddress: '10.0.0.2',
-                        userAgent: 'Safari/17',
-                        requestHeaders: {},
-                    },
-                },
-            ];
-            const bundledMessage = await createBundledMessage(MESSAGE_TYPES.TRACKING_EVENT_COLLECT, originalItems);
-            const serialized = JSON.stringify(bundledMessage);
-            const sqsRecord = createSQSRecord(serialized);
-            const result = await unbundleRecords([sqsRecord]);
-            expect(result.items).toHaveLength(2);
-            expect(result.failedMessageIds).toHaveLength(0);
-            expect(result.stats.bundledSqsRecords).toBe(1);
-            expect(result.stats.totalItems).toBe(2);
-            const item1 = result.items[0];
-            expect(item1.pixelId).toBe('px_tracking_001');
-            expect(item1.trackingEvent?.name).toBe('AddToCart');
-            expect(item1.trackingEvent?.data?.productId).toBe('prod_001');
-            expect(item1.edgeContext?.ipAddress).toBe('10.0.0.1');
-            const item2 = result.items[1];
-            expect(item2.pixelId).toBe('px_tracking_002');
-            expect(item2._encrypted).toBe('encrypted_payload_base64');
-        });
-        it('consumer validates required pixelId field exists', async () => {
-            const items = [{ pixelId: 'px_valid', trackingEvent: { name: 'PageView' } }];
-            const bundledMessage = await createBundledMessage(MESSAGE_TYPES.TRACKING_EVENT_COLLECT, items);
-            const serialized = JSON.stringify(bundledMessage);
-            const sqsRecord = createSQSRecord(serialized);
-            const result = await unbundleRecords([sqsRecord]);
-            expect(result.items).toHaveLength(1);
-            expect(result.items[0].pixelId).toBe('px_valid');
-        });
-    });
-    describe('SESSION_EVENT_COLLECT Contract', () => {
-        it('producer creates valid InternalSQSMessage<BundledEnvelope> structure', async () => {
-            const sessionEvents = [
-                {
-                    pixelId: 'px_session_001',
-                    id: 'sess_evt_001',
-                    sessionEvent: {
-                        id: 'sess_evt_001',
-                        type: 'session',
-                        name: 'session_end',
-                        version: '1.0',
-                        pixelId: 'px_session_001',
-                        sessionId: 'sess_001',
-                        context: {
-                            identity: { identityId: 'id_001' },
-                            properties: { sessionId: 'sess_001' },
-                        },
-                        data: {
-                            messageId: 'msg_001',
-                            pixelId_sessionId: 'px_session_001_sess_001',
-                            isFinal: true,
-                            sessionStartAt: '2024-01-01T00:00:00.000Z',
-                            sessionEndAt: '2024-01-01T00:30:00.000Z',
-                            sessionDuration: 1800000,
-                            pageCount: 5,
-                            totalActiveTime: 600000,
-                        },
-                    },
-                    edgeContext: {
-                        ipAddress: '192.168.1.100',
-                        userAgent: 'Mozilla/5.0',
-                        requestHeaders: { 'cf-connecting-ip': '192.168.1.100' },
-                        cf: { country: 'US' },
-                    },
-                },
-            ];
-            const bundledMessage = await createBundledMessage(MESSAGE_TYPES.SESSION_EVENT_COLLECT, sessionEvents);
-            expect(bundledMessage).toMatchObject({
-                messageId: expect.any(String),
-                messageType: 'SESSION_EVENT_COLLECT',
-                messageTime: expect.any(String),
-                messageBody: {
-                    v: 1,
-                    c: 'gzip',
-                    n: 1,
-                    p: expect.any(String),
-                    s: expect.any(Number),
-                },
-            });
-        });
-        it('consumer unbundleRecords extracts items matching SessionCollectMessage', async () => {
-            const originalItems = [
-                {
-                    pixelId: 'px_sess_001',
-                    id: 'sess_record_001',
-                    sessionEvent: {
-                        id: 'sess_record_001',
-                        type: 'session',
-                        name: 'session_start',
-                        version: '1.0',
-                        pixelId: 'px_sess_001',
-                        sessionId: 'sess_abc123',
-                        context: {
-                            identity: { identityId: 'identity_001' },
-                            properties: {
-                                sessionId: 'sess_abc123',
-                                userAgent: 'Chrome/120',
-                                ipAddress: '10.0.0.100',
-                            },
-                        },
-                        data: {
-                            messageId: 'msg_sess_001',
-                            pixelId_sessionId: 'px_sess_001_sess_abc123',
-                            isFinal: false,
-                            sessionStartAt: '2024-01-15T10:00:00.000Z',
-                            landingPage: '/home',
-                            returnTier: 'new',
-                        },
-                    },
-                    edgeContext: {
-                        ipAddress: '10.0.0.100',
-                        userAgent: 'Chrome/120',
-                        requestHeaders: {},
-                        cf: { country: 'CA', region: 'ON', city: 'Toronto' },
-                    },
-                },
-                {
-                    pixelId: 'px_sess_002',
-                    id: 'sess_record_002',
-                    sessionEvent: {
-                        id: 'sess_record_002',
-                        type: 'session',
-                        name: 'session_end',
-                        pixelId: 'px_sess_002',
-                        sessionId: 'sess_xyz789',
-                        data: {
-                            isFinal: true,
-                            sessionDuration: 300000,
-                            pageCount: 3,
-                            endReason: 'timeout',
-                        },
-                    },
-                },
-            ];
-            const bundledMessage = await createBundledMessage(MESSAGE_TYPES.SESSION_EVENT_COLLECT, originalItems);
-            const serialized = JSON.stringify(bundledMessage);
-            const sqsRecord = createSQSRecord(serialized);
-            const result = await unbundleRecords([sqsRecord]);
-            expect(result.items).toHaveLength(2);
-            expect(result.failedMessageIds).toHaveLength(0);
-            expect(result.stats.bundledSqsRecords).toBe(1);
-            expect(result.stats.totalItems).toBe(2);
-            const item1 = result.items[0];
-            expect(item1.pixelId).toBe('px_sess_001');
-            expect(item1.sessionEvent).toBeDefined();
-            expect(item1.sessionEvent.name).toBe('session_start');
-            expect(item1.sessionEvent.sessionId).toBe('sess_abc123');
-            expect(item1.sessionEvent.data?.landingPage).toBe('/home');
-            expect(item1.edgeContext?.cf?.country).toBe('CA');
-            const item2 = result.items[1];
-            expect(item2.pixelId).toBe('px_sess_002');
-            expect(item2.sessionEvent.name).toBe('session_end');
-            expect(item2.sessionEvent.data?.isFinal).toBe(true);
-            expect(item2.sessionEvent.data?.endReason).toBe('timeout');
-        });
-        it('consumer validates required sessionEvent field exists', async () => {
-            const items = [
-                {
-                    pixelId: 'px_valid_session',
-                    sessionEvent: {
-                        name: 'session_update',
-                        pixelId: 'px_valid_session',
-                        sessionId: 'sess_valid',
-                    },
-                },
-            ];
-            const bundledMessage = await createBundledMessage(MESSAGE_TYPES.SESSION_EVENT_COLLECT, items);
-            const serialized = JSON.stringify(bundledMessage);
-            const sqsRecord = createSQSRecord(serialized);
-            const result = await unbundleRecords([sqsRecord]);
-            expect(result.items).toHaveLength(1);
-            expect(result.items[0].sessionEvent).toBeDefined();
-            expect(result.items[0].sessionEvent.sessionId).toBe('sess_valid');
-        });
-    });
-    describe('LOG_EVENT_COLLECT Contract', () => {
-        it('producer creates valid InternalSQSMessage<BundledEnvelope> structure', async () => {
-            const logEvents = [
-                {
-                    pixelId: 'px_log_001',
-                    logEvent: {
-                        name: 'error',
-                        type: 'client_error',
-                        message: 'Failed to load resource',
-                        stack: 'Error at line 42',
-                    },
-                    requestHeaders: { 'user-agent': 'Chrome/120' },
-                },
-            ];
-            const bundledMessage = await createBundledMessage(MESSAGE_TYPES.LOG_EVENT_COLLECT, logEvents);
-            expect(bundledMessage).toMatchObject({
-                messageId: expect.any(String),
-                messageType: 'LOG_EVENT_COLLECT',
-                messageTime: expect.any(String),
-                messageBody: {
-                    v: 1,
-                    c: 'gzip',
-                    n: 1,
-                    p: expect.any(String),
-                    s: expect.any(Number),
-                },
-            });
-        });
-        it('consumer unbundleRecords extracts items matching LogCollectMessage', async () => {
-            const originalItems = [
-                {
-                    pixelId: 'px_log_001',
-                    logEvent: {
-                        name: 'performance',
-                        type: 'web_vital',
-                        metric: 'LCP',
-                        value: 2500,
-                        timestamp: Date.now(),
-                    },
-                    requestHeaders: {
-                        'user-agent': 'Safari/17',
-                        'cf-connecting-ip': '172.16.0.1',
-                    },
-                },
-                {
-                    pixelId: 'px_log_002',
-                    _encrypted: 'encrypted_log_payload',
-                },
-                {
-                    pixelId: 'px_log_003',
-                    logEvent: {
-                        name: 'debug',
-                        type: 'pixel_init',
-                        data: { version: '2.1.0', config: { trackClicks: true } },
-                    },
-                },
-            ];
-            const bundledMessage = await createBundledMessage(MESSAGE_TYPES.LOG_EVENT_COLLECT, originalItems);
-            const serialized = JSON.stringify(bundledMessage);
-            const sqsRecord = createSQSRecord(serialized);
-            const result = await unbundleRecords([sqsRecord]);
-            expect(result.items).toHaveLength(3);
-            expect(result.failedMessageIds).toHaveLength(0);
-            expect(result.stats.bundledSqsRecords).toBe(1);
-            expect(result.stats.totalItems).toBe(3);
-            const item1 = result.items[0];
-            expect(item1.pixelId).toBe('px_log_001');
-            expect(item1.logEvent?.name).toBe('performance');
-            expect(item1.logEvent?.metric).toBe('LCP');
-            expect(item1.requestHeaders?.['user-agent']).toBe('Safari/17');
-            const item2 = result.items[1];
-            expect(item2.pixelId).toBe('px_log_002');
-            expect(item2._encrypted).toBe('encrypted_log_payload');
-            const item3 = result.items[2];
-            expect(item3.pixelId).toBe('px_log_003');
-            expect(item3.logEvent?.type).toBe('pixel_init');
-        });
-    });
-    describe('Cross-Queue Contract Consistency', () => {
-        it('all message types use identical BundledEnvelope structure', async () => {
-            const trackingMessage = await createBundledMessage(MESSAGE_TYPES.TRACKING_EVENT_COLLECT, [{ pixelId: 'px1' }]);
-            const sessionMessage = await createBundledMessage(MESSAGE_TYPES.SESSION_EVENT_COLLECT, [
-                { pixelId: 'px2', sessionEvent: { name: 'test' } },
-            ]);
-            const logMessage = await createBundledMessage(MESSAGE_TYPES.LOG_EVENT_COLLECT, [{ pixelId: 'px3' }]);
-            const envelopeKeys = ['c', 'n', 'p', 's', 'v'];
-            expect(Object.keys(trackingMessage.messageBody).sort()).toEqual(envelopeKeys);
-            expect(Object.keys(sessionMessage.messageBody).sort()).toEqual(envelopeKeys);
-            expect(Object.keys(logMessage.messageBody).sort()).toEqual(envelopeKeys);
-            expect(trackingMessage.messageBody.v).toBe(1);
-            expect(trackingMessage.messageBody.c).toBe('gzip');
-            expect(sessionMessage.messageBody.v).toBe(1);
-            expect(sessionMessage.messageBody.c).toBe('gzip');
-            expect(logMessage.messageBody.v).toBe(1);
-            expect(logMessage.messageBody.c).toBe('gzip');
-        });
-        it('all message types use identical InternalSQSMessage wrapper structure', async () => {
-            const trackingMessage = await createBundledMessage(MESSAGE_TYPES.TRACKING_EVENT_COLLECT, [{ pixelId: 'px1' }]);
-            const sessionMessage = await createBundledMessage(MESSAGE_TYPES.SESSION_EVENT_COLLECT, [
-                { pixelId: 'px2', sessionEvent: { name: 'test' } },
-            ]);
-            const logMessage = await createBundledMessage(MESSAGE_TYPES.LOG_EVENT_COLLECT, [{ pixelId: 'px3' }]);
-            const wrapperKeys = ['messageBody', 'messageId', 'messageTime', 'messageType'];
-            expect(Object.keys(trackingMessage).sort()).toEqual(wrapperKeys);
-            expect(Object.keys(sessionMessage).sort()).toEqual(wrapperKeys);
-            expect(Object.keys(logMessage).sort()).toEqual(wrapperKeys);
-            expect([
-                MESSAGE_TYPES.TRACKING_EVENT_COLLECT,
-                MESSAGE_TYPES.SESSION_EVENT_COLLECT,
-                MESSAGE_TYPES.LOG_EVENT_COLLECT,
-            ]).toContain(trackingMessage.messageType);
-            expect([
-                MESSAGE_TYPES.TRACKING_EVENT_COLLECT,
-                MESSAGE_TYPES.SESSION_EVENT_COLLECT,
-                MESSAGE_TYPES.LOG_EVENT_COLLECT,
-            ]).toContain(sessionMessage.messageType);
-            expect([
-                MESSAGE_TYPES.TRACKING_EVENT_COLLECT,
-                MESSAGE_TYPES.SESSION_EVENT_COLLECT,
-                MESSAGE_TYPES.LOG_EVENT_COLLECT,
-            ]).toContain(logMessage.messageType);
-        });
-        it('unbundleRecords handles all message types uniformly', async () => {
-            const tracking = await createBundledMessage(MESSAGE_TYPES.TRACKING_EVENT_COLLECT, [
-                { pixelId: 'px_t1', trackingEvent: { name: 'PageView' } },
-                { pixelId: 'px_t2', trackingEvent: { name: 'AddToCart' } },
-            ]);
-            const session = await createBundledMessage(MESSAGE_TYPES.SESSION_EVENT_COLLECT, [
-                { pixelId: 'px_s1', sessionEvent: { name: 'session_start' } },
-            ]);
-            const log = await createBundledMessage(MESSAGE_TYPES.LOG_EVENT_COLLECT, [
-                { pixelId: 'px_l1', logEvent: { name: 'error' } },
-                { pixelId: 'px_l2', logEvent: { name: 'debug' } },
-                { pixelId: 'px_l3', logEvent: { name: 'info' } },
-            ]);
-            const records = [
-                createSQSRecord(JSON.stringify(tracking), 'msg-tracking'),
-                createSQSRecord(JSON.stringify(session), 'msg-session'),
-                createSQSRecord(JSON.stringify(log), 'msg-log'),
-            ];
-            const result = await unbundleRecords(records);
-            expect(result.failedMessageIds).toHaveLength(0);
-            expect(result.stats.bundledSqsRecords).toBe(3);
-            expect(result.stats.totalItems).toBe(6);
-            expect(result.items).toHaveLength(6);
-            const pixelIds = result.items.map((item) => item.pixelId);
-            expect(pixelIds).toContain('px_t1');
-            expect(pixelIds).toContain('px_t2');
-            expect(pixelIds).toContain('px_s1');
-            expect(pixelIds).toContain('px_l1');
-            expect(pixelIds).toContain('px_l2');
-            expect(pixelIds).toContain('px_l3');
-        });
-    });
-    describe('Edge Cases and Error Handling', () => {
-        it('handles empty bundle gracefully', async () => {
-            const bundledMessage = await createBundledMessage(MESSAGE_TYPES.TRACKING_EVENT_COLLECT, []);
-            const sqsRecord = createSQSRecord(JSON.stringify(bundledMessage));
-            const result = await unbundleRecords([sqsRecord]);
-            expect(result.items).toHaveLength(0);
-            expect(result.failedMessageIds).toHaveLength(0);
-            expect(result.stats.bundledSqsRecords).toBe(1);
-            expect(result.stats.totalItems).toBe(0);
-        });
-        it('handles mixed bundled and legacy records in same batch', async () => {
-            const bundledMessage = await createBundledMessage(MESSAGE_TYPES.TRACKING_EVENT_COLLECT, [
-                { pixelId: 'px_bundled_1' },
-                { pixelId: 'px_bundled_2' },
-            ]);
-            const legacyItem = { pixelId: 'px_legacy' };
-            const records = [
-                createSQSRecord(JSON.stringify(bundledMessage), 'msg-bundled'),
-                createSQSRecord(JSON.stringify(legacyItem), 'msg-legacy'),
-            ];
-            const result = await unbundleRecords(records);
-            expect(result.items).toHaveLength(3);
-            expect(result.stats.bundledSqsRecords).toBe(1);
-            expect(result.stats.legacySqsRecords).toBe(1);
-            expect(result.stats.totalItems).toBe(3);
-            const pixelIds = result.items.map((item) => item.pixelId);
-            expect(pixelIds).toContain('px_bundled_1');
-            expect(pixelIds).toContain('px_bundled_2');
-            expect(pixelIds).toContain('px_legacy');
-        });
-        it('preserves exact item data through bundle/unbundle cycle', async () => {
-            const complexItem = {
-                pixelId: 'px_complex',
-                id: 'evt_complex',
-                dd: 1234567890,
-                trackingEvent: {
-                    name: 'Purchase',
-                    eventName: 'purchase',
-                    context: {
-                        properties: {
-                            sessionId: 'sess_xyz',
-                            page: { path: '/checkout/success', title: 'Order Complete' },
-                            device: { type: 'mobile', os: 'iOS', browser: 'Safari' },
-                        },
-                    },
-                    data: {
-                        orderId: 'order_12345',
-                        value: 199.99,
-                        currency: 'USD',
-                        items: [
-                            { sku: 'SKU001', name: 'Widget', quantity: 2, price: 49.99 },
-                            { sku: 'SKU002', name: 'Gadget', quantity: 1, price: 100.01 },
-                        ],
-                    },
-                },
-                edgeContext: {
-                    ipAddress: '2001:db8::1',
-                    userAgent: 'Mozilla/5.0 (iPhone; CPU iPhone OS 17_0)',
-                    requestHeaders: {
-                        'cf-connecting-ip': '2001:db8::1',
-                        'cf-ipcountry': 'US',
-                        'user-agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 17_0)',
-                        'accept-language': 'en-US,en;q=0.9',
-                    },
-                    cf: {
-                        country: 'US',
-                        region: 'CA',
-                        city: 'San Francisco',
-                        colo: 'SJC',
-                        timezone: 'America/Los_Angeles',
-                    },
-                },
-            };
-            const bundledMessage = await createBundledMessage(MESSAGE_TYPES.TRACKING_EVENT_COLLECT, [complexItem]);
-            const sqsRecord = createSQSRecord(JSON.stringify(bundledMessage));
-            const result = await unbundleRecords([sqsRecord]);
-            expect(result.items).toHaveLength(1);
-            const extracted = result.items[0];
-            expect(extracted).toEqual(complexItem);
-            expect(extracted.trackingEvent?.data?.items).toHaveLength(2);
-            expect(extracted?.trackingEvent?.data && (extracted?.trackingEvent?.data?.items)[0]?.sku).toBe('SKU001');
-            expect(extracted.edgeContext?.cf?.timezone).toBe('America/Los_Angeles');
-        });
-    });
-});
+import * as zlib from 'zlib';
+import { promisify } from 'util';
+import { unbundleRecords } from '../../clients/generic/sqs-unbundle';
+const gzip = promisify(zlib.gzip);
+const MESSAGE_TYPES = {
+    TRACKING_EVENT_COLLECT: 'TRACKING_EVENT_COLLECT',
+    SESSION_EVENT_COLLECT: 'SESSION_EVENT_COLLECT',
+    LOG_EVENT_COLLECT: 'LOG_EVENT_COLLECT',
+};
+async function createBundledMessage(messageType, items) {
+    const json = JSON.stringify(items);
+    const uncompressedBuffer = Buffer.from(json, 'utf-8');
+    const compressedBuffer = await gzip(uncompressedBuffer);
+    const base64 = compressedBuffer.toString('base64');
+    const envelope = {
+        v: 1,
+        c: 'gzip',
+        n: items.length,
+        p: base64,
+        s: uncompressedBuffer.length,
+    };
+    const wrapped = {
+        messageId: crypto.randomUUID(),
+        messageType,
+        messageTime: new Date().toISOString(),
+        messageBody: envelope,
+    };
+    return wrapped;
+}
+function createSQSRecord(messageBody, messageId) {
+    return {
+        messageId: messageId ?? crypto.randomUUID(),
+        receiptHandle: 'test-receipt-handle',
+        body: messageBody,
+        attributes: {
+            ApproximateReceiveCount: '1',
+            SentTimestamp: Date.now().toString(),
+            SenderId: 'test-sender',
+            ApproximateFirstReceiveTimestamp: Date.now().toString(),
+        },
+        messageAttributes: {},
+        md5OfBody: 'test-md5',
+        eventSource: 'aws:sqs',
+        eventSourceARN: 'arn:aws:sqs:us-east-1:123456789:test-queue',
+        awsRegion: 'us-east-1',
+    };
+}
+describe('Producer-Consumer Contract Tests', () => {
+    describe('TRACKING_EVENT_COLLECT Contract', () => {
+        it('producer creates valid InternalSQSMessage<BundledEnvelope> structure', async () => {
+            const trackingEvents = [
+                {
+                    pixelId: 'px_test_001',
+                    id: 'evt_001',
+                    trackingEvent: {
+                        name: 'PageView',
+                        context: { properties: { page: '/products' } },
+                        data: { url: 'https://example.com/products' },
+                    },
+                    edgeContext: {
+                        ipAddress: '192.168.1.1',
+                        userAgent: 'Mozilla/5.0',
+                        requestHeaders: { 'cf-connecting-ip': '192.168.1.1' },
+                    },
+                },
+                {
+                    pixelId: 'px_test_002',
+                    id: 'evt_002',
+                    _encrypted: 'base64_encrypted_payload',
+                },
+            ];
+            const bundledMessage = await createBundledMessage(MESSAGE_TYPES.TRACKING_EVENT_COLLECT, trackingEvents);
+            expect(bundledMessage).toMatchObject({
+                messageId: expect.any(String),
+                messageType: 'TRACKING_EVENT_COLLECT',
+                messageTime: expect.any(String),
+                messageBody: {
+                    v: 1,
+                    c: 'gzip',
+                    n: 2,
+                    p: expect.any(String),
+                    s: expect.any(Number),
+                },
+            });
+            expect(new Date(bundledMessage.messageTime).toISOString()).toBe(bundledMessage.messageTime);
+        });
+        it('consumer unbundleRecords extracts items matching TrackingEventCollectMessage', async () => {
+            const originalItems = [
+                {
+                    pixelId: 'px_tracking_001',
+                    id: 'evt_tracking_001',
+                    trackingEvent: {
+                        name: 'AddToCart',
+                        eventName: 'add_to_cart',
+                        context: {
+                            properties: {
+                                sessionId: 'sess_001',
+                                page: { path: '/products/widget' },
+                            },
+                        },
+                        data: {
+                            productId: 'prod_001',
+                            value: 29.99,
+                            currency: 'USD',
+                        },
+                    },
+                    edgeContext: {
+                        ipAddress: '10.0.0.1',
+                        userAgent: 'Chrome/120',
+                        requestHeaders: {
+                            'cf-connecting-ip': '10.0.0.1',
+                            'user-agent': 'Chrome/120',
+                            'accept-language': 'en-US',
+                        },
+                        cf: { country: 'US', colo: 'SJC' },
+                    },
+                },
+                {
+                    pixelId: 'px_tracking_002',
+                    _encrypted: 'encrypted_payload_base64',
+                    edgeContext: {
+                        ipAddress: '10.0.0.2',
+                        userAgent: 'Safari/17',
+                        requestHeaders: {},
+                    },
+                },
+            ];
+            const bundledMessage = await createBundledMessage(MESSAGE_TYPES.TRACKING_EVENT_COLLECT, originalItems);
+            const serialized = JSON.stringify(bundledMessage);
+            const sqsRecord = createSQSRecord(serialized);
+            const result = await unbundleRecords([sqsRecord]);
+            expect(result.items).toHaveLength(2);
+            expect(result.failedMessageIds).toHaveLength(0);
+            expect(result.stats.bundledSqsRecords).toBe(1);
+            expect(result.stats.totalItems).toBe(2);
+            const item1 = result.items[0];
+            expect(item1.pixelId).toBe('px_tracking_001');
+            expect(item1.trackingEvent?.name).toBe('AddToCart');
+            expect(item1.trackingEvent?.data?.productId).toBe('prod_001');
+            expect(item1.edgeContext?.ipAddress).toBe('10.0.0.1');
+            const item2 = result.items[1];
+            expect(item2.pixelId).toBe('px_tracking_002');
+            expect(item2._encrypted).toBe('encrypted_payload_base64');
+        });
+        it('consumer validates required pixelId field exists', async () => {
+            const items = [{ pixelId: 'px_valid', trackingEvent: { name: 'PageView' } }];
+            const bundledMessage = await createBundledMessage(MESSAGE_TYPES.TRACKING_EVENT_COLLECT, items);
+            const serialized = JSON.stringify(bundledMessage);
+            const sqsRecord = createSQSRecord(serialized);
+            const result = await unbundleRecords([sqsRecord]);
+            expect(result.items).toHaveLength(1);
+            expect(result.items[0].pixelId).toBe('px_valid');
+        });
+    });
+    describe('SESSION_EVENT_COLLECT Contract', () => {
+        it('producer creates valid InternalSQSMessage<BundledEnvelope> structure', async () => {
+            const sessionEvents = [
+                {
+                    pixelId: 'px_session_001',
+                    id: 'sess_evt_001',
+                    sessionEvent: {
+                        id: 'sess_evt_001',
+                        type: 'session',
+                        name: 'session_end',
+                        version: '1.0',
+                        pixelId: 'px_session_001',
+                        sessionId: 'sess_001',
+                        context: {
+                            identity: { identityId: 'id_001' },
+                            properties: { sessionId: 'sess_001' },
+                        },
+                        data: {
+                            messageId: 'msg_001',
+                            pixelId_sessionId: 'px_session_001_sess_001',
+                            isFinal: true,
+                            sessionStartAt: '2024-01-01T00:00:00.000Z',
+                            sessionEndAt: '2024-01-01T00:30:00.000Z',
+                            sessionDuration: 1800000,
+                            pageCount: 5,
+                            totalActiveTime: 600000,
+                        },
+                    },
+                    edgeContext: {
+                        ipAddress: '192.168.1.100',
+                        userAgent: 'Mozilla/5.0',
+                        requestHeaders: { 'cf-connecting-ip': '192.168.1.100' },
+                        cf: { country: 'US' },
+                    },
+                },
+            ];
+            const bundledMessage = await createBundledMessage(MESSAGE_TYPES.SESSION_EVENT_COLLECT, sessionEvents);
+            expect(bundledMessage).toMatchObject({
+                messageId: expect.any(String),
+                messageType: 'SESSION_EVENT_COLLECT',
+                messageTime: expect.any(String),
+                messageBody: {
+                    v: 1,
+                    c: 'gzip',
+                    n: 1,
+                    p: expect.any(String),
+                    s: expect.any(Number),
+                },
+            });
+        });
+        it('consumer unbundleRecords extracts items matching SessionCollectMessage', async () => {
+            const originalItems = [
+                {
+                    pixelId: 'px_sess_001',
+                    id: 'sess_record_001',
+                    sessionEvent: {
+                        id: 'sess_record_001',
+                        type: 'session',
+                        name: 'session_start',
+                        version: '1.0',
+                        pixelId: 'px_sess_001',
+                        sessionId: 'sess_abc123',
+                        context: {
+                            identity: { identityId: 'identity_001' },
+                            properties: {
+                                sessionId: 'sess_abc123',
+                                userAgent: 'Chrome/120',
+                                ipAddress: '10.0.0.100',
+                            },
+                        },
+                        data: {
+                            messageId: 'msg_sess_001',
+                            pixelId_sessionId: 'px_sess_001_sess_abc123',
+                            isFinal: false,
+                            sessionStartAt: '2024-01-15T10:00:00.000Z',
+                            landingPage: '/home',
+                            returnTier: 'new',
+                        },
+                    },
+                    edgeContext: {
+                        ipAddress: '10.0.0.100',
+                        userAgent: 'Chrome/120',
+                        requestHeaders: {},
+                        cf: { country: 'CA', region: 'ON', city: 'Toronto' },
+                    },
+                },
+                {
+                    pixelId: 'px_sess_002',
+                    id: 'sess_record_002',
+                    sessionEvent: {
+                        id: 'sess_record_002',
+                        type: 'session',
+                        name: 'session_end',
+                        pixelId: 'px_sess_002',
+                        sessionId: 'sess_xyz789',
+                        data: {
+                            isFinal: true,
+                            sessionDuration: 300000,
+                            pageCount: 3,
+                            endReason: 'timeout',
+                        },
+                    },
+                },
+            ];
+            const bundledMessage = await createBundledMessage(MESSAGE_TYPES.SESSION_EVENT_COLLECT, originalItems);
+            const serialized = JSON.stringify(bundledMessage);
+            const sqsRecord = createSQSRecord(serialized);
+            const result = await unbundleRecords([sqsRecord]);
+            expect(result.items).toHaveLength(2);
+            expect(result.failedMessageIds).toHaveLength(0);
+            expect(result.stats.bundledSqsRecords).toBe(1);
+            expect(result.stats.totalItems).toBe(2);
+            const item1 = result.items[0];
+            expect(item1.pixelId).toBe('px_sess_001');
+            expect(item1.sessionEvent).toBeDefined();
+            expect(item1.sessionEvent.name).toBe('session_start');
+            expect(item1.sessionEvent.sessionId).toBe('sess_abc123');
+            expect(item1.sessionEvent.data?.landingPage).toBe('/home');
+            expect(item1.edgeContext?.cf?.country).toBe('CA');
+            const item2 = result.items[1];
+            expect(item2.pixelId).toBe('px_sess_002');
+            expect(item2.sessionEvent.name).toBe('session_end');
+            expect(item2.sessionEvent.data?.isFinal).toBe(true);
+            expect(item2.sessionEvent.data?.endReason).toBe('timeout');
+        });
+        it('consumer validates required sessionEvent field exists', async () => {
+            const items = [
+                {
+                    pixelId: 'px_valid_session',
+                    sessionEvent: {
+                        name: 'session_update',
+                        pixelId: 'px_valid_session',
+                        sessionId: 'sess_valid',
+                    },
+                },
+            ];
+            const bundledMessage = await createBundledMessage(MESSAGE_TYPES.SESSION_EVENT_COLLECT, items);
+            const serialized = JSON.stringify(bundledMessage);
+            const sqsRecord = createSQSRecord(serialized);
+            const result = await unbundleRecords([sqsRecord]);
+            expect(result.items).toHaveLength(1);
+            expect(result.items[0].sessionEvent).toBeDefined();
+            expect(result.items[0].sessionEvent.sessionId).toBe('sess_valid');
+        });
+    });
+    describe('LOG_EVENT_COLLECT Contract', () => {
+        it('producer creates valid InternalSQSMessage<BundledEnvelope> structure', async () => {
+            const logEvents = [
+                {
+                    pixelId: 'px_log_001',
+                    logEvent: {
+                        name: 'error',
+                        type: 'client_error',
+                        message: 'Failed to load resource',
+                        stack: 'Error at line 42',
+                    },
+                    requestHeaders: { 'user-agent': 'Chrome/120' },
+                },
+            ];
+            const bundledMessage = await createBundledMessage(MESSAGE_TYPES.LOG_EVENT_COLLECT, logEvents);
+            expect(bundledMessage).toMatchObject({
+                messageId: expect.any(String),
+                messageType: 'LOG_EVENT_COLLECT',
+                messageTime: expect.any(String),
+                messageBody: {
+                    v: 1,
+                    c: 'gzip',
+                    n: 1,
+                    p: expect.any(String),
+                    s: expect.any(Number),
+                },
+            });
+        });
+        it('consumer unbundleRecords extracts items matching LogCollectMessage', async () => {
+            const originalItems = [
+                {
+                    pixelId: 'px_log_001',
+                    logEvent: {
+                        name: 'performance',
+                        type: 'web_vital',
+                        metric: 'LCP',
+                        value: 2500,
+                        timestamp: Date.now(),
+                    },
+                    requestHeaders: {
+                        'user-agent': 'Safari/17',
+                        'cf-connecting-ip': '172.16.0.1',
+                    },
+                },
+                {
+                    pixelId: 'px_log_002',
+                    _encrypted: 'encrypted_log_payload',
+                },
+                {
+                    pixelId: 'px_log_003',
+                    logEvent: {
+                        name: 'debug',
+                        type: 'pixel_init',
+                        data: { version: '2.1.0', config: { trackClicks: true } },
+                    },
+                },
+            ];
+            const bundledMessage = await createBundledMessage(MESSAGE_TYPES.LOG_EVENT_COLLECT, originalItems);
+            const serialized = JSON.stringify(bundledMessage);
+            const sqsRecord = createSQSRecord(serialized);
+            const result = await unbundleRecords([sqsRecord]);
+            expect(result.items).toHaveLength(3);
+            expect(result.failedMessageIds).toHaveLength(0);
+            expect(result.stats.bundledSqsRecords).toBe(1);
+            expect(result.stats.totalItems).toBe(3);
+            const item1 = result.items[0];
+            expect(item1.pixelId).toBe('px_log_001');
+            expect(item1.logEvent?.name).toBe('performance');
+            expect(item1.logEvent?.metric).toBe('LCP');
+            expect(item1.requestHeaders?.['user-agent']).toBe('Safari/17');
+            const item2 = result.items[1];
+            expect(item2.pixelId).toBe('px_log_002');
+            expect(item2._encrypted).toBe('encrypted_log_payload');
+            const item3 = result.items[2];
+            expect(item3.pixelId).toBe('px_log_003');
+            expect(item3.logEvent?.type).toBe('pixel_init');
+        });
+    });
+    describe('Cross-Queue Contract Consistency', () => {
+        it('all message types use identical BundledEnvelope structure', async () => {
+            const trackingMessage = await createBundledMessage(MESSAGE_TYPES.TRACKING_EVENT_COLLECT, [{ pixelId: 'px1' }]);
+            const sessionMessage = await createBundledMessage(MESSAGE_TYPES.SESSION_EVENT_COLLECT, [
+                { pixelId: 'px2', sessionEvent: { name: 'test' } },
+            ]);
+            const logMessage = await createBundledMessage(MESSAGE_TYPES.LOG_EVENT_COLLECT, [{ pixelId: 'px3' }]);
+            const envelopeKeys = ['c', 'n', 'p', 's', 'v'];
+            expect(Object.keys(trackingMessage.messageBody).sort()).toEqual(envelopeKeys);
+            expect(Object.keys(sessionMessage.messageBody).sort()).toEqual(envelopeKeys);
+            expect(Object.keys(logMessage.messageBody).sort()).toEqual(envelopeKeys);
+            expect(trackingMessage.messageBody.v).toBe(1);
+            expect(trackingMessage.messageBody.c).toBe('gzip');
+            expect(sessionMessage.messageBody.v).toBe(1);
+            expect(sessionMessage.messageBody.c).toBe('gzip');
+            expect(logMessage.messageBody.v).toBe(1);
+            expect(logMessage.messageBody.c).toBe('gzip');
+        });
+        it('all message types use identical InternalSQSMessage wrapper structure', async () => {
+            const trackingMessage = await createBundledMessage(MESSAGE_TYPES.TRACKING_EVENT_COLLECT, [{ pixelId: 'px1' }]);
+            const sessionMessage = await createBundledMessage(MESSAGE_TYPES.SESSION_EVENT_COLLECT, [
+                { pixelId: 'px2', sessionEvent: { name: 'test' } },
+            ]);
+            const logMessage = await createBundledMessage(MESSAGE_TYPES.LOG_EVENT_COLLECT, [{ pixelId: 'px3' }]);
+            const wrapperKeys = ['messageBody', 'messageId', 'messageTime', 'messageType'];
+            expect(Object.keys(trackingMessage).sort()).toEqual(wrapperKeys);
+            expect(Object.keys(sessionMessage).sort()).toEqual(wrapperKeys);
+            expect(Object.keys(logMessage).sort()).toEqual(wrapperKeys);
+            expect([
+                MESSAGE_TYPES.TRACKING_EVENT_COLLECT,
+                MESSAGE_TYPES.SESSION_EVENT_COLLECT,
+                MESSAGE_TYPES.LOG_EVENT_COLLECT,
+            ]).toContain(trackingMessage.messageType);
+            expect([
+                MESSAGE_TYPES.TRACKING_EVENT_COLLECT,
+                MESSAGE_TYPES.SESSION_EVENT_COLLECT,
+                MESSAGE_TYPES.LOG_EVENT_COLLECT,
+            ]).toContain(sessionMessage.messageType);
+            expect([
+                MESSAGE_TYPES.TRACKING_EVENT_COLLECT,
+                MESSAGE_TYPES.SESSION_EVENT_COLLECT,
+                MESSAGE_TYPES.LOG_EVENT_COLLECT,
+            ]).toContain(logMessage.messageType);
+        });
+        it('unbundleRecords handles all message types uniformly', async () => {
+            const tracking = await createBundledMessage(MESSAGE_TYPES.TRACKING_EVENT_COLLECT, [
+                { pixelId: 'px_t1', trackingEvent: { name: 'PageView' } },
+                { pixelId: 'px_t2', trackingEvent: { name: 'AddToCart' } },
+            ]);
+            const session = await createBundledMessage(MESSAGE_TYPES.SESSION_EVENT_COLLECT, [
+                { pixelId: 'px_s1', sessionEvent: { name: 'session_start' } },
+            ]);
+            const log = await createBundledMessage(MESSAGE_TYPES.LOG_EVENT_COLLECT, [
+                { pixelId: 'px_l1', logEvent: { name: 'error' } },
+                { pixelId: 'px_l2', logEvent: { name: 'debug' } },
+                { pixelId: 'px_l3', logEvent: { name: 'info' } },
+            ]);
+            const records = [
+                createSQSRecord(JSON.stringify(tracking), 'msg-tracking'),
+                createSQSRecord(JSON.stringify(session), 'msg-session'),
+                createSQSRecord(JSON.stringify(log), 'msg-log'),
+            ];
+            const result = await unbundleRecords(records);
+            expect(result.failedMessageIds).toHaveLength(0);
+            expect(result.stats.bundledSqsRecords).toBe(3);
+            expect(result.stats.totalItems).toBe(6);
+            expect(result.items).toHaveLength(6);
+            const pixelIds = result.items.map((item) => item.pixelId);
+            expect(pixelIds).toContain('px_t1');
+            expect(pixelIds).toContain('px_t2');
+            expect(pixelIds).toContain('px_s1');
+            expect(pixelIds).toContain('px_l1');
+            expect(pixelIds).toContain('px_l2');
+            expect(pixelIds).toContain('px_l3');
+        });
+    });
+    describe('Edge Cases and Error Handling', () => {
+        it('handles empty bundle gracefully', async () => {
+            const bundledMessage = await createBundledMessage(MESSAGE_TYPES.TRACKING_EVENT_COLLECT, []);
+            const sqsRecord = createSQSRecord(JSON.stringify(bundledMessage));
+            const result = await unbundleRecords([sqsRecord]);
+            expect(result.items).toHaveLength(0);
+            expect(result.failedMessageIds).toHaveLength(0);
+            expect(result.stats.bundledSqsRecords).toBe(1);
+            expect(result.stats.totalItems).toBe(0);
+        });
+        it('handles mixed bundled and legacy records in same batch', async () => {
+            const bundledMessage = await createBundledMessage(MESSAGE_TYPES.TRACKING_EVENT_COLLECT, [
+                { pixelId: 'px_bundled_1' },
+                { pixelId: 'px_bundled_2' },
+            ]);
+            const legacyItem = { pixelId: 'px_legacy' };
+            const records = [
+                createSQSRecord(JSON.stringify(bundledMessage), 'msg-bundled'),
+                createSQSRecord(JSON.stringify(legacyItem), 'msg-legacy'),
+            ];
+            const result = await unbundleRecords(records);
+            expect(result.items).toHaveLength(3);
+            expect(result.stats.bundledSqsRecords).toBe(1);
+            expect(result.stats.legacySqsRecords).toBe(1);
+            expect(result.stats.totalItems).toBe(3);
+            const pixelIds = result.items.map((item) => item.pixelId);
+            expect(pixelIds).toContain('px_bundled_1');
+            expect(pixelIds).toContain('px_bundled_2');
+            expect(pixelIds).toContain('px_legacy');
+        });
+        it('preserves exact item data through bundle/unbundle cycle', async () => {
+            const complexItem = {
+                pixelId: 'px_complex',
+                id: 'evt_complex',
+                dd: 1234567890,
+                trackingEvent: {
+                    name: 'Purchase',
+                    eventName: 'purchase',
+                    context: {
+                        properties: {
+                            sessionId: 'sess_xyz',
+                            page: { path: '/checkout/success', title: 'Order Complete' },
+                            device: { type: 'mobile', os: 'iOS', browser: 'Safari' },
+                        },
+                    },
+                    data: {
+                        orderId: 'order_12345',
+                        value: 199.99,
+                        currency: 'USD',
+                        items: [
+                            { sku: 'SKU001', name: 'Widget', quantity: 2, price: 49.99 },
+                            { sku: 'SKU002', name: 'Gadget', quantity: 1, price: 100.01 },
+                        ],
+                    },
+                },
+                edgeContext: {
+                    ipAddress: '2001:db8::1',
+                    userAgent: 'Mozilla/5.0 (iPhone; CPU iPhone OS 17_0)',
+                    requestHeaders: {
+                        'cf-connecting-ip': '2001:db8::1',
+                        'cf-ipcountry': 'US',
+                        'user-agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 17_0)',
+                        'accept-language': 'en-US,en;q=0.9',
+                    },
+                    cf: {
+                        country: 'US',
+                        region: 'CA',
+                        city: 'San Francisco',
+                        colo: 'SJC',
+                        timezone: 'America/Los_Angeles',
+                    },
+                },
+            };
+            const bundledMessage = await createBundledMessage(MESSAGE_TYPES.TRACKING_EVENT_COLLECT, [complexItem]);
+            const sqsRecord = createSQSRecord(JSON.stringify(bundledMessage));
+            const result = await unbundleRecords([sqsRecord]);
+            expect(result.items).toHaveLength(1);
+            const extracted = result.items[0];
+            expect(extracted).toEqual(complexItem);
+            expect(extracted.trackingEvent?.data?.items).toHaveLength(2);
+            expect(extracted?.trackingEvent?.data && (extracted?.trackingEvent?.data?.items)[0]?.sku).toBe('SKU001');
+            expect(extracted.edgeContext?.cf?.timezone).toBe('America/Los_Angeles');
+        });
+    });
+});
 //# sourceMappingURL=sqs-bundling-contracts.spec.js.map