@adtrackify/at-service-common 4.0.25 → 4.0.28

package/dist/esm/__tests__/identity-cache/identity-gateway-cache-hit.spec.d.ts

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

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

@@ -1,136 +1,136 @@
-import { createService, createCachedIdentity, mockGetIdentity, mockedDynamoDbClient, resetAllMocks, TEST_PIXEL_ID, IDENTITY_CACHE_WITH_CACHING_OUTCOME, } from './identity-gateway-test-setup.js';
-describe('IdentityGatewayService cache hit scenarios', () => {
-    const pixelId = TEST_PIXEL_ID;
-    beforeEach(() => {
-        resetAllMocks();
-    });
-    describe('fresh cache hit', () => {
-        it('should return cached identity without calling Neptune', async () => {
-            const service = createService();
-            const cachedResponse = createCachedIdentity(pixelId, 'identity456', {
-                emails: ['test@email.com'],
-            });
-            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-            const incomingIdentity = {
-                identityId: 'identity456',
-                traits: { emails: ['test@email.com'] },
-            };
-            const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
-            expect(result.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.FRESH_CACHE_HIT);
-            expect(result.didCallNeptune).toBe(false);
-            expect(result.didWriteCache).toBe(false);
-            expect(mockGetIdentity).not.toHaveBeenCalled();
-            expect(mockedDynamoDbClient.safeBatchWrite).not.toHaveBeenCalled();
-        });
-        it('should treat as cache hit when merged identity is deep equal to cached', async () => {
-            const service = createService();
-            const cachedResponse = createCachedIdentity(pixelId, 'deep-equal', {
-                emails: ['same@email.com'],
-                phones: ['555-1234'],
-            });
-            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-            const incomingIdentity = {
-                identityId: 'deep-equal',
-                traits: {
-                    emails: ['same@email.com'],
-                    phones: ['555-1234'],
-                },
-            };
-            const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
-            expect(result.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.FRESH_CACHE_HIT);
-            expect(result.didCallNeptune).toBe(false);
-            expect(mockGetIdentity).not.toHaveBeenCalled();
-        });
-    });
-    describe('address timestamp stripping', () => {
-        it('should strip address timestamps before deep equality comparison', async () => {
-            const service = createService();
-            const now = Date.now();
-            const cachedResponse = {
-                pk: `identity#${pixelId}#timestamp-strip`,
-                pixelId,
-                identityId: 'timestamp-strip',
-                response: {
-                    identityId: 'timestamp-strip',
-                    traits: {
-                        emails: ['test@email.com'],
-                        addresses: [{ city: 'NYC', cra: now - 10000, upa: now - 5000 }],
-                    },
-                },
-                updatedAt: new Date().toISOString(),
-            };
-            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-            const incomingIdentity = {
-                identityId: 'timestamp-strip',
-                traits: {
-                    emails: ['test@email.com'],
-                    addresses: [{ city: 'NYC', cra: now, upa: now }],
-                },
-            };
-            const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
-            expect(result.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.FRESH_CACHE_HIT);
-            expect(result.didCallNeptune).toBe(false);
-        });
-    });
-    describe('volatile-only cache hit', () => {
-        it('should treat VOLATILE_ONLY changes as cache hit', async () => {
-            const service = createService();
-            const cachedResponse = createCachedIdentity(pixelId, 'volatile-override', {
-                emails: ['same@email.com'],
-            });
-            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-            const incomingIdentity = {
-                identityId: 'volatile-override',
-                traits: {
-                    emails: ['same@email.com'],
-                    ipAddress: '10.0.0.1',
-                    userAgent: 'Mozilla/5.0 (New)',
-                },
-            };
-            const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
-            expect(result.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.VOLATILE_ONLY_CACHE_HIT);
-            expect(result.didCallNeptune).toBe(false);
-            expect(result.didWriteCache).toBe(false);
-        });
-        it('should return merged identity for VOLATILE_ONLY tier', async () => {
-            const service = createService();
-            const cachedResponse = createCachedIdentity(pixelId, 'volatile-merged', {
-                emails: ['test@email.com'],
-                phones: ['555-cached'],
-            });
-            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-            const incomingIdentity = {
-                identityId: 'volatile-merged',
-                traits: {
-                    emails: ['test@email.com'],
-                    ipAddress: '10.0.0.1',
-                },
-            };
-            const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
-            expect(result.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.VOLATILE_ONLY_CACHE_HIT);
-            expect(result.identity?.traits?.emails).toContain('test@email.com');
-            expect(result.identity?.traits?.phones).toContain('555-cached');
-            expect(result.identity?.traits?.ipAddress).toBe('10.0.0.1');
-        });
-    });
-    describe('trait merging', () => {
-        it('should merge incoming traits with cached traits on cache hit', async () => {
-            const service = createService();
-            const cachedResponse = createCachedIdentity(pixelId, 'merge-test', {
-                emails: ['cached@email.com'],
-                phones: ['555-cached'],
-            });
-            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-            const incomingIdentity = {
-                identityId: 'merge-test',
-                traits: {
-                    emails: ['cached@email.com'],
-                },
-            };
-            const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
-            expect(result.identity?.traits?.emails).toContain('cached@email.com');
-            expect(result.identity?.traits?.phones).toContain('555-cached');
-        });
-    });
-});
+import { createService, createCachedIdentity, mockGetIdentity, mockedDynamoDbClient, resetAllMocks, TEST_PIXEL_ID, IDENTITY_CACHE_WITH_CACHING_OUTCOME, } from './identity-gateway-test-setup.js';
+describe('IdentityGatewayService cache hit scenarios', () => {
+    const pixelId = TEST_PIXEL_ID;
+    beforeEach(() => {
+        resetAllMocks();
+    });
+    describe('fresh cache hit', () => {
+        it('should return cached identity without calling Neptune', async () => {
+            const service = createService();
+            const cachedResponse = createCachedIdentity(pixelId, 'identity456', {
+                emails: ['test@email.com'],
+            });
+            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
+            const incomingIdentity = {
+                identityId: 'identity456',
+                traits: { emails: ['test@email.com'] },
+            };
+            const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
+            expect(result.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.FRESH_CACHE_HIT);
+            expect(result.didCallNeptune).toBe(false);
+            expect(result.didWriteCache).toBe(false);
+            expect(mockGetIdentity).not.toHaveBeenCalled();
+            expect(mockedDynamoDbClient.safeBatchWrite).not.toHaveBeenCalled();
+        });
+        it('should treat as cache hit when merged identity is deep equal to cached', async () => {
+            const service = createService();
+            const cachedResponse = createCachedIdentity(pixelId, 'deep-equal', {
+                emails: ['same@email.com'],
+                phones: ['555-1234'],
+            });
+            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
+            const incomingIdentity = {
+                identityId: 'deep-equal',
+                traits: {
+                    emails: ['same@email.com'],
+                    phones: ['555-1234'],
+                },
+            };
+            const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
+            expect(result.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.FRESH_CACHE_HIT);
+            expect(result.didCallNeptune).toBe(false);
+            expect(mockGetIdentity).not.toHaveBeenCalled();
+        });
+    });
+    describe('address timestamp stripping', () => {
+        it('should strip address timestamps before deep equality comparison', async () => {
+            const service = createService();
+            const now = Date.now();
+            const cachedResponse = {
+                pk: `identity#${pixelId}#timestamp-strip`,
+                pixelId,
+                identityId: 'timestamp-strip',
+                response: {
+                    identityId: 'timestamp-strip',
+                    traits: {
+                        emails: ['test@email.com'],
+                        addresses: [{ city: 'NYC', cra: now - 10000, upa: now - 5000 }],
+                    },
+                },
+                updatedAt: new Date().toISOString(),
+            };
+            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
+            const incomingIdentity = {
+                identityId: 'timestamp-strip',
+                traits: {
+                    emails: ['test@email.com'],
+                    addresses: [{ city: 'NYC', cra: now, upa: now }],
+                },
+            };
+            const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
+            expect(result.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.FRESH_CACHE_HIT);
+            expect(result.didCallNeptune).toBe(false);
+        });
+    });
+    describe('volatile-only cache hit', () => {
+        it('should treat VOLATILE_ONLY changes as cache hit', async () => {
+            const service = createService();
+            const cachedResponse = createCachedIdentity(pixelId, 'volatile-override', {
+                emails: ['same@email.com'],
+            });
+            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
+            const incomingIdentity = {
+                identityId: 'volatile-override',
+                traits: {
+                    emails: ['same@email.com'],
+                    ipAddress: '10.0.0.1',
+                    userAgent: 'Mozilla/5.0 (New)',
+                },
+            };
+            const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
+            expect(result.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.VOLATILE_ONLY_CACHE_HIT);
+            expect(result.didCallNeptune).toBe(false);
+            expect(result.didWriteCache).toBe(false);
+        });
+        it('should return merged identity for VOLATILE_ONLY tier', async () => {
+            const service = createService();
+            const cachedResponse = createCachedIdentity(pixelId, 'volatile-merged', {
+                emails: ['test@email.com'],
+                phones: ['555-cached'],
+            });
+            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
+            const incomingIdentity = {
+                identityId: 'volatile-merged',
+                traits: {
+                    emails: ['test@email.com'],
+                    ipAddress: '10.0.0.1',
+                },
+            };
+            const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
+            expect(result.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.VOLATILE_ONLY_CACHE_HIT);
+            expect(result.identity?.traits?.emails).toContain('test@email.com');
+            expect(result.identity?.traits?.phones).toContain('555-cached');
+            expect(result.identity?.traits?.ipAddress).toBe('10.0.0.1');
+        });
+    });
+    describe('trait merging', () => {
+        it('should merge incoming traits with cached traits on cache hit', async () => {
+            const service = createService();
+            const cachedResponse = createCachedIdentity(pixelId, 'merge-test', {
+                emails: ['cached@email.com'],
+                phones: ['555-cached'],
+            });
+            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
+            const incomingIdentity = {
+                identityId: 'merge-test',
+                traits: {
+                    emails: ['cached@email.com'],
+                },
+            };
+            const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
+            expect(result.identity?.traits?.emails).toContain('cached@email.com');
+            expect(result.identity?.traits?.phones).toContain('555-cached');
+        });
+    });
+});
 //# sourceMappingURL=identity-gateway-cache-hit.spec.js.map

package/dist/esm/__tests__/identity-cache/identity-gateway-cache-miss.spec.d.ts

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

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

@@ -1,151 +1,151 @@
-import { createService, mockGetIdentity, mockedDynamoDbClient, resetAllMocks, TEST_PIXEL_ID, IDENTITY_CACHE_WITH_CACHING_OUTCOME, } from './identity-gateway-test-setup.js';
-describe('IdentityGatewayService cache miss scenarios', () => {
-    const pixelId = TEST_PIXEL_ID;
-    beforeEach(() => {
-        resetAllMocks();
-    });
-    describe('Neptune resolution on cache miss', () => {
-        it('should call Neptune with incoming identity when no cached identity', async () => {
-            const service = createService();
-            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(null);
-            mockGetIdentity.mockResolvedValueOnce({
-                identityId: 'neptune-resolved-id',
-                traits: { emails: ['test@email.com'] },
-            });
-            const incomingIdentity = {
-                identityId: 'incoming-id',
-                traits: { emails: ['test@email.com'] },
-            };
-            const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
-            expect(mockGetIdentity).toHaveBeenCalledWith(pixelId, expect.objectContaining({
-                identity: expect.objectContaining({
-                    identityId: 'incoming-id',
-                }),
-            }));
-            expect(result.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.NEPTUNE_RESOLVED);
-            expect(result.didReadCache).toBe(true);
-            expect(result.didCallNeptune).toBe(true);
-        });
-        it('should return Neptune identity on successful resolution', async () => {
-            const service = createService();
-            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(null);
-            mockGetIdentity.mockResolvedValueOnce({
-                identityId: 'from-neptune',
-                traits: { emails: ['neptune@email.com'] },
-            });
-            const result = await service.resolveIdentityWithCaching(pixelId, { identityId: 'original', traits: { emails: ['original@email.com'] } });
-            expect(result.identity?.identityId).toBe('from-neptune');
-            expect(result.identity?.traits?.emails).toContain('neptune@email.com');
-        });
-        it('should include traitChanges with "no cached identity" reason', async () => {
-            const service = createService();
-            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(null);
-            mockGetIdentity.mockResolvedValueOnce({
-                identityId: 'new-identity',
-                traits: { emails: ['new@email.com'] },
-            });
-            const result = await service.resolveIdentityWithCaching(pixelId, { identityId: 'incoming', traits: { emails: ['incoming@email.com'] } });
-            expect(result.traitChanges).toEqual({
-                reason: { resolved: 'no cached identity' },
-            });
-        });
-        it('should not write to cache (identity service handles writes)', async () => {
-            const service = createService();
-            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(null);
-            mockGetIdentity.mockResolvedValueOnce({
-                identityId: 'neptune-success',
-                traits: { emails: ['test@email.com'], phones: ['555-1234'] },
-            });
-            const result = await service.resolveIdentityWithCaching(pixelId, { identityId: 'incoming', traits: { emails: ['test@email.com'] } });
-            expect(result.didWriteCache).toBe(false);
-            expect(result.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.NEPTUNE_RESOLVED);
-            expect(mockedDynamoDbClient.safeBatchWrite).not.toHaveBeenCalled();
-        });
-    });
-    describe('email pointer discovery', () => {
-        it('should discover identity ID from email lookup when incoming has no ID', async () => {
-            const service = createService();
-            const incomingNoId = {
-                traits: { emails: ['discovered@email.com'] },
-            };
-            mockedDynamoDbClient.safeGet.mockResolvedValueOnce({
-                pk: `email#${pixelId}#discovered@email.com`,
-                identityId: 'discovered-identity-id',
-            });
-            mockGetIdentity.mockResolvedValueOnce({
-                identityId: 'discovered-identity-id',
-                traits: { emails: ['discovered@email.com', 'other@email.com'] },
-            });
-            const result = await service.resolveIdentityWithCaching(pixelId, incomingNoId);
-            expect(result.identity?.identityId).toBe('discovered-identity-id');
-        });
-        it('should use incoming identity traits in Neptune call', async () => {
-            const service = createService();
-            mockedDynamoDbClient.safeGet.mockResolvedValueOnce({
-                pk: `email#${pixelId}#test@email.com`,
-                identityId: 'discovered-from-email',
-            });
-            mockGetIdentity.mockResolvedValueOnce({
-                identityId: 'neptune-resolved',
-                traits: { emails: ['test@email.com'] },
-            });
-            await service.resolveIdentityWithCaching(pixelId, { traits: { emails: ['test@email.com'] } });
-            expect(mockGetIdentity).toHaveBeenCalledWith(pixelId, expect.objectContaining({
-                identity: expect.objectContaining({
-                    traits: expect.objectContaining({ emails: ['test@email.com'] }),
-                }),
-            }));
-        });
-    });
-    describe('Neptune resolution failure', () => {
-        it('should fallback to incoming identity when Neptune fails', async () => {
-            const service = createService();
-            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(null);
-            mockGetIdentity.mockRejectedValueOnce(new Error('Neptune unavailable'));
-            const incomingIdentity = {
-                identityId: 'fallback-incoming',
-                traits: { emails: ['fallback@email.com'] },
-            };
-            const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
-            expect(result.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.NEPTUNE_RESOLUTION_FAILED);
-            expect(result.didFallbackToIncoming).toBe(true);
-            expect(result.identity?.identityId).toBe('fallback-incoming');
-        });
-        it('should not write to cache when Neptune fails', async () => {
-            const service = createService();
-            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(null);
-            mockGetIdentity.mockRejectedValueOnce(new Error('Lambda timeout'));
-            const result = await service.resolveIdentityWithCaching(pixelId, { identityId: 'test', traits: {} });
-            expect(result.didWriteCache).toBe(false);
-            expect(mockedDynamoDbClient.safeBatchWrite).not.toHaveBeenCalled();
-        });
-        it('should use discovered identity ID as fallback when available', async () => {
-            const service = createService();
-            mockedDynamoDbClient.safeGet.mockResolvedValueOnce({
-                pk: `email#${pixelId}#test@email.com`,
-                identityId: 'discovered-id',
-            });
-            mockGetIdentity.mockRejectedValueOnce(new Error('Neptune error'));
-            const result = await service.resolveIdentityWithCaching(pixelId, { traits: { emails: ['test@email.com'] } });
-            expect(result.didFallbackToIncoming).toBe(true);
-            expect(result.identity?.identityId).toBe('discovered-id');
-            expect(result.identity?.traits?.emails).toContain('test@email.com');
-        });
-    });
-    describe('cache read failure', () => {
-        it('should continue to Neptune when cache read fails (fail-open)', async () => {
-            const service = createService();
-            mockedDynamoDbClient.safeGet.mockRejectedValueOnce(new Error('DynamoDB error'));
-            mockGetIdentity.mockResolvedValueOnce({
-                identityId: 'neptune-resolved',
-                traits: { emails: ['test@email.com'] },
-            });
-            const result = await service.resolveIdentityWithCaching(pixelId, { identityId: 'test-id', traits: { emails: ['test@email.com'] } });
-            expect(result.identity).toBeDefined();
-            expect(result.identity?.identityId).toBe('neptune-resolved');
-            expect(result.didReadCache).toBe(true);
-            expect(result.didCallNeptune).toBe(true);
-        });
-    });
-});
+import { createService, mockGetIdentity, mockedDynamoDbClient, resetAllMocks, TEST_PIXEL_ID, IDENTITY_CACHE_WITH_CACHING_OUTCOME, } from './identity-gateway-test-setup.js';
+describe('IdentityGatewayService cache miss scenarios', () => {
+    const pixelId = TEST_PIXEL_ID;
+    beforeEach(() => {
+        resetAllMocks();
+    });
+    describe('Neptune resolution on cache miss', () => {
+        it('should call Neptune with incoming identity when no cached identity', async () => {
+            const service = createService();
+            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(null);
+            mockGetIdentity.mockResolvedValueOnce({
+                identityId: 'neptune-resolved-id',
+                traits: { emails: ['test@email.com'] },
+            });
+            const incomingIdentity = {
+                identityId: 'incoming-id',
+                traits: { emails: ['test@email.com'] },
+            };
+            const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
+            expect(mockGetIdentity).toHaveBeenCalledWith(pixelId, expect.objectContaining({
+                identity: expect.objectContaining({
+                    identityId: 'incoming-id',
+                }),
+            }));
+            expect(result.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.NEPTUNE_RESOLVED);
+            expect(result.didReadCache).toBe(true);
+            expect(result.didCallNeptune).toBe(true);
+        });
+        it('should return Neptune identity on successful resolution', async () => {
+            const service = createService();
+            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(null);
+            mockGetIdentity.mockResolvedValueOnce({
+                identityId: 'from-neptune',
+                traits: { emails: ['neptune@email.com'] },
+            });
+            const result = await service.resolveIdentityWithCaching(pixelId, { identityId: 'original', traits: { emails: ['original@email.com'] } });
+            expect(result.identity?.identityId).toBe('from-neptune');
+            expect(result.identity?.traits?.emails).toContain('neptune@email.com');
+        });
+        it('should include traitChanges with "no cached identity" reason', async () => {
+            const service = createService();
+            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(null);
+            mockGetIdentity.mockResolvedValueOnce({
+                identityId: 'new-identity',
+                traits: { emails: ['new@email.com'] },
+            });
+            const result = await service.resolveIdentityWithCaching(pixelId, { identityId: 'incoming', traits: { emails: ['incoming@email.com'] } });
+            expect(result.traitChanges).toEqual({
+                reason: { resolved: 'no cached identity' },
+            });
+        });
+        it('should not write to cache (identity service handles writes)', async () => {
+            const service = createService();
+            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(null);
+            mockGetIdentity.mockResolvedValueOnce({
+                identityId: 'neptune-success',
+                traits: { emails: ['test@email.com'], phones: ['555-1234'] },
+            });
+            const result = await service.resolveIdentityWithCaching(pixelId, { identityId: 'incoming', traits: { emails: ['test@email.com'] } });
+            expect(result.didWriteCache).toBe(false);
+            expect(result.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.NEPTUNE_RESOLVED);
+            expect(mockedDynamoDbClient.safeBatchWrite).not.toHaveBeenCalled();
+        });
+    });
+    describe('email pointer discovery', () => {
+        it('should discover identity ID from email lookup when incoming has no ID', async () => {
+            const service = createService();
+            const incomingNoId = {
+                traits: { emails: ['discovered@email.com'] },
+            };
+            mockedDynamoDbClient.safeGet.mockResolvedValueOnce({
+                pk: `email#${pixelId}#discovered@email.com`,
+                identityId: 'discovered-identity-id',
+            });
+            mockGetIdentity.mockResolvedValueOnce({
+                identityId: 'discovered-identity-id',
+                traits: { emails: ['discovered@email.com', 'other@email.com'] },
+            });
+            const result = await service.resolveIdentityWithCaching(pixelId, incomingNoId);
+            expect(result.identity?.identityId).toBe('discovered-identity-id');
+        });
+        it('should use incoming identity traits in Neptune call', async () => {
+            const service = createService();
+            mockedDynamoDbClient.safeGet.mockResolvedValueOnce({
+                pk: `email#${pixelId}#test@email.com`,
+                identityId: 'discovered-from-email',
+            });
+            mockGetIdentity.mockResolvedValueOnce({
+                identityId: 'neptune-resolved',
+                traits: { emails: ['test@email.com'] },
+            });
+            await service.resolveIdentityWithCaching(pixelId, { traits: { emails: ['test@email.com'] } });
+            expect(mockGetIdentity).toHaveBeenCalledWith(pixelId, expect.objectContaining({
+                identity: expect.objectContaining({
+                    traits: expect.objectContaining({ emails: ['test@email.com'] }),
+                }),
+            }));
+        });
+    });
+    describe('Neptune resolution failure', () => {
+        it('should fallback to incoming identity when Neptune fails', async () => {
+            const service = createService();
+            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(null);
+            mockGetIdentity.mockRejectedValueOnce(new Error('Neptune unavailable'));
+            const incomingIdentity = {
+                identityId: 'fallback-incoming',
+                traits: { emails: ['fallback@email.com'] },
+            };
+            const result = await service.resolveIdentityWithCaching(pixelId, incomingIdentity);
+            expect(result.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.NEPTUNE_RESOLUTION_FAILED);
+            expect(result.didFallbackToIncoming).toBe(true);
+            expect(result.identity?.identityId).toBe('fallback-incoming');
+        });
+        it('should not write to cache when Neptune fails', async () => {
+            const service = createService();
+            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(null);
+            mockGetIdentity.mockRejectedValueOnce(new Error('Lambda timeout'));
+            const result = await service.resolveIdentityWithCaching(pixelId, { identityId: 'test', traits: {} });
+            expect(result.didWriteCache).toBe(false);
+            expect(mockedDynamoDbClient.safeBatchWrite).not.toHaveBeenCalled();
+        });
+        it('should use discovered identity ID as fallback when available', async () => {
+            const service = createService();
+            mockedDynamoDbClient.safeGet.mockResolvedValueOnce({
+                pk: `email#${pixelId}#test@email.com`,
+                identityId: 'discovered-id',
+            });
+            mockGetIdentity.mockRejectedValueOnce(new Error('Neptune error'));
+            const result = await service.resolveIdentityWithCaching(pixelId, { traits: { emails: ['test@email.com'] } });
+            expect(result.didFallbackToIncoming).toBe(true);
+            expect(result.identity?.identityId).toBe('discovered-id');
+            expect(result.identity?.traits?.emails).toContain('test@email.com');
+        });
+    });
+    describe('cache read failure', () => {
+        it('should continue to Neptune when cache read fails (fail-open)', async () => {
+            const service = createService();
+            mockedDynamoDbClient.safeGet.mockRejectedValueOnce(new Error('DynamoDB error'));
+            mockGetIdentity.mockResolvedValueOnce({
+                identityId: 'neptune-resolved',
+                traits: { emails: ['test@email.com'] },
+            });
+            const result = await service.resolveIdentityWithCaching(pixelId, { identityId: 'test-id', traits: { emails: ['test@email.com'] } });
+            expect(result.identity).toBeDefined();
+            expect(result.identity?.identityId).toBe('neptune-resolved');
+            expect(result.didReadCache).toBe(true);
+            expect(result.didCallNeptune).toBe(true);
+        });
+    });
+});
 //# sourceMappingURL=identity-gateway-cache-miss.spec.js.map

package/dist/esm/__tests__/identity-cache/identity-gateway-constructor.spec.d.ts

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