@adtrackify/at-service-common 4.0.13 → 4.0.14

package/dist/esm/__tests__/identity-cache/identity-cache-tier-routing.spec.js

@@ -1,7 +1,5 @@
 import { ADDRESS_INFO_SOURCE } from '@adtrackify/at-tracking-event-types';
-import { IDENTITY_CACHE_STALENESS_TIER } from '@adtrackify/at-shared-utils';
-import { CACHE_WRITE_REASON } from '../../services/db/identity-cache-dynamodb-service';
-const mockInvokeFunction = jest.fn();
+const mockLambdaInvoke = jest.fn();
 const mockBuildAndSendMessage = jest.fn();
 const mockSQSClientConstructor = jest.fn();
 jest.mock('../../clients/index.js', () => ({
@@ -15,7 +13,7 @@ jest.mock('../../clients/index.js', () => ({
         batchWrite: jest.fn(),
     },
     LambdaInvokeClient: jest.fn().mockImplementation(() => ({
-        invokeFunction: mockInvokeFunction,
+        invokeFunction: mockLambdaInvoke,
     })),
     SQSClient: jest.fn().mockImplementation((_region, _accountId, _queueName) => {
         mockSQSClientConstructor(_region, _accountId, _queueName);
@@ -33,15 +31,19 @@ jest.mock('../../helpers/index.js', () => ({
         error: jest.fn(),
     },
 }));
+const mockGetIdentity = jest.fn();
+jest.mock('../../clients/internal-api/identity-client.js', () => ({
+    IdentityClient: jest.fn().mockImplementation(() => ({
+        getIdentity: mockGetIdentity,
+    })),
+}));
 import { IdentityGatewayService, } 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 { IdentityCacheDynamoDbDbService } from '../../services/db/identity-cache-dynamodb-service/identity-cache-dynamodb-db-service.js';
 import { DynamoDbClient, SQSClient } from '../../clients/index.js';
 const mockedDynamoDbClient = DynamoDbClient;
 const _mockedSQSClient = SQSClient;
 describe('Identity Cache Three-Tier Routing', () => {
     const pixelId = 'pixel123';
-    const lambdaArn = 'arn:aws:lambda:us-east-1:123456789:function:identity-private';
     beforeEach(() => {
         jest.clearAllMocks();
         mockedDynamoDbClient.safeGet.mockReset();
@@ -51,13 +53,14 @@ describe('Identity Cache Three-Tier Routing', () => {
         mockedDynamoDbClient.safeBatchWrite.mockReset();
         mockedDynamoDbClient.safeQueryByGSI.mockReset();
         mockedDynamoDbClient.batchWrite.mockReset();
-        mockInvokeFunction.mockReset();
+        mockGetIdentity.mockReset();
         mockBuildAndSendMessage.mockReset();
         mockSQSClientConstructor.mockReset();
         _mockedSQSClient.mockClear();
-        IdentityGatewayService.lambdaInvokeClient = undefined;
+        IdentityGatewayService.identityClient = undefined;
         IdentityGatewayService.sqsClient = undefined;
         IdentityGatewayService.sqsQueueUrl = undefined;
+        IdentityGatewayService.configure({ identifyPrivateLambdaArn: 'arn:aws:lambda:us-east-1:123456789:function:identity-private' });
     });
     describe('TIER: VOLATILE_ONLY — Returns merged identity, NO Neptune, NO cache write', () => {
         it('should return merged identity without Neptune call when only ipAddress is stale', async () => {
@@ -82,10 +85,10 @@ describe('Identity Cache Three-Tier Routing', () => {
                 updatedAt: new Date().toISOString(),
             };
             mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-            const result = await IdentityGatewayService.getIdentityWithCachingV2(pixelId, incomingIdentity, lambdaArn);
+            const result = await IdentityGatewayService.resolveIdentityWithCaching(pixelId, incomingIdentity);
             expect(result.identity).toBeDefined();
             expect(result.identity?.identityId).toBe('identity456');
-            expect(mockInvokeFunction).not.toHaveBeenCalled();
+            expect(mockGetIdentity).not.toHaveBeenCalled();
             expect(mockedDynamoDbClient.safeBatchWrite).not.toHaveBeenCalled();
         });
         it('should return merged identity without Neptune call when only userAgent is stale', async () => {
@@ -110,9 +113,9 @@ describe('Identity Cache Three-Tier Routing', () => {
                 updatedAt: new Date().toISOString(),
             };
             mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-            const result = await IdentityGatewayService.getIdentityWithCachingV2(pixelId, incomingIdentity, lambdaArn);
+            const result = await IdentityGatewayService.resolveIdentityWithCaching(pixelId, incomingIdentity);
             expect(result.identity).toBeDefined();
-            expect(mockInvokeFunction).not.toHaveBeenCalled();
+            expect(mockGetIdentity).not.toHaveBeenCalled();
             expect(mockedDynamoDbClient.safeBatchWrite).not.toHaveBeenCalled();
         });
         it('should return merged identity without Neptune call when only IP-sourced addresses are stale', async () => {
@@ -137,117 +140,12 @@ describe('Identity Cache Three-Tier Routing', () => {
                 updatedAt: new Date().toISOString(),
             };
             mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-            const result = await IdentityGatewayService.getIdentityWithCachingV2(pixelId, incomingIdentity, lambdaArn);
+            const result = await IdentityGatewayService.resolveIdentityWithCaching(pixelId, incomingIdentity);
             expect(result.identity).toBeDefined();
-            expect(mockInvokeFunction).not.toHaveBeenCalled();
+            expect(mockGetIdentity).not.toHaveBeenCalled();
             expect(mockedDynamoDbClient.safeBatchWrite).not.toHaveBeenCalled();
         });
     });
-    describe('TIER: ADDRESS_UPDATE — Enqueues async update, NO Neptune call, NO sync cache write', () => {
-        it('should enqueue async update but skip Neptune when new non-IP address is added', async () => {
-            IdentityGatewayService.configure({
-                awsRegion: 'us-east-1',
-                awsAccountId: '123456789',
-                asyncUpdateQueueName: 'test-queue',
-            });
-            mockBuildAndSendMessage.mockResolvedValueOnce({ MessageId: 'test-msg-id' });
-            const incomingIdentity = {
-                identityId: 'identity456',
-                traits: {
-                    emails: ['test@email.com'],
-                    addresses: [{ city: 'Boston', firstName: 'John', s: ADDRESS_INFO_SOURCE.INPUT }],
-                },
-            };
-            const cachedResponse = {
-                pk: `identity#${pixelId}#identity456`,
-                pixelId,
-                identityId: 'identity456',
-                response: {
-                    identityId: 'identity456',
-                    traits: {
-                        emails: ['test@email.com'],
-                        addresses: [],
-                    },
-                },
-                updatedAt: new Date().toISOString(),
-            };
-            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-            const result = await IdentityGatewayService.getIdentityWithCachingV2(pixelId, incomingIdentity, lambdaArn);
-            expect(result.identity).toBeDefined();
-            expect(result.identity?.traits?.addresses).toHaveLength(1);
-            expect(mockInvokeFunction).not.toHaveBeenCalled();
-            expect(mockedDynamoDbClient.safeBatchWrite).not.toHaveBeenCalled();
-            expect(mockBuildAndSendMessage).toHaveBeenCalled();
-        });
-        it('should enqueue async update and skip Neptune when address with PII but no source is added', async () => {
-            IdentityGatewayService.configure({
-                awsRegion: 'us-east-1',
-                awsAccountId: '123456789',
-                asyncUpdateQueueName: 'test-queue',
-            });
-            mockBuildAndSendMessage.mockResolvedValueOnce({ MessageId: 'test-msg-id' });
-            const incomingIdentity = {
-                identityId: 'identity456',
-                traits: {
-                    emails: ['test@email.com'],
-                    addresses: [{ city: 'Miami', lastName: 'Smith' }],
-                },
-            };
-            const cachedResponse = {
-                pk: `identity#${pixelId}#identity456`,
-                pixelId,
-                identityId: 'identity456',
-                response: {
-                    identityId: 'identity456',
-                    traits: {
-                        emails: ['test@email.com'],
-                        addresses: [],
-                    },
-                },
-                updatedAt: new Date().toISOString(),
-            };
-            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-            const result = await IdentityGatewayService.getIdentityWithCachingV2(pixelId, incomingIdentity, lambdaArn);
-            expect(result.identity).toBeDefined();
-            expect(mockInvokeFunction).not.toHaveBeenCalled();
-            expect(mockedDynamoDbClient.safeBatchWrite).not.toHaveBeenCalled();
-            expect(mockBuildAndSendMessage).toHaveBeenCalled();
-        });
-        it('should return ADDRESS_UPDATE_ASYNC outcome in summary', async () => {
-            IdentityGatewayService.configure({
-                awsRegion: 'us-east-1',
-                awsAccountId: '123456789',
-                asyncUpdateQueueName: 'test-queue',
-            });
-            mockBuildAndSendMessage.mockResolvedValueOnce({ MessageId: 'test-msg-id' });
-            const incomingIdentity = {
-                identityId: 'identity456',
-                traits: {
-                    emails: ['test@email.com'],
-                    addresses: [{ city: 'Seattle', s: ADDRESS_INFO_SOURCE.INPUT }],
-                },
-            };
-            const cachedResponse = {
-                pk: `identity#${pixelId}#identity456`,
-                pixelId,
-                identityId: 'identity456',
-                response: {
-                    identityId: 'identity456',
-                    traits: {
-                        emails: ['test@email.com'],
-                        addresses: [],
-                    },
-                },
-                updatedAt: new Date().toISOString(),
-            };
-            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-            const result = await IdentityGatewayService.getIdentityWithCachingV2(pixelId, incomingIdentity, lambdaArn);
-            expect(result.summary.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.ADDRESS_UPDATE_ASYNC);
-            expect(result.summary.didSkipNeptune).toBe(true);
-            expect(result.summary.didWriteCache).toBe(false);
-            expect(result.summary.didEnqueueAsync).toBe(true);
-        });
-    });
     describe('TIER: IDENTITY_STALE — Calls Neptune AND writes to cache', () => {
         it('should call Neptune and write to cache when emails are stale', async () => {
             const incomingIdentity = {
@@ -269,18 +167,13 @@ describe('Identity Cache Three-Tier Routing', () => {
                 updatedAt: new Date().toISOString(),
             };
             mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-            mockInvokeFunction.mockResolvedValueOnce({
-                statusCode: 200,
-                body: JSON.stringify({
-                    identity: {
-                        identityId: 'identity456',
-                        traits: { emails: ['old@email.com', 'new@email.com', 'resolved@email.com'] },
-                    },
-                }),
+            mockGetIdentity.mockResolvedValueOnce({
+                identityId: 'identity456',
+                traits: { emails: ['old@email.com', 'new@email.com', 'resolved@email.com'] },
             });
-            const result = await IdentityGatewayService.getIdentityWithCachingV2(pixelId, incomingIdentity, lambdaArn);
+            const result = await IdentityGatewayService.resolveIdentityWithCaching(pixelId, incomingIdentity);
             expect(result.identity).toBeDefined();
-            expect(mockInvokeFunction).toHaveBeenCalled();
+            expect(mockGetIdentity).toHaveBeenCalled();
             expect(mockedDynamoDbClient.safeBatchWrite).not.toHaveBeenCalled();
         });
         it('should call Neptune and write to cache when phones are stale', async () => {
@@ -303,18 +196,13 @@ describe('Identity Cache Three-Tier Routing', () => {
                 updatedAt: new Date().toISOString(),
             };
             mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-            mockInvokeFunction.mockResolvedValueOnce({
-                statusCode: 200,
-                body: JSON.stringify({
-                    identity: {
-                        identityId: 'identity456',
-                        traits: { phones: ['+1234567890', '+9876543210'] },
-                    },
-                }),
+            mockGetIdentity.mockResolvedValueOnce({
+                identityId: 'identity456',
+                traits: { phones: ['+1234567890', '+9876543210'] },
             });
-            const result = await IdentityGatewayService.getIdentityWithCachingV2(pixelId, incomingIdentity, lambdaArn);
+            const result = await IdentityGatewayService.resolveIdentityWithCaching(pixelId, incomingIdentity);
             expect(result.identity).toBeDefined();
-            expect(mockInvokeFunction).toHaveBeenCalled();
+            expect(mockGetIdentity).toHaveBeenCalled();
             expect(mockedDynamoDbClient.safeBatchWrite).not.toHaveBeenCalled();
         });
         it('should return NEPTUNE_WRITE_BACK outcome with staleTraits in summary', async () => {
@@ -335,20 +223,15 @@ describe('Identity Cache Three-Tier Routing', () => {
                 updatedAt: new Date().toISOString(),
             };
             mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-            mockInvokeFunction.mockResolvedValueOnce({
-                statusCode: 200,
-                body: JSON.stringify({
-                    identity: {
-                        identityId: 'identity456',
-                        traits: { emails: ['old@email.com', 'new@email.com'] },
-                    },
-                }),
+            mockGetIdentity.mockResolvedValueOnce({
+                identityId: 'identity456',
+                traits: { emails: ['old@email.com', 'new@email.com'] },
             });
-            const result = await IdentityGatewayService.getIdentityWithCachingV2(pixelId, incomingIdentity, lambdaArn);
-            expect(result.summary.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.NEPTUNE_RESOLVED);
-            expect(result.summary.staleTraits).toContain('emails');
-            expect(result.summary.didCallNeptune).toBe(true);
-            expect(result.summary.didWriteCache).toBe(false);
+            const result = await IdentityGatewayService.resolveIdentityWithCaching(pixelId, incomingIdentity);
+            expect(result.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.NEPTUNE_RESOLVED);
+            expect(result.stalenessResult?.staleTraits).toContain('emails');
+            expect(result.didCallNeptune).toBe(true);
+            expect(result.didWriteCache).toBe(false);
         });
     });
     describe('CACHE_MISS — Calls Neptune AND writes to cache', () => {
@@ -358,18 +241,13 @@ describe('Identity Cache Three-Tier Routing', () => {
                 traits: { emails: ['test@email.com'] },
             };
             mockedDynamoDbClient.safeGet.mockResolvedValueOnce(null);
-            mockInvokeFunction.mockResolvedValueOnce({
-                statusCode: 200,
-                body: JSON.stringify({
-                    identity: {
-                        identityId: 'identity456',
-                        traits: { emails: ['test@email.com'] },
-                    },
-                }),
+            mockGetIdentity.mockResolvedValueOnce({
+                identityId: 'identity456',
+                traits: { emails: ['test@email.com'] },
             });
-            const result = await IdentityGatewayService.getIdentityWithCachingV2(pixelId, incomingIdentity, lambdaArn);
+            const result = await IdentityGatewayService.resolveIdentityWithCaching(pixelId, incomingIdentity);
             expect(result.identity).toBeDefined();
-            expect(mockInvokeFunction).toHaveBeenCalled();
+            expect(mockGetIdentity).toHaveBeenCalled();
             expect(mockedDynamoDbClient.safeBatchWrite).not.toHaveBeenCalled();
         });
         it('should return NEPTUNE_WRITE_BACK outcome for cache miss', async () => {
@@ -378,19 +256,14 @@ describe('Identity Cache Three-Tier Routing', () => {
                 traits: { emails: ['test@email.com'] },
             };
             mockedDynamoDbClient.safeGet.mockResolvedValueOnce(null);
-            mockInvokeFunction.mockResolvedValueOnce({
-                statusCode: 200,
-                body: JSON.stringify({
-                    identity: {
-                        identityId: 'identity456',
-                        traits: { emails: ['test@email.com'] },
-                    },
-                }),
+            mockGetIdentity.mockResolvedValueOnce({
+                identityId: 'identity456',
+                traits: { emails: ['test@email.com'] },
             });
-            const result = await IdentityGatewayService.getIdentityWithCachingV2(pixelId, incomingIdentity, lambdaArn);
-            expect(result.summary.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.NEPTUNE_RESOLVED);
-            expect(result.summary.didCallNeptune).toBe(true);
-            expect(result.summary.didWriteCache).toBe(false);
+            const result = await IdentityGatewayService.resolveIdentityWithCaching(pixelId, incomingIdentity);
+            expect(result.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.NEPTUNE_RESOLVED);
+            expect(result.didCallNeptune).toBe(true);
+            expect(result.didWriteCache).toBe(false);
         });
     });
     describe('EMAIL_POINTER_DISCOVERY — Calls Neptune with discovered identityId', () => {
@@ -406,35 +279,28 @@ describe('Identity Cache Three-Tier Routing', () => {
                 updatedAt: new Date().toISOString(),
             };
             mockedDynamoDbClient.safeGet.mockResolvedValueOnce(pointerRecord);
-            mockInvokeFunction.mockResolvedValueOnce({
-                statusCode: 200,
-                body: JSON.stringify({
-                    identity: {
-                        identityId: 'discovered-id',
-                        traits: { emails: ['test@email.com', 'other@email.com'] },
-                    },
-                }),
+            mockGetIdentity.mockResolvedValueOnce({
+                identityId: 'discovered-id',
+                traits: { emails: ['test@email.com', 'other@email.com'] },
             });
-            const result = await IdentityGatewayService.getIdentityWithCachingV2(pixelId, incomingIdentity, lambdaArn);
+            const result = await IdentityGatewayService.resolveIdentityWithCaching(pixelId, incomingIdentity);
             expect(result.identity?.identityId).toBe('discovered-id');
-            expect(mockInvokeFunction).toHaveBeenCalledWith(lambdaArn, expect.objectContaining({
-                context: {
-                    identity: expect.objectContaining({
-                        traits: { emails: ['test@email.com'] },
-                    }),
-                },
+            expect(mockGetIdentity).toHaveBeenCalledWith(pixelId, expect.objectContaining({
+                identity: expect.objectContaining({
+                    identityId: 'discovered-id',
+                    traits: expect.objectContaining({ emails: ['test@email.com'] }),
+                }),
             }));
         });
     });
 });
 describe('Identity Cache stripAddressTimestamps', () => {
     const pixelId = 'pixel123';
-    const lambdaArn = 'arn:aws:lambda:us-east-1:123456789:function:identity-private';
     beforeEach(() => {
         jest.clearAllMocks();
         mockedDynamoDbClient.safeGet.mockReset();
         mockedDynamoDbClient.safeBatchWrite.mockReset();
-        mockInvokeFunction.mockReset();
+        mockGetIdentity.mockReset();
         IdentityGatewayService.lambdaInvokeClient = undefined;
     });
     it('should strip cra and upa from addresses during comparison', async () => {
@@ -473,9 +339,9 @@ describe('Identity Cache stripAddressTimestamps', () => {
             updatedAt: new Date().toISOString(),
         };
         mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-        const result = await IdentityGatewayService.getIdentityWithCachingV2(pixelId, incomingIdentity, lambdaArn);
+        const result = await IdentityGatewayService.resolveIdentityWithCaching(pixelId, incomingIdentity);
         expect(result.identity).toBeDefined();
-        expect(mockInvokeFunction).not.toHaveBeenCalled();
+        expect(mockGetIdentity).not.toHaveBeenCalled();
     });
     it('should NOT mutate the original object when stripping timestamps', async () => {
         const originalAddress = {
@@ -512,7 +378,7 @@ describe('Identity Cache stripAddressTimestamps', () => {
             updatedAt: new Date().toISOString(),
         };
         mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-        await IdentityGatewayService.getIdentityWithCachingV2(pixelId, incomingIdentity, lambdaArn);
+        await IdentityGatewayService.resolveIdentityWithCaching(pixelId, incomingIdentity);
         expect(incomingIdentity.traits?.addresses?.[0]).toHaveProperty('cra');
         expect(incomingIdentity.traits?.addresses?.[0]).toHaveProperty('upa');
         expect(cachedResponse.response.traits?.addresses?.[0]).toHaveProperty('cra');
@@ -538,9 +404,9 @@ describe('Identity Cache stripAddressTimestamps', () => {
             updatedAt: new Date().toISOString(),
         };
         mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-        const result = await IdentityGatewayService.getIdentityWithCachingV2(pixelId, incomingIdentity, lambdaArn);
+        const result = await IdentityGatewayService.resolveIdentityWithCaching(pixelId, incomingIdentity);
         expect(result.identity).toBeDefined();
-        expect(mockInvokeFunction).not.toHaveBeenCalled();
+        expect(mockGetIdentity).not.toHaveBeenCalled();
     });
     it('should handle identity with empty addresses array', async () => {
         const incomingIdentity = {
@@ -564,9 +430,9 @@ describe('Identity Cache stripAddressTimestamps', () => {
             updatedAt: new Date().toISOString(),
         };
         mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-        const result = await IdentityGatewayService.getIdentityWithCachingV2(pixelId, incomingIdentity, lambdaArn);
+        const result = await IdentityGatewayService.resolveIdentityWithCaching(pixelId, incomingIdentity);
         expect(result.identity).toBeDefined();
-        expect(mockInvokeFunction).not.toHaveBeenCalled();
+        expect(mockGetIdentity).not.toHaveBeenCalled();
     });
     it('should handle addresses without cra/upa (no-op)', async () => {
         const incomingIdentity = {
@@ -590,19 +456,18 @@ describe('Identity Cache stripAddressTimestamps', () => {
             updatedAt: new Date().toISOString(),
         };
         mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-        const result = await IdentityGatewayService.getIdentityWithCachingV2(pixelId, incomingIdentity, lambdaArn);
+        const result = await IdentityGatewayService.resolveIdentityWithCaching(pixelId, incomingIdentity);
         expect(result.identity).toBeDefined();
-        expect(mockInvokeFunction).not.toHaveBeenCalled();
+        expect(mockGetIdentity).not.toHaveBeenCalled();
     });
 });
 describe('Identity Cache fastDeepEqual with Timestamp Stripping', () => {
     const pixelId = 'pixel123';
-    const lambdaArn = 'arn:aws:lambda:us-east-1:123456789:function:identity-private';
     beforeEach(() => {
         jest.clearAllMocks();
         mockedDynamoDbClient.safeGet.mockReset();
         mockedDynamoDbClient.safeBatchWrite.mockReset();
-        mockInvokeFunction.mockReset();
+        mockGetIdentity.mockReset();
         IdentityGatewayService.lambdaInvokeClient = undefined;
     });
     it('should treat cached and merged as equal when they differ ONLY in cra/upa', async () => {
@@ -645,9 +510,9 @@ describe('Identity Cache fastDeepEqual with Timestamp Stripping', () => {
             updatedAt: new Date().toISOString(),
         };
         mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-        const result = await IdentityGatewayService.getIdentityWithCachingV2(pixelId, incomingIdentity, lambdaArn);
+        const result = await IdentityGatewayService.resolveIdentityWithCaching(pixelId, incomingIdentity);
         expect(result.identity).toBeDefined();
-        expect(mockInvokeFunction).not.toHaveBeenCalled();
+        expect(mockGetIdentity).not.toHaveBeenCalled();
         expect(mockedDynamoDbClient.safeBatchWrite).not.toHaveBeenCalled();
     });
     it('should treat cached and merged as NOT equal when address content differs (plus cra/upa)', async () => {
@@ -688,18 +553,17 @@ describe('Identity Cache fastDeepEqual with Timestamp Stripping', () => {
             updatedAt: new Date().toISOString(),
         };
         mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-        const result = await IdentityGatewayService.getIdentityWithCachingV2(pixelId, incomingIdentity, lambdaArn);
+        const result = await IdentityGatewayService.resolveIdentityWithCaching(pixelId, incomingIdentity);
         expect(result.identity).toBeDefined();
     });
 });
 describe('Identity Cache Logging Levels', () => {
     const pixelId = 'pixel123';
-    const lambdaArn = 'arn:aws:lambda:us-east-1:123456789:function:identity-private';
     beforeEach(() => {
         jest.clearAllMocks();
         mockedDynamoDbClient.safeGet.mockReset();
         mockedDynamoDbClient.safeBatchWrite.mockReset();
-        mockInvokeFunction.mockReset();
+        mockGetIdentity.mockReset();
         IdentityGatewayService.lambdaInvokeClient = undefined;
     });
     it('should return fresh cache hit without calling Neptune or writing cache', async () => {
@@ -722,45 +586,11 @@ describe('Identity Cache Logging Levels', () => {
             updatedAt: new Date().toISOString(),
         };
         mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-        const result = await IdentityGatewayService.getIdentityWithCachingV2(pixelId, incomingIdentity, lambdaArn);
-        expect(result.summary.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.FRESH_CACHE_HIT);
-        expect(mockInvokeFunction).not.toHaveBeenCalled();
+        const result = await IdentityGatewayService.resolveIdentityWithCaching(pixelId, incomingIdentity);
+        expect(result.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.FRESH_CACHE_HIT);
+        expect(mockGetIdentity).not.toHaveBeenCalled();
         expect(mockedDynamoDbClient.safeBatchWrite).not.toHaveBeenCalled();
     });
-    it('should return ADDRESS_UPDATE_ASYNC outcome for address update path', async () => {
-        IdentityGatewayService.configure({
-            awsRegion: 'us-east-1',
-            awsAccountId: '123456789',
-            asyncUpdateQueueName: 'test-queue',
-        });
-        mockBuildAndSendMessage.mockResolvedValueOnce({ MessageId: 'test-msg-id' });
-        const incomingIdentity = {
-            identityId: 'identity456',
-            traits: {
-                emails: ['test@email.com'],
-                addresses: [{ city: 'New City', s: ADDRESS_INFO_SOURCE.INPUT }],
-            },
-        };
-        const cachedResponse = {
-            pk: `identity#${pixelId}#identity456`,
-            pixelId,
-            identityId: 'identity456',
-            response: {
-                identityId: 'identity456',
-                traits: {
-                    emails: ['test@email.com'],
-                    addresses: [],
-                },
-            },
-            updatedAt: new Date().toISOString(),
-        };
-        mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-        const result = await IdentityGatewayService.getIdentityWithCachingV2(pixelId, incomingIdentity, lambdaArn);
-        expect(result.summary.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.ADDRESS_UPDATE_ASYNC);
-        expect(result.summary.didSkipNeptune).toBe(true);
-        expect(result.summary.didWriteCache).toBe(false);
-        expect(result.summary.didEnqueueAsync).toBe(true);
-    });
     it('should return NEPTUNE_WRITE_BACK outcome with traitChanges for stale traits', async () => {
         const incomingIdentity = {
             identityId: 'identity456',
@@ -781,107 +611,16 @@ describe('Identity Cache Logging Levels', () => {
             updatedAt: new Date().toISOString(),
         };
         mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-        mockInvokeFunction.mockResolvedValueOnce({
-            statusCode: 200,
-            body: JSON.stringify({
-                identity: {
-                    identityId: 'identity456',
-                    traits: { emails: ['old@email.com', 'new@email.com'] },
-                },
-            }),
-        });
-        const result = await IdentityGatewayService.getIdentityWithCachingV2(pixelId, incomingIdentity, lambdaArn);
-        expect(result.summary.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.NEPTUNE_RESOLVED);
-        expect(result.summary.staleTraits).toContain('emails');
-        expect(result.summary.traitChanges).toBeDefined();
-        expect(result.summary.didCallNeptune).toBe(true);
-        expect(result.summary.didWriteCache).toBe(false);
-    });
-});
-describe('getIdentityFromCache staleness tier results', () => {
-    const pixelId = 'pixel123';
-    beforeEach(() => {
-        jest.clearAllMocks();
-        mockedDynamoDbClient.safeGet.mockReset();
-    });
-    it('should return staleTier NONE when cached and incoming are deep equal', async () => {
-        const incomingIdentity = {
-            identityId: 'identity456',
-            traits: {
-                emails: ['test@email.com'],
-            },
-        };
-        const cachedResponse = {
-            pk: `identity#${pixelId}#identity456`,
-            pixelId,
-            identityId: 'identity456',
-            response: {
-                identityId: 'identity456',
-                traits: {
-                    emails: ['test@email.com'],
-                },
-            },
-            updatedAt: new Date().toISOString(),
-        };
-        mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-        const result = await IdentityCacheDynamoDbDbService.getIdentityFromCache(pixelId, incomingIdentity);
-        expect(result.staleTier).toBe(IDENTITY_CACHE_STALENESS_TIER.NONE);
-        expect(result.isCacheStale).toBe(false);
-        expect(result.skipNeptune).toBeUndefined();
-    });
-    it('should return staleTier ADDRESS_UPDATE and skipNeptune=true for new non-IP address', async () => {
-        const incomingIdentity = {
-            identityId: 'identity456',
-            traits: {
-                emails: ['test@email.com'],
-                addresses: [{ city: 'New City', s: ADDRESS_INFO_SOURCE.INPUT }],
-            },
-        };
-        const cachedResponse = {
-            pk: `identity#${pixelId}#identity456`,
-            pixelId,
-            identityId: 'identity456',
-            response: {
-                identityId: 'identity456',
-                traits: {
-                    emails: ['test@email.com'],
-                    addresses: [],
-                },
-            },
-            updatedAt: new Date().toISOString(),
-        };
-        mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-        const result = await IdentityCacheDynamoDbDbService.getIdentityFromCache(pixelId, incomingIdentity);
-        expect(result.staleTier).toBe(IDENTITY_CACHE_STALENESS_TIER.ADDRESS_UPDATE);
-        expect(result.isCacheStale).toBe(true);
-        expect(result.skipNeptune).toBe(true);
-        expect(result.writeReason).toBe(CACHE_WRITE_REASON.ADDRESS_UPDATE);
-    });
-    it('should return staleTier IDENTITY_STALE and skipNeptune=false for new email', async () => {
-        const incomingIdentity = {
+        mockGetIdentity.mockResolvedValueOnce({
             identityId: 'identity456',
-            traits: {
-                emails: ['old@email.com', 'new@email.com'],
-            },
-        };
-        const cachedResponse = {
-            pk: `identity#${pixelId}#identity456`,
-            pixelId,
-            identityId: 'identity456',
-            response: {
-                identityId: 'identity456',
-                traits: {
-                    emails: ['old@email.com'],
-                },
-            },
-            updatedAt: new Date().toISOString(),
-        };
-        mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-        const result = await IdentityCacheDynamoDbDbService.getIdentityFromCache(pixelId, incomingIdentity);
-        expect(result.staleTier).toBe(IDENTITY_CACHE_STALENESS_TIER.IDENTITY_STALE);
-        expect(result.isCacheStale).toBe(true);
-        expect(result.skipNeptune).toBe(false);
-        expect(result.writeReason).toBe(CACHE_WRITE_REASON.STALE_TRAITS);
+            traits: { emails: ['old@email.com', 'new@email.com'] },
+        });
+        const result = await IdentityGatewayService.resolveIdentityWithCaching(pixelId, incomingIdentity);
+        expect(result.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.NEPTUNE_RESOLVED);
+        expect(result.stalenessResult?.staleTraits).toContain('emails');
+        expect(result.traitChanges).toBeDefined();
+        expect(result.didCallNeptune).toBe(true);
+        expect(result.didWriteCache).toBe(false);
     });
 });
 //# sourceMappingURL=identity-cache-tier-routing.spec.js.map