@adtrackify/at-service-common 5.0.0 → 5.0.2

package/dist/esm/__tests__/identity-cache/identity-gateway-stale-cache.spec.js

@@ -1,222 +1,222 @@
-import { createService, createServiceWithSqs, createCachedIdentity, mockGetIdentity, mockBuildAndSendMessage, mockedDynamoDbClient, resetAllMocks, TEST_PIXEL_ID, IDENTITY_CACHE_WITH_CACHING_OUTCOME, } from './identity-gateway-test-setup.js';
-describe('IdentityGatewayService stale cache scenarios', () => {
-    const pixelId = TEST_PIXEL_ID;
-    beforeEach(() => {
-        resetAllMocks();
-    });
-    describe('identity-defining trait changes → Neptune', () => {
-        it('should call Neptune when new emails are added', async () => {
-            const service = createService();
-            const cachedResponse = createCachedIdentity(pixelId, 'staleness-compute', {
-                emails: ['old@email.com'],
-            });
-            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-            mockGetIdentity.mockResolvedValueOnce({
-                identityId: 'staleness-compute',
-                traits: { emails: ['old@email.com', 'new@email.com'] },
-            });
-            const incomingIdentity = {
-                identityId: 'staleness-compute',
-                traits: {
-                    emails: ['old@email.com', 'new@email.com'],
-                },
-            };
-            const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
-            expect(result.didCallNeptune).toBe(true);
-            expect(result.stalenessResult?.staleTraits).toContain('emails');
-        });
-        it('should not skip Neptune for IDENTITY_STALE tier', async () => {
-            const service = createService();
-            const cachedResponse = createCachedIdentity(pixelId, 'call-neptune', {
-                emails: ['old@email.com'],
-            });
-            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-            mockGetIdentity.mockResolvedValueOnce({
-                identityId: 'call-neptune',
-                traits: { emails: ['old@email.com', 'new@email.com'] },
-            });
-            const incomingIdentity = {
-                identityId: 'call-neptune',
-                traits: {
-                    emails: ['old@email.com', 'new@email.com'],
-                },
-            };
-            const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
-            expect(result.didSkipNeptune).toBe(false);
-            expect(result.didCallNeptune).toBe(true);
-            expect(mockGetIdentity).toHaveBeenCalled();
-        });
-    });
-    describe('Neptune resolution success', () => {
-        it('should return NEPTUNE_RESOLVED outcome', async () => {
-            const service = createService();
-            const cachedResponse = createCachedIdentity(pixelId, 'stale-reason', {
-                emails: ['old@email.com'],
-            });
-            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-            mockGetIdentity.mockResolvedValueOnce({
-                identityId: 'stale-reason',
-                traits: { emails: ['old@email.com', 'new@email.com'] },
-            });
-            const incomingIdentity = {
-                identityId: 'stale-reason',
-                traits: {
-                    emails: ['old@email.com', 'new@email.com'],
-                },
-            };
-            const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
-            expect(result.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.NEPTUNE_RESOLVED);
-        });
-        it('should compute traitChanges between cached and Neptune identity', async () => {
-            const service = createService();
-            const cachedResponse = createCachedIdentity(pixelId, 'trait-changes', {
-                emails: ['old@email.com'],
-                phones: ['555-old'],
-            });
-            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-            mockGetIdentity.mockResolvedValueOnce({
-                identityId: 'trait-changes',
-                traits: {
-                    emails: ['old@email.com', 'new@email.com'],
-                    phones: ['555-old', '555-new'],
-                },
-            });
-            const result = await service.resolveIdentityWithCaching(pixelId, { identityId: 'trait-changes', traits: { emails: ['old@email.com', 'new@email.com'] } });
-            expect(result.traitChanges).toBeDefined();
-            expect(result.traitChanges?.emails).toBeDefined();
-        });
-        it('should not write to cache (identity service handles writes)', async () => {
-            const service = createService();
-            const cachedResponse = createCachedIdentity(pixelId, 'neptune-write', {
-                emails: ['old@email.com'],
-            });
-            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-            mockGetIdentity.mockResolvedValueOnce({
-                identityId: 'neptune-write',
-                traits: {
-                    emails: ['old@email.com', 'new@email.com'],
-                    phones: ['555-neptune'],
-                },
-            });
-            const result = await service.resolveIdentityWithCaching(pixelId, { identityId: 'neptune-write', traits: { emails: ['old@email.com', 'new@email.com'] } });
-            expect(result.didWriteCache).toBe(false);
-            expect(result.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.NEPTUNE_RESOLVED);
-            expect(mockedDynamoDbClient.safeBatchWrite).not.toHaveBeenCalled();
-        });
-        it('should still return Neptune identity when it matches cached', async () => {
-            const service = createService();
-            const cachedResponse = createCachedIdentity(pixelId, 'no-changes', {
-                emails: ['same@email.com'],
-            });
-            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-            mockGetIdentity.mockResolvedValueOnce({
-                identityId: 'no-changes',
-                traits: { emails: ['same@email.com'] },
-            });
-            const result = await service.resolveIdentityWithCaching(pixelId, { identityId: 'no-changes', traits: { emails: ['same@email.com', 'thought-new@email.com'] } });
-            expect(result.didCallNeptune).toBe(true);
-            expect(result.didWriteCache).toBe(false);
-            expect(result.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.NEPTUNE_RESOLVED);
-        });
-        it('should strip address timestamps when comparing Neptune result', async () => {
-            const service = createService();
-            const now = Date.now();
-            const cachedResponse = {
-                pk: `identity#${pixelId}#addr-timestamp`,
-                pixelId,
-                identityId: 'addr-timestamp',
-                response: {
-                    identityId: 'addr-timestamp',
-                    traits: {
-                        emails: ['test@email.com'],
-                        addresses: [{ city: 'NYC', cra: now - 1000, upa: now - 500 }],
-                    },
-                },
-                updatedAt: new Date().toISOString(),
-            };
-            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-            mockGetIdentity.mockResolvedValueOnce({
-                identityId: 'addr-timestamp',
-                traits: {
-                    emails: ['test@email.com'],
-                    addresses: [{ city: 'NYC', cra: now, upa: now }],
-                },
-            });
-            const result = await service.resolveIdentityWithCaching(pixelId, { identityId: 'addr-timestamp', traits: { emails: ['test@email.com', 'new@email.com'] } });
-            expect(result.didWriteCache).toBe(false);
-            expect(result.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.NEPTUNE_RESOLVED);
-        });
-    });
-    describe('Neptune resolution failure', () => {
-        it('should return NEPTUNE_RESOLUTION_FAILED outcome', async () => {
-            const service = createService();
-            const cachedResponse = createCachedIdentity(pixelId, 'neptune-throws', {
-                emails: ['old@email.com'],
-            });
-            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-            mockGetIdentity.mockRejectedValueOnce(new Error('Neptune invocation failed'));
-            const result = await service.resolveIdentityWithCaching(pixelId, { identityId: 'neptune-throws', traits: { emails: ['old@email.com', 'new@email.com'] } });
-            expect(result.didCallNeptune).toBe(true);
-            expect(result.didWriteCache).toBe(false);
-            expect(result.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.NEPTUNE_RESOLUTION_FAILED);
-        });
-        it('should return merged identity on Neptune failure (fail-open)', async () => {
-            const service = createService();
-            const cachedResponse = createCachedIdentity(pixelId, 'neptune-throws', {
-                emails: ['old@email.com'],
-            });
-            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-            mockGetIdentity.mockRejectedValueOnce(new Error('Neptune invocation failed'));
-            const result = await service.resolveIdentityWithCaching(pixelId, { identityId: 'neptune-throws', traits: { emails: ['old@email.com', 'new@email.com'] } });
-            expect(result.identity).toBeDefined();
-            expect(result.identity?.identityId).toBe('neptune-throws');
-            expect(result.identity?.traits?.emails).toEqual(['old@email.com', 'new@email.com']);
-        });
-        it('should not write to cache when Neptune fails', async () => {
-            const service = createService();
-            const cachedResponse = createCachedIdentity(pixelId, 'no-write-fail', {
-                emails: ['test@email.com'],
-            });
-            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-            mockGetIdentity.mockRejectedValueOnce(new Error('Network error'));
-            const result = await service.resolveIdentityWithCaching(pixelId, { identityId: 'no-write-fail', traits: { emails: ['test@email.com', 'extra@email.com'] } });
-            expect(result.didWriteCache).toBe(false);
-            expect(mockedDynamoDbClient.safeBatchWrite).not.toHaveBeenCalled();
-        });
-    });
-    describe('address update path', () => {
-        it('should enqueue async update on address changes', async () => {
-            const service = createServiceWithSqs();
-            mockBuildAndSendMessage.mockResolvedValueOnce({ MessageId: 'test-msg-id' });
-            const cachedResponse = {
-                pk: `identity#${pixelId}#identity456`,
-                pixelId,
-                identityId: 'identity456',
-                response: {
-                    identityId: 'identity456',
-                    traits: {
-                        emails: ['test@email.com'],
-                        addresses: [{ city: 'Old City', upa: 1704067200000 }],
-                    },
-                },
-                updatedAt: new Date().toISOString(),
-            };
-            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-            const identityWithNewAddress = {
-                identityId: 'identity456',
-                traits: {
-                    emails: ['test@email.com'],
-                    addresses: [{ city: 'New City', upa: 1717200000000 }],
-                },
-            };
-            const result = await service.resolveIdentityWithCaching(pixelId, identityWithNewAddress);
-            if (result.outcome === IDENTITY_CACHE_WITH_CACHING_OUTCOME.ADDRESS_UPDATE_ASYNC) {
-                expect(result.didWriteCache).toBe(false);
-                expect(result.didEnqueueAsync).toBe(true);
-                expect(mockedDynamoDbClient.safeBatchWrite).not.toHaveBeenCalled();
-                expect(mockBuildAndSendMessage).toHaveBeenCalled();
-            }
-        });
-    });
-});
+import { createService, createServiceWithSqs, createCachedIdentity, mockGetIdentity, mockBuildAndSendMessage, mockedDynamoDbClient, resetAllMocks, TEST_PIXEL_ID, IDENTITY_CACHE_WITH_CACHING_OUTCOME, } from './identity-gateway-test-setup.js';
+describe('IdentityGatewayService stale cache scenarios', () => {
+    const pixelId = TEST_PIXEL_ID;
+    beforeEach(() => {
+        resetAllMocks();
+    });
+    describe('identity-defining trait changes → Neptune', () => {
+        it('should call Neptune when new emails are added', async () => {
+            const service = createService();
+            const cachedResponse = createCachedIdentity(pixelId, 'staleness-compute', {
+                emails: ['old@email.com'],
+            });
+            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
+            mockGetIdentity.mockResolvedValueOnce({
+                identityId: 'staleness-compute',
+                traits: { emails: ['old@email.com', 'new@email.com'] },
+            });
+            const incomingIdentity = {
+                identityId: 'staleness-compute',
+                traits: {
+                    emails: ['old@email.com', 'new@email.com'],
+                },
+            };
+            const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
+            expect(result.didCallNeptune).toBe(true);
+            expect(result.stalenessResult?.staleTraits).toContain('emails');
+        });
+        it('should not skip Neptune for IDENTITY_STALE tier', async () => {
+            const service = createService();
+            const cachedResponse = createCachedIdentity(pixelId, 'call-neptune', {
+                emails: ['old@email.com'],
+            });
+            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
+            mockGetIdentity.mockResolvedValueOnce({
+                identityId: 'call-neptune',
+                traits: { emails: ['old@email.com', 'new@email.com'] },
+            });
+            const incomingIdentity = {
+                identityId: 'call-neptune',
+                traits: {
+                    emails: ['old@email.com', 'new@email.com'],
+                },
+            };
+            const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
+            expect(result.didSkipNeptune).toBe(false);
+            expect(result.didCallNeptune).toBe(true);
+            expect(mockGetIdentity).toHaveBeenCalled();
+        });
+    });
+    describe('Neptune resolution success', () => {
+        it('should return NEPTUNE_RESOLVED outcome', async () => {
+            const service = createService();
+            const cachedResponse = createCachedIdentity(pixelId, 'stale-reason', {
+                emails: ['old@email.com'],
+            });
+            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
+            mockGetIdentity.mockResolvedValueOnce({
+                identityId: 'stale-reason',
+                traits: { emails: ['old@email.com', 'new@email.com'] },
+            });
+            const incomingIdentity = {
+                identityId: 'stale-reason',
+                traits: {
+                    emails: ['old@email.com', 'new@email.com'],
+                },
+            };
+            const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
+            expect(result.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.NEPTUNE_RESOLVED);
+        });
+        it('should compute traitChanges between cached and Neptune identity', async () => {
+            const service = createService();
+            const cachedResponse = createCachedIdentity(pixelId, 'trait-changes', {
+                emails: ['old@email.com'],
+                phones: ['555-old'],
+            });
+            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
+            mockGetIdentity.mockResolvedValueOnce({
+                identityId: 'trait-changes',
+                traits: {
+                    emails: ['old@email.com', 'new@email.com'],
+                    phones: ['555-old', '555-new'],
+                },
+            });
+            const result = await service.resolveIdentityWithCaching(pixelId, { identityId: 'trait-changes', traits: { emails: ['old@email.com', 'new@email.com'] } });
+            expect(result.traitChanges).toBeDefined();
+            expect(result.traitChanges?.emails).toBeDefined();
+        });
+        it('should not write to cache (identity service handles writes)', async () => {
+            const service = createService();
+            const cachedResponse = createCachedIdentity(pixelId, 'neptune-write', {
+                emails: ['old@email.com'],
+            });
+            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
+            mockGetIdentity.mockResolvedValueOnce({
+                identityId: 'neptune-write',
+                traits: {
+                    emails: ['old@email.com', 'new@email.com'],
+                    phones: ['555-neptune'],
+                },
+            });
+            const result = await service.resolveIdentityWithCaching(pixelId, { identityId: 'neptune-write', traits: { emails: ['old@email.com', 'new@email.com'] } });
+            expect(result.didWriteCache).toBe(false);
+            expect(result.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.NEPTUNE_RESOLVED);
+            expect(mockedDynamoDbClient.safeBatchWrite).not.toHaveBeenCalled();
+        });
+        it('should still return Neptune identity when it matches cached', async () => {
+            const service = createService();
+            const cachedResponse = createCachedIdentity(pixelId, 'no-changes', {
+                emails: ['same@email.com'],
+            });
+            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
+            mockGetIdentity.mockResolvedValueOnce({
+                identityId: 'no-changes',
+                traits: { emails: ['same@email.com'] },
+            });
+            const result = await service.resolveIdentityWithCaching(pixelId, { identityId: 'no-changes', traits: { emails: ['same@email.com', 'thought-new@email.com'] } });
+            expect(result.didCallNeptune).toBe(true);
+            expect(result.didWriteCache).toBe(false);
+            expect(result.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.NEPTUNE_RESOLVED);
+        });
+        it('should strip address timestamps when comparing Neptune result', async () => {
+            const service = createService();
+            const now = Date.now();
+            const cachedResponse = {
+                pk: `identity#${pixelId}#addr-timestamp`,
+                pixelId,
+                identityId: 'addr-timestamp',
+                response: {
+                    identityId: 'addr-timestamp',
+                    traits: {
+                        emails: ['test@email.com'],
+                        addresses: [{ city: 'NYC', cra: now - 1000, upa: now - 500 }],
+                    },
+                },
+                updatedAt: new Date().toISOString(),
+            };
+            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
+            mockGetIdentity.mockResolvedValueOnce({
+                identityId: 'addr-timestamp',
+                traits: {
+                    emails: ['test@email.com'],
+                    addresses: [{ city: 'NYC', cra: now, upa: now }],
+                },
+            });
+            const result = await service.resolveIdentityWithCaching(pixelId, { identityId: 'addr-timestamp', traits: { emails: ['test@email.com', 'new@email.com'] } });
+            expect(result.didWriteCache).toBe(false);
+            expect(result.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.NEPTUNE_RESOLVED);
+        });
+    });
+    describe('Neptune resolution failure', () => {
+        it('should return NEPTUNE_RESOLUTION_FAILED outcome', async () => {
+            const service = createService();
+            const cachedResponse = createCachedIdentity(pixelId, 'neptune-throws', {
+                emails: ['old@email.com'],
+            });
+            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
+            mockGetIdentity.mockRejectedValueOnce(new Error('Neptune invocation failed'));
+            const result = await service.resolveIdentityWithCaching(pixelId, { identityId: 'neptune-throws', traits: { emails: ['old@email.com', 'new@email.com'] } });
+            expect(result.didCallNeptune).toBe(true);
+            expect(result.didWriteCache).toBe(false);
+            expect(result.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.NEPTUNE_RESOLUTION_FAILED);
+        });
+        it('should return merged identity on Neptune failure (fail-open)', async () => {
+            const service = createService();
+            const cachedResponse = createCachedIdentity(pixelId, 'neptune-throws', {
+                emails: ['old@email.com'],
+            });
+            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
+            mockGetIdentity.mockRejectedValueOnce(new Error('Neptune invocation failed'));
+            const result = await service.resolveIdentityWithCaching(pixelId, { identityId: 'neptune-throws', traits: { emails: ['old@email.com', 'new@email.com'] } });
+            expect(result.identity).toBeDefined();
+            expect(result.identity?.identityId).toBe('neptune-throws');
+            expect(result.identity?.traits?.emails).toEqual(['old@email.com', 'new@email.com']);
+        });
+        it('should not write to cache when Neptune fails', async () => {
+            const service = createService();
+            const cachedResponse = createCachedIdentity(pixelId, 'no-write-fail', {
+                emails: ['test@email.com'],
+            });
+            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
+            mockGetIdentity.mockRejectedValueOnce(new Error('Network error'));
+            const result = await service.resolveIdentityWithCaching(pixelId, { identityId: 'no-write-fail', traits: { emails: ['test@email.com', 'extra@email.com'] } });
+            expect(result.didWriteCache).toBe(false);
+            expect(mockedDynamoDbClient.safeBatchWrite).not.toHaveBeenCalled();
+        });
+    });
+    describe('address update path', () => {
+        it('should enqueue async update on address changes', async () => {
+            const service = createServiceWithSqs();
+            mockBuildAndSendMessage.mockResolvedValueOnce({ MessageId: 'test-msg-id' });
+            const cachedResponse = {
+                pk: `identity#${pixelId}#identity456`,
+                pixelId,
+                identityId: 'identity456',
+                response: {
+                    identityId: 'identity456',
+                    traits: {
+                        emails: ['test@email.com'],
+                        addresses: [{ city: 'Old City', upa: 1704067200000 }],
+                    },
+                },
+                updatedAt: new Date().toISOString(),
+            };
+            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
+            const identityWithNewAddress = {
+                identityId: 'identity456',
+                traits: {
+                    emails: ['test@email.com'],
+                    addresses: [{ city: 'New City', upa: 1717200000000 }],
+                },
+            };
+            const result = await service.resolveIdentityWithCaching(pixelId, identityWithNewAddress);
+            if (result.outcome === IDENTITY_CACHE_WITH_CACHING_OUTCOME.ADDRESS_UPDATE_ASYNC) {
+                expect(result.didWriteCache).toBe(false);
+                expect(result.didEnqueueAsync).toBe(true);
+                expect(mockedDynamoDbClient.safeBatchWrite).not.toHaveBeenCalled();
+                expect(mockBuildAndSendMessage).toHaveBeenCalled();
+            }
+        });
+    });
+});
 //# sourceMappingURL=identity-gateway-stale-cache.spec.js.map

package/dist/esm/__tests__/identity-cache/identity-gateway-test-setup.d.ts

@@ -1,28 +1,28 @@
-/// <reference types="jest" />
-import { EventContext, EventIdentity, IdentityDynamoDbCache } from '@adtrackify/at-tracking-event-types';
-export declare const mockLambdaInvokeFunction: jest.Mock<any, any>;
-export declare const mockBuildAndSendMessage: jest.Mock<any, any>;
-export declare const mockSQSClientConstructor: jest.Mock<any, any>;
-export declare const mockGetIdentity: jest.Mock<any, any>;
-import { IdentityGatewayService, IdentityGatewayServiceOptions } from '../../services/db/identity-cache-dynamodb-service/identity-gateway-service.js';
-import { IDENTITY_CACHE_WITH_CACHING_OUTCOME } from '../../services/db/identity-cache-dynamodb-service/types.js';
-import { DynamoDbClient, SQSClient } from '../../clients/index.js';
-export declare const mockedDynamoDbClient: jest.Mocked<typeof DynamoDbClient>;
-export declare const mockedLogger: jest.Mocked<{
-    log: (logLevel: string, msg: string | Error, meta?: object | undefined, tags?: string[] | undefined) => void;
-    debug: (msg: string, meta?: object | undefined, tags?: string[] | undefined) => void;
-    info: (msg: string, meta?: object | undefined, tags?: string[] | undefined) => void;
-    warn: (msg: string, meta?: object | undefined, tags?: string[] | undefined) => void;
-    error: (msg: string | Error, meta?: object | undefined, tags?: string[] | undefined) => void;
-}>;
-export declare const mockedSQSClient: jest.MockedClass<typeof SQSClient>;
-export { IdentityGatewayService };
-export { IDENTITY_CACHE_WITH_CACHING_OUTCOME };
-export type { IdentityGatewayServiceOptions };
-export type { EventContext, EventIdentity, IdentityDynamoDbCache };
-export declare const TEST_PIXEL_ID = "pixel123";
-export declare const TEST_LAMBDA_ARN = "arn:aws:lambda:us-east-1:123456789:function:identity-private";
-export declare const createService: (options?: IdentityGatewayServiceOptions) => IdentityGatewayService;
-export declare const createServiceWithSqs: (overrides?: Partial<IdentityGatewayServiceOptions>) => IdentityGatewayService;
-export declare const resetAllMocks: () => void;
-export declare const createCachedIdentity: (pixelId: string, identityId: string, traits: EventIdentity['traits'], updatedAt?: string) => IdentityDynamoDbCache;
+/// <reference types="jest" />
+import { EventContext, EventIdentity, IdentityDynamoDbCache } from '@adtrackify/at-tracking-event-types';
+export declare const mockLambdaInvokeFunction: jest.Mock<any, any>;
+export declare const mockBuildAndSendMessage: jest.Mock<any, any>;
+export declare const mockSQSClientConstructor: jest.Mock<any, any>;
+export declare const mockGetIdentity: jest.Mock<any, any>;
+import { IdentityGatewayService, IdentityGatewayServiceOptions } from '../../services/db/identity-cache-dynamodb-service/identity-gateway-service.js';
+import { IDENTITY_CACHE_WITH_CACHING_OUTCOME } from '../../services/db/identity-cache-dynamodb-service/types.js';
+import { DynamoDbClient, SQSClient } from '../../clients/index.js';
+export declare const mockedDynamoDbClient: jest.Mocked<typeof DynamoDbClient>;
+export declare const mockedLogger: jest.Mocked<{
+    log: (logLevel: string, msg: string | Error, meta?: object | undefined, tags?: string[] | undefined) => void;
+    debug: (msg: string, meta?: object | undefined, tags?: string[] | undefined) => void;
+    info: (msg: string, meta?: object | undefined, tags?: string[] | undefined) => void;
+    warn: (msg: string, meta?: object | undefined, tags?: string[] | undefined) => void;
+    error: (msg: string | Error, meta?: object | undefined, tags?: string[] | undefined) => void;
+}>;
+export declare const mockedSQSClient: jest.MockedClass<typeof SQSClient>;
+export { IdentityGatewayService };
+export { IDENTITY_CACHE_WITH_CACHING_OUTCOME };
+export type { IdentityGatewayServiceOptions };
+export type { EventContext, EventIdentity, IdentityDynamoDbCache };
+export declare const TEST_PIXEL_ID = "pixel123";
+export declare const TEST_LAMBDA_ARN = "arn:aws:lambda:us-east-1:123456789:function:identity-private";
+export declare const createService: (options?: IdentityGatewayServiceOptions) => IdentityGatewayService;
+export declare const createServiceWithSqs: (overrides?: Partial<IdentityGatewayServiceOptions>) => IdentityGatewayService;
+export declare const resetAllMocks: () => void;
+export declare const createCachedIdentity: (pixelId: string, identityId: string, traits: EventIdentity['traits'], updatedAt?: string) => IdentityDynamoDbCache;