@adtrackify/at-service-common 5.0.0 → 5.0.3

package/dist/esm/__tests__/services/events/collect-queue-tracking-service.spec.js

@@ -1,228 +1,228 @@
-import { TRACKING_EVENT_NAME, } from '@adtrackify/at-tracking-event-types';
-const mockSendTrackingEventSqsMessage = jest.fn();
-jest.mock('../../../services/events/tracking-event-sqs-service', () => ({
-    TrackingEventSqsService: jest.fn().mockImplementation(() => ({
-        sendTrackingEventSqsMessage: mockSendTrackingEventSqsMessage,
-    })),
-}));
-jest.mock('../../../helpers/logging-helper', () => ({
-    Logger: {
-        debug: jest.fn(),
-        info: jest.fn(),
-        warn: jest.fn(),
-        error: jest.fn(),
-    },
-}));
-import { CollectQueueTrackingService } from '../../../services/events/collect-queue-tracking-service';
-describe('CollectQueueTrackingService', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-        jest.spyOn(Date, 'now').mockReturnValue(1700000000000);
-    });
-    afterEach(() => {
-        jest.restoreAllMocks();
-    });
-    const createService = () => new CollectQueueTrackingService('us-east-2', '123456789012', 'collect-queue');
-    const baseEventParams = {
-        eventId: 'evt_1',
-        name: TRACKING_EVENT_NAME.ACCOUNT_CREATED,
-        pixelId: 'pixel-1',
-        source: 'lifecycle',
-        data: { plan: 'pro' },
-    };
-    describe('buildEvent', () => {
-        it('builds event with full context', () => {
-            const service = createService();
-            const context = {
-                identity: {
-                    traits: {
-                        emails: ['user@example.com'],
-                        userIds: ['user-123'],
-                    },
-                },
-            };
-            const event = service.buildEvent({
-                ...baseEventParams,
-                context,
-            });
-            expect(event.context).toEqual(context);
-            expect(event.id).toBe('evt_1');
-            expect(event.data).toEqual({ plan: 'pro' });
-        });
-        it('builds event without context when not provided', () => {
-            const service = createService();
-            const event = service.buildEvent(baseEventParams);
-            expect(event.context).toBeUndefined();
-            expect(event.id).toBe('evt_1');
-            expect(event.pixelId).toBe('pixel-1');
-        });
-        it('builds event with identity only in context', () => {
-            const service = createService();
-            const event = service.buildEvent({
-                ...baseEventParams,
-                context: {
-                    identity: { traits: { emails: ['test@example.com'] } },
-                },
-            });
-            expect(event.context?.identity?.traits?.emails).toEqual(['test@example.com']);
-            expect(event.context?.properties).toBeUndefined();
-        });
-        it('builds event with properties only in context', () => {
-            const service = createService();
-            const event = service.buildEvent({
-                ...baseEventParams,
-                context: {
-                    properties: { sessionId: 'sess_123' },
-                },
-            });
-            expect(event.context?.properties?.sessionId).toBe('sess_123');
-            expect(event.context?.identity).toBeUndefined();
-        });
-    });
-    describe('send', () => {
-        it('returns true when SQS succeeds', async () => {
-            mockSendTrackingEventSqsMessage.mockResolvedValue(true);
-            const service = createService();
-            const event = service.buildEvent({
-                ...baseEventParams,
-                context: { identity: { traits: { emails: ['user@example.com'] } } },
-            });
-            const result = await service.send(event);
-            expect(result).toBe(true);
-            expect(mockSendTrackingEventSqsMessage).toHaveBeenCalledWith(event, 0);
-        });
-        it('returns false when SQS fails', async () => {
-            mockSendTrackingEventSqsMessage.mockResolvedValue(false);
-            const service = createService();
-            const event = service.buildEvent({
-                ...baseEventParams,
-                context: { identity: { traits: { emails: ['user@example.com'] } } },
-            });
-            const result = await service.send(event);
-            expect(result).toBe(false);
-        });
-        it('passes delaySeconds to SQS service', async () => {
-            mockSendTrackingEventSqsMessage.mockResolvedValue(true);
-            const service = createService();
-            const event = service.buildEvent({
-                ...baseEventParams,
-                context: { identity: { traits: { emails: ['user@example.com'] } } },
-            });
-            const result = await service.send(event, { delaySeconds: 600 });
-            expect(result).toBe(true);
-            expect(mockSendTrackingEventSqsMessage).toHaveBeenCalledWith(event, 600);
-        });
-        it('passes 900 second delay to SQS service', async () => {
-            mockSendTrackingEventSqsMessage.mockResolvedValue(true);
-            const service = createService();
-            const event = service.buildEvent({
-                ...baseEventParams,
-                context: { identity: { traits: { emails: ['user@example.com'] } } },
-            });
-            const result = await service.send(event, { delaySeconds: 900 });
-            expect(result).toBe(true);
-            expect(mockSendTrackingEventSqsMessage).toHaveBeenCalledWith(event, 900);
-        });
-    });
-    describe('emit', () => {
-        it('builds and sends in one call', async () => {
-            mockSendTrackingEventSqsMessage.mockResolvedValue(true);
-            const service = createService();
-            const result = await service.emit({
-                eventId: 'evt_1',
-                name: TRACKING_EVENT_NAME.ACCOUNT_CREATED,
-                pixelId: 'pixel-1',
-                source: 'lifecycle',
-                data: {},
-                context: { identity: { traits: { emails: ['test@example.com'] } } },
-            });
-            expect(result).toBe(true);
-            expect(mockSendTrackingEventSqsMessage).toHaveBeenCalledWith(expect.objectContaining({
-                id: 'evt_1',
-                pixelId: 'pixel-1',
-                context: { identity: { traits: { emails: ['test@example.com'] } } },
-            }), 0);
-        });
-        it('returns true when emit succeeds without context', async () => {
-            mockSendTrackingEventSqsMessage.mockResolvedValue(true);
-            const service = createService();
-            const result = await service.emit({
-                eventId: 'evt_2',
-                name: TRACKING_EVENT_NAME.SUBSCRIPTION_CREATED,
-                pixelId: 'pixel-1',
-                source: 'lifecycle',
-                data: { plan: 'enterprise' },
-            });
-            expect(result).toBe(true);
-            expect(mockSendTrackingEventSqsMessage).toHaveBeenCalledWith(expect.objectContaining({
-                id: 'evt_2',
-                name: TRACKING_EVENT_NAME.SUBSCRIPTION_CREATED,
-                data: { plan: 'enterprise' },
-            }), 0);
-        });
-        it('returns false when SQS send fails', async () => {
-            mockSendTrackingEventSqsMessage.mockResolvedValue(false);
-            const service = createService();
-            const result = await service.emit({
-                ...baseEventParams,
-                context: { identity: { traits: { userIds: ['user-123'] } } },
-            });
-            expect(result).toBe(false);
-        });
-        it('passes full context with identity and properties', async () => {
-            mockSendTrackingEventSqsMessage.mockResolvedValue(true);
-            const service = createService();
-            const context = {
-                identity: {
-                    traits: {
-                        emails: ['user@example.com'],
-                        userIds: ['user-123'],
-                    },
-                },
-                properties: {
-                    sessionId: 'sess_456',
-                    locale: 'en-US',
-                },
-            };
-            const result = await service.emit({
-                ...baseEventParams,
-                context,
-            });
-            expect(result).toBe(true);
-            expect(mockSendTrackingEventSqsMessage).toHaveBeenCalledWith(expect.objectContaining({
-                context,
-            }), 0);
-        });
-        it('emit with no delay passes 0 to SQS (existing behavior)', async () => {
-            mockSendTrackingEventSqsMessage.mockResolvedValue(true);
-            const service = createService();
-            const result = await service.emit({
-                ...baseEventParams,
-                context: { identity: { traits: { emails: ['test@example.com'] } } },
-            });
-            expect(result).toBe(true);
-            expect(mockSendTrackingEventSqsMessage).toHaveBeenCalledWith(expect.objectContaining({ id: 'evt_1' }), 0);
-        });
-        it('emit with 600 second delay passes delay to SQS', async () => {
-            mockSendTrackingEventSqsMessage.mockResolvedValue(true);
-            const service = createService();
-            const result = await service.emit({
-                ...baseEventParams,
-                context: { identity: { traits: { emails: ['test@example.com'] } } },
-            }, { delaySeconds: 600 });
-            expect(result).toBe(true);
-            expect(mockSendTrackingEventSqsMessage).toHaveBeenCalledWith(expect.objectContaining({ id: 'evt_1' }), 600);
-        });
-        it('emit with 900 second delay passes delay to SQS', async () => {
-            mockSendTrackingEventSqsMessage.mockResolvedValue(true);
-            const service = createService();
-            const result = await service.emit({
-                ...baseEventParams,
-                context: { identity: { traits: { emails: ['test@example.com'] } } },
-            }, { delaySeconds: 900 });
-            expect(result).toBe(true);
-            expect(mockSendTrackingEventSqsMessage).toHaveBeenCalledWith(expect.objectContaining({ id: 'evt_1' }), 900);
-        });
-    });
-});
+import { TRACKING_EVENT_NAME, } from '@adtrackify/at-tracking-event-types';
+const mockSendTrackingEventSqsMessage = jest.fn();
+jest.mock('../../../services/events/tracking-event-sqs-service', () => ({
+    TrackingEventSqsService: jest.fn().mockImplementation(() => ({
+        sendTrackingEventSqsMessage: mockSendTrackingEventSqsMessage,
+    })),
+}));
+jest.mock('../../../helpers/logging-helper', () => ({
+    Logger: {
+        debug: jest.fn(),
+        info: jest.fn(),
+        warn: jest.fn(),
+        error: jest.fn(),
+    },
+}));
+import { CollectQueueTrackingService } from '../../../services/events/collect-queue-tracking-service';
+describe('CollectQueueTrackingService', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        jest.spyOn(Date, 'now').mockReturnValue(1700000000000);
+    });
+    afterEach(() => {
+        jest.restoreAllMocks();
+    });
+    const createService = () => new CollectQueueTrackingService('us-east-2', '123456789012', 'collect-queue');
+    const baseEventParams = {
+        eventId: 'evt_1',
+        name: TRACKING_EVENT_NAME.ACCOUNT_CREATED,
+        pixelId: 'pixel-1',
+        source: 'lifecycle',
+        data: { plan: 'pro' },
+    };
+    describe('buildEvent', () => {
+        it('builds event with full context', () => {
+            const service = createService();
+            const context = {
+                identity: {
+                    traits: {
+                        emails: ['user@example.com'],
+                        userIds: ['user-123'],
+                    },
+                },
+            };
+            const event = service.buildEvent({
+                ...baseEventParams,
+                context,
+            });
+            expect(event.context).toEqual(context);
+            expect(event.id).toBe('evt_1');
+            expect(event.data).toEqual({ plan: 'pro' });
+        });
+        it('builds event without context when not provided', () => {
+            const service = createService();
+            const event = service.buildEvent(baseEventParams);
+            expect(event.context).toBeUndefined();
+            expect(event.id).toBe('evt_1');
+            expect(event.pixelId).toBe('pixel-1');
+        });
+        it('builds event with identity only in context', () => {
+            const service = createService();
+            const event = service.buildEvent({
+                ...baseEventParams,
+                context: {
+                    identity: { traits: { emails: ['test@example.com'] } },
+                },
+            });
+            expect(event.context?.identity?.traits?.emails).toEqual(['test@example.com']);
+            expect(event.context?.properties).toBeUndefined();
+        });
+        it('builds event with properties only in context', () => {
+            const service = createService();
+            const event = service.buildEvent({
+                ...baseEventParams,
+                context: {
+                    properties: { sessionId: 'sess_123' },
+                },
+            });
+            expect(event.context?.properties?.sessionId).toBe('sess_123');
+            expect(event.context?.identity).toBeUndefined();
+        });
+    });
+    describe('send', () => {
+        it('returns true when SQS succeeds', async () => {
+            mockSendTrackingEventSqsMessage.mockResolvedValue(true);
+            const service = createService();
+            const event = service.buildEvent({
+                ...baseEventParams,
+                context: { identity: { traits: { emails: ['user@example.com'] } } },
+            });
+            const result = await service.send(event);
+            expect(result).toBe(true);
+            expect(mockSendTrackingEventSqsMessage).toHaveBeenCalledWith(event, 0);
+        });
+        it('returns false when SQS fails', async () => {
+            mockSendTrackingEventSqsMessage.mockResolvedValue(false);
+            const service = createService();
+            const event = service.buildEvent({
+                ...baseEventParams,
+                context: { identity: { traits: { emails: ['user@example.com'] } } },
+            });
+            const result = await service.send(event);
+            expect(result).toBe(false);
+        });
+        it('passes delaySeconds to SQS service', async () => {
+            mockSendTrackingEventSqsMessage.mockResolvedValue(true);
+            const service = createService();
+            const event = service.buildEvent({
+                ...baseEventParams,
+                context: { identity: { traits: { emails: ['user@example.com'] } } },
+            });
+            const result = await service.send(event, { delaySeconds: 600 });
+            expect(result).toBe(true);
+            expect(mockSendTrackingEventSqsMessage).toHaveBeenCalledWith(event, 600);
+        });
+        it('passes 900 second delay to SQS service', async () => {
+            mockSendTrackingEventSqsMessage.mockResolvedValue(true);
+            const service = createService();
+            const event = service.buildEvent({
+                ...baseEventParams,
+                context: { identity: { traits: { emails: ['user@example.com'] } } },
+            });
+            const result = await service.send(event, { delaySeconds: 900 });
+            expect(result).toBe(true);
+            expect(mockSendTrackingEventSqsMessage).toHaveBeenCalledWith(event, 900);
+        });
+    });
+    describe('emit', () => {
+        it('builds and sends in one call', async () => {
+            mockSendTrackingEventSqsMessage.mockResolvedValue(true);
+            const service = createService();
+            const result = await service.emit({
+                eventId: 'evt_1',
+                name: TRACKING_EVENT_NAME.ACCOUNT_CREATED,
+                pixelId: 'pixel-1',
+                source: 'lifecycle',
+                data: {},
+                context: { identity: { traits: { emails: ['test@example.com'] } } },
+            });
+            expect(result).toBe(true);
+            expect(mockSendTrackingEventSqsMessage).toHaveBeenCalledWith(expect.objectContaining({
+                id: 'evt_1',
+                pixelId: 'pixel-1',
+                context: { identity: { traits: { emails: ['test@example.com'] } } },
+            }), 0);
+        });
+        it('returns true when emit succeeds without context', async () => {
+            mockSendTrackingEventSqsMessage.mockResolvedValue(true);
+            const service = createService();
+            const result = await service.emit({
+                eventId: 'evt_2',
+                name: TRACKING_EVENT_NAME.SUBSCRIPTION_CREATED,
+                pixelId: 'pixel-1',
+                source: 'lifecycle',
+                data: { plan: 'enterprise' },
+            });
+            expect(result).toBe(true);
+            expect(mockSendTrackingEventSqsMessage).toHaveBeenCalledWith(expect.objectContaining({
+                id: 'evt_2',
+                name: TRACKING_EVENT_NAME.SUBSCRIPTION_CREATED,
+                data: { plan: 'enterprise' },
+            }), 0);
+        });
+        it('returns false when SQS send fails', async () => {
+            mockSendTrackingEventSqsMessage.mockResolvedValue(false);
+            const service = createService();
+            const result = await service.emit({
+                ...baseEventParams,
+                context: { identity: { traits: { userIds: ['user-123'] } } },
+            });
+            expect(result).toBe(false);
+        });
+        it('passes full context with identity and properties', async () => {
+            mockSendTrackingEventSqsMessage.mockResolvedValue(true);
+            const service = createService();
+            const context = {
+                identity: {
+                    traits: {
+                        emails: ['user@example.com'],
+                        userIds: ['user-123'],
+                    },
+                },
+                properties: {
+                    sessionId: 'sess_456',
+                    locale: 'en-US',
+                },
+            };
+            const result = await service.emit({
+                ...baseEventParams,
+                context,
+            });
+            expect(result).toBe(true);
+            expect(mockSendTrackingEventSqsMessage).toHaveBeenCalledWith(expect.objectContaining({
+                context,
+            }), 0);
+        });
+        it('emit with no delay passes 0 to SQS (existing behavior)', async () => {
+            mockSendTrackingEventSqsMessage.mockResolvedValue(true);
+            const service = createService();
+            const result = await service.emit({
+                ...baseEventParams,
+                context: { identity: { traits: { emails: ['test@example.com'] } } },
+            });
+            expect(result).toBe(true);
+            expect(mockSendTrackingEventSqsMessage).toHaveBeenCalledWith(expect.objectContaining({ id: 'evt_1' }), 0);
+        });
+        it('emit with 600 second delay passes delay to SQS', async () => {
+            mockSendTrackingEventSqsMessage.mockResolvedValue(true);
+            const service = createService();
+            const result = await service.emit({
+                ...baseEventParams,
+                context: { identity: { traits: { emails: ['test@example.com'] } } },
+            }, { delaySeconds: 600 });
+            expect(result).toBe(true);
+            expect(mockSendTrackingEventSqsMessage).toHaveBeenCalledWith(expect.objectContaining({ id: 'evt_1' }), 600);
+        });
+        it('emit with 900 second delay passes delay to SQS', async () => {
+            mockSendTrackingEventSqsMessage.mockResolvedValue(true);
+            const service = createService();
+            const result = await service.emit({
+                ...baseEventParams,
+                context: { identity: { traits: { emails: ['test@example.com'] } } },
+            }, { delaySeconds: 900 });
+            expect(result).toBe(true);
+            expect(mockSendTrackingEventSqsMessage).toHaveBeenCalledWith(expect.objectContaining({ id: 'evt_1' }), 900);
+        });
+    });
+});
 //# sourceMappingURL=collect-queue-tracking-service.spec.js.map

package/dist/esm/__tests__/services/events/tracking-event-sqs-service.spec.d.ts

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