@adtrackify/at-service-common 4.0.36 → 5.0.2

package/dist/esm/__tests__/clients/event-collector-client.spec.js

@@ -1,226 +1,226 @@
-import { axiosHttpService } from '../../clients/generic';
-import { Logger } from '../../helpers/logging-helper';
-const mockGet = jest.fn();
-const mockPost = jest.fn();
-jest.mock('../../clients/generic', () => ({
-    axiosHttpService: jest.fn(() => ({
-        get: mockGet,
-        post: mockPost,
-    })),
-}));
-jest.mock('../../helpers/logging-helper', () => ({
-    Logger: {
-        debug: jest.fn(),
-        info: jest.fn(),
-        warn: jest.fn(),
-        error: jest.fn(),
-    },
-}));
-import { EventCollectorClient } from '../../clients/internal-api/event-collector-client';
-const mockAxiosHttpService = axiosHttpService;
-const createClient = () => new EventCollectorClient('https://status-api.example.com', 'status-api-key');
-describe('EventCollectorClient', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-        mockAxiosHttpService.mockImplementation(() => ({
-            get: mockGet,
-            post: mockPost,
-        }));
-    });
-    describe('getEventStatus', () => {
-        it('GETs /e with eid and pid using constructor credentials', async () => {
-            mockGet.mockResolvedValue({ status: 200, data: { found: true } });
-            const client = createClient();
-            const response = await client.getEventStatus('pixel-1', 'event-1');
-            expect(mockAxiosHttpService).toHaveBeenCalledWith(expect.objectContaining({
-                baseURL: 'https://status-api.example.com/tr',
-                headers: {
-                    common: {
-                        'x-api-key': 'status-api-key',
-                    },
-                },
-            }));
-            expect(mockGet).toHaveBeenCalledWith('/e', { params: { eid: 'event-1', pid: 'pixel-1' } });
-            expect(response).toEqual({ status: 200, data: { found: true } });
-        });
-    });
-    describe('createEvents', () => {
-        const baseParams = {
-            baseApiUrl: 'https://dev2-api.upstackified.com',
-            apiKey: 'marketing-pixel-key',
-            pixelId: '14ea7c6f-2f3c-4ea4-aac3-7af8c1834c4a',
-            events: [
-                {
-                    name: 'account_created',
-                    eventId: 'evt_1',
-                    userProperties: { emails: ['user@example.com'] },
-                },
-            ],
-        };
-        it('POSTs /api/events with x-api-key, x-pixel-id, and events body', async () => {
-            mockPost.mockResolvedValue({
-                status: 200,
-                data: { requestId: 'req_1', eventsIngested: 1 },
-            });
-            const client = createClient();
-            const result = await client.createEvents(baseParams);
-            expect(mockAxiosHttpService).toHaveBeenCalledWith(expect.objectContaining({
-                baseURL: 'https://dev2-api.upstackified.com/tr',
-                headers: {
-                    common: {
-                        'x-api-key': 'marketing-pixel-key',
-                        'x-pixel-id': baseParams.pixelId,
-                        'Content-Type': 'application/json',
-                    },
-                },
-                timeout: 5000,
-            }));
-            expect(mockPost).toHaveBeenCalledWith('/api/events', { events: baseParams.events });
-            expect(result).toEqual({ ok: true, eventsIngested: 1 });
-        });
-        it('returns ok false on 401 without throwing', async () => {
-            mockPost.mockResolvedValue({
-                status: 401,
-                data: { message: 'Unauthorized', error: { code: 'UNAUTHORIZED', message: 'Unauthorized' } },
-            });
-            const client = createClient();
-            const result = await client.createEvents(baseParams);
-            expect(result).toEqual({ ok: false, errorMessage: 'Unauthorized' });
-            expect(Logger.warn).toHaveBeenCalledWith('EventCollectorClient.createEvents: non-success response', expect.objectContaining({
-                pixelId: baseParams.pixelId,
-                eventCount: 1,
-                status: 401,
-                errorMessage: 'Unauthorized',
-            }));
-        });
-        it('returns ok false on 400 validation error without throwing', async () => {
-            mockPost.mockResolvedValue({
-                status: 400,
-                data: { message: 'One or more events failed validation.' },
-            });
-            const result = await createClient().createEvents(baseParams);
-            expect(result.ok).toBe(false);
-            expect(result.errorMessage).toBe('One or more events failed validation.');
-        });
-        it('returns ok false on 500 without throwing', async () => {
-            mockPost.mockResolvedValue({
-                status: 500,
-                data: { message: 'Internal server error.' },
-            });
-            const result = await createClient().createEvents(baseParams);
-            expect(result).toEqual({ ok: false, errorMessage: 'Internal server error.' });
-        });
-        it('fail-opens on network/thrown errors', async () => {
-            mockPost.mockRejectedValue(new Error('socket hang up'));
-            const result = await createClient().createEvents(baseParams);
-            expect(result).toEqual({ ok: false, errorMessage: 'socket hang up' });
-            expect(Logger.warn).toHaveBeenCalledWith('EventCollectorClient.createEvents: failed', expect.objectContaining({
-                errorMessage: 'socket hang up',
-                pixelId: baseParams.pixelId,
-                eventCount: 1,
-            }));
-        });
-        it('uses per-call marketing key, not constructor status key', async () => {
-            mockPost.mockResolvedValue({
-                status: 200,
-                data: { eventsIngested: 2 },
-            });
-            await createClient().createEvents({
-                ...baseParams,
-                events: [
-                    { name: 'subscription_created' },
-                    { name: 'lead', eventProperties: { value: 250, currency: 'USD' } },
-                ],
-            });
-            const config = mockAxiosHttpService.mock.calls[0][0];
-            expect(config.headers.common['x-api-key']).toBe('marketing-pixel-key');
-            expect(config.headers.common['x-api-key']).not.toBe('status-api-key');
-        });
-        it('POSTs curated CAPI payload fields (identityId, click, viewport, shopifyYIds)', async () => {
-            mockPost.mockResolvedValue({
-                status: 200,
-                data: { eventsIngested: 1 },
-            });
-            const curatedEvents = [
-                {
-                    name: 'purchase',
-                    eventId: '01ARZ3NDEKTSV4RRFFQ69G5FAV',
-                    identityId: '01HXYZ_BROWSER_ADTIK',
-                    userProperties: {
-                        emails: ['jane@example.com'],
-                        phones: ['+15551234567'],
-                        userIds: ['cust_889'],
-                        genders: ['f'],
-                        dobs: ['1990-01-15'],
-                        addresses: [
-                            {
-                                firstName: 'Jane',
-                                lastName: 'Doe',
-                                address1: '1 Main St',
-                                city: 'Austin',
-                                provinceCode: 'TX',
-                                countryCode: 'US',
-                                zip: '78701',
-                            },
-                        ],
-                        shopifyYIds: ['y-abc'],
-                    },
-                    ipAddress: '203.0.113.5',
-                    userAgent: 'Mozilla/5.0',
-                    sessionId: '01HSESSION',
-                    locale: 'en-US',
-                    timezone: 'America/New_York',
-                    page: { url: 'https://shop.com/checkout', path: '/checkout' },
-                    campaign: { source: 'google', medium: 'cpc', campaign: 'spring' },
-                    click: {
-                        fbc: 'fb.1.abc',
-                        fbp: 'fb.1.xyz',
-                        fbclid: 'IwAR…',
-                        gclid: 'Cj0…',
-                        gbraid: 'gbraid-1',
-                        wbraid: 'wbraid-1',
-                        ttclid: 'E.C.P…',
-                        ttp: 'ttp-1',
-                        msclkid: 'msclk-1',
-                    },
-                    viewport: {
-                        viewportWidth: 1440,
-                        viewportHeight: 900,
-                        pageHeight: 3200,
-                        devicePixelRatio: 2,
-                    },
-                    eventProperties: { orderId: '10421', value: 99.9, currency: 'USD' },
-                },
-            ];
-            const result = await createClient().createEvents({
-                ...baseParams,
-                events: curatedEvents,
-            });
-            expect(mockPost).toHaveBeenCalledWith('/api/events', { events: curatedEvents });
-            expect(result).toEqual({ ok: true, eventsIngested: 1 });
-            const postedBody = mockPost.mock.calls[0][1];
-            const postedEvent = postedBody.events[0];
-            expect(postedEvent.identityId).toBe('01HXYZ_BROWSER_ADTIK');
-            expect(postedEvent.userProperties.shopifyYIds).toEqual(['y-abc']);
-            expect(postedEvent.click.fbclid).toBe('IwAR…');
-            expect(postedEvent.click.gbraid).toBe('gbraid-1');
-            expect(postedEvent.viewport.viewportWidth).toBe(1440);
-            expect(postedEvent).not.toHaveProperty('shopify');
-            expect(postedEvent.userProperties).not.toHaveProperty('tpc');
-            expect(postedEvent.click).not.toHaveProperty('googleClientInfos');
-        });
-        it('handles empty events array gracefully', async () => {
-            mockPost.mockResolvedValue({
-                status: 200,
-                data: { eventsIngested: 0 },
-            });
-            const result = await createClient().createEvents({
-                ...baseParams,
-                events: [],
-            });
-            expect(mockPost).toHaveBeenCalledWith('/api/events', { events: [] });
-            expect(result).toEqual({ ok: true, eventsIngested: 0 });
-        });
-    });
-});
+import { axiosHttpService } from '../../clients/generic';
+import { Logger } from '../../helpers/logging-helper';
+const mockGet = jest.fn();
+const mockPost = jest.fn();
+jest.mock('../../clients/generic', () => ({
+    axiosHttpService: jest.fn(() => ({
+        get: mockGet,
+        post: mockPost,
+    })),
+}));
+jest.mock('../../helpers/logging-helper', () => ({
+    Logger: {
+        debug: jest.fn(),
+        info: jest.fn(),
+        warn: jest.fn(),
+        error: jest.fn(),
+    },
+}));
+import { EventCollectorClient } from '../../clients/internal-api/event-collector-client';
+const mockAxiosHttpService = axiosHttpService;
+const createClient = () => new EventCollectorClient('https://status-api.example.com', 'status-api-key');
+describe('EventCollectorClient', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+        mockAxiosHttpService.mockImplementation(() => ({
+            get: mockGet,
+            post: mockPost,
+        }));
+    });
+    describe('getEventStatus', () => {
+        it('GETs /e with eid and pid using constructor credentials', async () => {
+            mockGet.mockResolvedValue({ status: 200, data: { found: true } });
+            const client = createClient();
+            const response = await client.getEventStatus('pixel-1', 'event-1');
+            expect(mockAxiosHttpService).toHaveBeenCalledWith(expect.objectContaining({
+                baseURL: 'https://status-api.example.com/tr',
+                headers: {
+                    common: {
+                        'x-api-key': 'status-api-key',
+                    },
+                },
+            }));
+            expect(mockGet).toHaveBeenCalledWith('/e', { params: { eid: 'event-1', pid: 'pixel-1' } });
+            expect(response).toEqual({ status: 200, data: { found: true } });
+        });
+    });
+    describe('createEvents', () => {
+        const baseParams = {
+            baseApiUrl: 'https://dev2-api.upstackified.com',
+            apiKey: 'marketing-pixel-key',
+            pixelId: '14ea7c6f-2f3c-4ea4-aac3-7af8c1834c4a',
+            events: [
+                {
+                    name: 'account_created',
+                    eventId: 'evt_1',
+                    userProperties: { emails: ['user@example.com'] },
+                },
+            ],
+        };
+        it('POSTs /api/events with x-api-key, x-pixel-id, and events body', async () => {
+            mockPost.mockResolvedValue({
+                status: 200,
+                data: { requestId: 'req_1', eventsIngested: 1 },
+            });
+            const client = createClient();
+            const result = await client.createEvents(baseParams);
+            expect(mockAxiosHttpService).toHaveBeenCalledWith(expect.objectContaining({
+                baseURL: 'https://dev2-api.upstackified.com/tr',
+                headers: {
+                    common: {
+                        'x-api-key': 'marketing-pixel-key',
+                        'x-pixel-id': baseParams.pixelId,
+                        'Content-Type': 'application/json',
+                    },
+                },
+                timeout: 5000,
+            }));
+            expect(mockPost).toHaveBeenCalledWith('/api/events', { events: baseParams.events });
+            expect(result).toEqual({ ok: true, eventsIngested: 1 });
+        });
+        it('returns ok false on 401 without throwing', async () => {
+            mockPost.mockResolvedValue({
+                status: 401,
+                data: { message: 'Unauthorized', error: { code: 'UNAUTHORIZED', message: 'Unauthorized' } },
+            });
+            const client = createClient();
+            const result = await client.createEvents(baseParams);
+            expect(result).toEqual({ ok: false, errorMessage: 'Unauthorized' });
+            expect(Logger.warn).toHaveBeenCalledWith('EventCollectorClient.createEvents: non-success response', expect.objectContaining({
+                pixelId: baseParams.pixelId,
+                eventCount: 1,
+                status: 401,
+                errorMessage: 'Unauthorized',
+            }));
+        });
+        it('returns ok false on 400 validation error without throwing', async () => {
+            mockPost.mockResolvedValue({
+                status: 400,
+                data: { message: 'One or more events failed validation.' },
+            });
+            const result = await createClient().createEvents(baseParams);
+            expect(result.ok).toBe(false);
+            expect(result.errorMessage).toBe('One or more events failed validation.');
+        });
+        it('returns ok false on 500 without throwing', async () => {
+            mockPost.mockResolvedValue({
+                status: 500,
+                data: { message: 'Internal server error.' },
+            });
+            const result = await createClient().createEvents(baseParams);
+            expect(result).toEqual({ ok: false, errorMessage: 'Internal server error.' });
+        });
+        it('fail-opens on network/thrown errors', async () => {
+            mockPost.mockRejectedValue(new Error('socket hang up'));
+            const result = await createClient().createEvents(baseParams);
+            expect(result).toEqual({ ok: false, errorMessage: 'socket hang up' });
+            expect(Logger.warn).toHaveBeenCalledWith('EventCollectorClient.createEvents: failed', expect.objectContaining({
+                errorMessage: 'socket hang up',
+                pixelId: baseParams.pixelId,
+                eventCount: 1,
+            }));
+        });
+        it('uses per-call marketing key, not constructor status key', async () => {
+            mockPost.mockResolvedValue({
+                status: 200,
+                data: { eventsIngested: 2 },
+            });
+            await createClient().createEvents({
+                ...baseParams,
+                events: [
+                    { name: 'subscription_created' },
+                    { name: 'lead', eventProperties: { value: 250, currency: 'USD' } },
+                ],
+            });
+            const config = mockAxiosHttpService.mock.calls[0][0];
+            expect(config.headers.common['x-api-key']).toBe('marketing-pixel-key');
+            expect(config.headers.common['x-api-key']).not.toBe('status-api-key');
+        });
+        it('POSTs curated CAPI payload fields (identityId, click, viewport, shopifyYIds)', async () => {
+            mockPost.mockResolvedValue({
+                status: 200,
+                data: { eventsIngested: 1 },
+            });
+            const curatedEvents = [
+                {
+                    name: 'purchase',
+                    eventId: '01ARZ3NDEKTSV4RRFFQ69G5FAV',
+                    identityId: '01HXYZ_BROWSER_ADTIK',
+                    userProperties: {
+                        emails: ['jane@example.com'],
+                        phones: ['+15551234567'],
+                        userIds: ['cust_889'],
+                        genders: ['f'],
+                        dobs: ['1990-01-15'],
+                        addresses: [
+                            {
+                                firstName: 'Jane',
+                                lastName: 'Doe',
+                                address1: '1 Main St',
+                                city: 'Austin',
+                                provinceCode: 'TX',
+                                countryCode: 'US',
+                                zip: '78701',
+                            },
+                        ],
+                        shopifyYIds: ['y-abc'],
+                    },
+                    ipAddress: '203.0.113.5',
+                    userAgent: 'Mozilla/5.0',
+                    sessionId: '01HSESSION',
+                    locale: 'en-US',
+                    timezone: 'America/New_York',
+                    page: { url: 'https://shop.com/checkout', path: '/checkout' },
+                    campaign: { source: 'google', medium: 'cpc', campaign: 'spring' },
+                    click: {
+                        fbc: 'fb.1.abc',
+                        fbp: 'fb.1.xyz',
+                        fbclid: 'IwAR…',
+                        gclid: 'Cj0…',
+                        gbraid: 'gbraid-1',
+                        wbraid: 'wbraid-1',
+                        ttclid: 'E.C.P…',
+                        ttp: 'ttp-1',
+                        msclkid: 'msclk-1',
+                    },
+                    viewport: {
+                        viewportWidth: 1440,
+                        viewportHeight: 900,
+                        pageHeight: 3200,
+                        devicePixelRatio: 2,
+                    },
+                    eventProperties: { orderId: '10421', value: 99.9, currency: 'USD' },
+                },
+            ];
+            const result = await createClient().createEvents({
+                ...baseParams,
+                events: curatedEvents,
+            });
+            expect(mockPost).toHaveBeenCalledWith('/api/events', { events: curatedEvents });
+            expect(result).toEqual({ ok: true, eventsIngested: 1 });
+            const postedBody = mockPost.mock.calls[0][1];
+            const postedEvent = postedBody.events[0];
+            expect(postedEvent.identityId).toBe('01HXYZ_BROWSER_ADTIK');
+            expect(postedEvent.userProperties.shopifyYIds).toEqual(['y-abc']);
+            expect(postedEvent.click.fbclid).toBe('IwAR…');
+            expect(postedEvent.click.gbraid).toBe('gbraid-1');
+            expect(postedEvent.viewport.viewportWidth).toBe(1440);
+            expect(postedEvent).not.toHaveProperty('shopify');
+            expect(postedEvent.userProperties).not.toHaveProperty('tpc');
+            expect(postedEvent.click).not.toHaveProperty('googleClientInfos');
+        });
+        it('handles empty events array gracefully', async () => {
+            mockPost.mockResolvedValue({
+                status: 200,
+                data: { eventsIngested: 0 },
+            });
+            const result = await createClient().createEvents({
+                ...baseParams,
+                events: [],
+            });
+            expect(mockPost).toHaveBeenCalledWith('/api/events', { events: [] });
+            expect(result).toEqual({ ok: true, eventsIngested: 0 });
+        });
+    });
+});
 //# sourceMappingURL=event-collector-client.spec.js.map

package/dist/esm/__tests__/clients/open-exchange-rates-client.spec.d.ts

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

package/dist/esm/__tests__/clients/open-exchange-rates-client.spec.js

@@ -1,54 +1,54 @@
-import { axiosHttpService } from '../../clients/generic';
-jest.mock('../../clients/generic', () => ({
-    axiosHttpService: jest.fn(() => ({ get: jest.fn() })),
-}));
-import { OpenExchangeRatesClient } from '../../clients/third-party/open-exchange-rates-client';
-const mockGet = axiosHttpService.mock.results[0].value.get;
-const fixtureRates = {
-    disclaimer: 'Usage subject to terms',
-    license: 'https://openexchangerates.org/license',
-    timestamp: 1704067200,
-    historical: true,
-    base: 'USD',
-    rates: {
-        USD: 1,
-        EUR: 0.92,
-        GBP: 0.79,
-    },
-};
-describe('OpenExchangeRatesClient', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    it('requests historical rates with app_id query param', async () => {
-        mockGet.mockResolvedValue({ status: 200, data: fixtureRates });
-        const oxrClient = new OpenExchangeRatesClient('test-app-id');
-        const response = await oxrClient.getHistoricalRates('2024-01-01');
-        expect(mockGet).toHaveBeenCalledTimes(1);
-        const [url, config] = mockGet.mock.calls[0];
-        expect(url).toBe('/historical/2024-01-01.json');
-        expect(config.params).toEqual({ app_id: 'test-app-id' });
-        expect(response).toEqual({ status: 200, data: fixtureRates });
-    });
-    it('requests latest rates with app_id query param', async () => {
-        const latestFixture = { ...fixtureRates, historical: undefined };
-        mockGet.mockResolvedValue({ status: 200, data: latestFixture });
-        const oxrClient = new OpenExchangeRatesClient('test-app-id');
-        const response = await oxrClient.getLatestRates();
-        expect(mockGet).toHaveBeenCalledTimes(1);
-        const [url, config] = mockGet.mock.calls[0];
-        expect(url).toBe('/latest.json');
-        expect(config.params).toEqual({ app_id: 'test-app-id' });
-        expect(response).toEqual({ status: 200, data: latestFixture });
-    });
-    it('passes a non-200 response through without throwing', async () => {
-        mockGet.mockResolvedValue({
-            status: 429,
-            data: { error: true, status: 429, message: 'rate_limit', description: 'Too many requests' },
-        });
-        const oxrClient = new OpenExchangeRatesClient('test-app-id');
-        const response = await oxrClient.getLatestRates();
-        expect(response.status).toBe(429);
-    });
-});
+import { axiosHttpService } from '../../clients/generic';
+jest.mock('../../clients/generic', () => ({
+    axiosHttpService: jest.fn(() => ({ get: jest.fn() })),
+}));
+import { OpenExchangeRatesClient } from '../../clients/third-party/open-exchange-rates-client';
+const mockGet = axiosHttpService.mock.results[0].value.get;
+const fixtureRates = {
+    disclaimer: 'Usage subject to terms',
+    license: 'https://openexchangerates.org/license',
+    timestamp: 1704067200,
+    historical: true,
+    base: 'USD',
+    rates: {
+        USD: 1,
+        EUR: 0.92,
+        GBP: 0.79,
+    },
+};
+describe('OpenExchangeRatesClient', () => {
+    beforeEach(() => {
+        jest.clearAllMocks();
+    });
+    it('requests historical rates with app_id query param', async () => {
+        mockGet.mockResolvedValue({ status: 200, data: fixtureRates });
+        const oxrClient = new OpenExchangeRatesClient('test-app-id');
+        const response = await oxrClient.getHistoricalRates('2024-01-01');
+        expect(mockGet).toHaveBeenCalledTimes(1);
+        const [url, config] = mockGet.mock.calls[0];
+        expect(url).toBe('/historical/2024-01-01.json');
+        expect(config.params).toEqual({ app_id: 'test-app-id' });
+        expect(response).toEqual({ status: 200, data: fixtureRates });
+    });
+    it('requests latest rates with app_id query param', async () => {
+        const latestFixture = { ...fixtureRates, historical: undefined };
+        mockGet.mockResolvedValue({ status: 200, data: latestFixture });
+        const oxrClient = new OpenExchangeRatesClient('test-app-id');
+        const response = await oxrClient.getLatestRates();
+        expect(mockGet).toHaveBeenCalledTimes(1);
+        const [url, config] = mockGet.mock.calls[0];
+        expect(url).toBe('/latest.json');
+        expect(config.params).toEqual({ app_id: 'test-app-id' });
+        expect(response).toEqual({ status: 200, data: latestFixture });
+    });
+    it('passes a non-200 response through without throwing', async () => {
+        mockGet.mockResolvedValue({
+            status: 429,
+            data: { error: true, status: 429, message: 'rate_limit', description: 'Too many requests' },
+        });
+        const oxrClient = new OpenExchangeRatesClient('test-app-id');
+        const response = await oxrClient.getLatestRates();
+        expect(response.status).toBe(429);
+    });
+});
 //# sourceMappingURL=open-exchange-rates-client.spec.js.map

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

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