@adtrackify/at-service-common 4.0.13 → 4.0.14

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

@@ -1,9 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const at_tracking_event_types_1 = require("@adtrackify/at-tracking-event-types");
-const at_shared_utils_1 = require("@adtrackify/at-shared-utils");
-const identity_cache_dynamodb_service_1 = require("../../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', () => ({
@@ -17,7 +15,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);
@@ -35,15 +33,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,
+    })),
+}));
 const identity_gateway_service_js_1 = require("../../services/db/identity-cache-dynamodb-service/identity-gateway-service.js");
 const types_js_1 = require("../../services/db/identity-cache-dynamodb-service/types.js");
-const identity_cache_dynamodb_db_service_js_1 = require("../../services/db/identity-cache-dynamodb-service/identity-cache-dynamodb-db-service.js");
 const index_js_1 = require("../../clients/index.js");
 const mockedDynamoDbClient = index_js_1.DynamoDbClient;
 const _mockedSQSClient = index_js_1.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();
@@ -53,13 +55,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();
-        identity_gateway_service_js_1.IdentityGatewayService.lambdaInvokeClient = undefined;
+        identity_gateway_service_js_1.IdentityGatewayService.identityClient = undefined;
         identity_gateway_service_js_1.IdentityGatewayService.sqsClient = undefined;
         identity_gateway_service_js_1.IdentityGatewayService.sqsQueueUrl = undefined;
+        identity_gateway_service_js_1.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 () => {
@@ -84,10 +87,10 @@ describe('Identity Cache Three-Tier Routing', () => {
                 updatedAt: new Date().toISOString(),
             };
             mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-            const result = await identity_gateway_service_js_1.IdentityGatewayService.getIdentityWithCachingV2(pixelId, incomingIdentity, lambdaArn);
+            const result = await identity_gateway_service_js_1.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 () => {
@@ -112,9 +115,9 @@ describe('Identity Cache Three-Tier Routing', () => {
                 updatedAt: new Date().toISOString(),
             };
             mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-            const result = await identity_gateway_service_js_1.IdentityGatewayService.getIdentityWithCachingV2(pixelId, incomingIdentity, lambdaArn);
+            const result = await identity_gateway_service_js_1.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 () => {
@@ -139,117 +142,12 @@ describe('Identity Cache Three-Tier Routing', () => {
                 updatedAt: new Date().toISOString(),
             };
             mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-            const result = await identity_gateway_service_js_1.IdentityGatewayService.getIdentityWithCachingV2(pixelId, incomingIdentity, lambdaArn);
+            const result = await identity_gateway_service_js_1.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 () => {
-            identity_gateway_service_js_1.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: at_tracking_event_types_1.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 identity_gateway_service_js_1.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 () => {
-            identity_gateway_service_js_1.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 identity_gateway_service_js_1.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 () => {
-            identity_gateway_service_js_1.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: at_tracking_event_types_1.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 identity_gateway_service_js_1.IdentityGatewayService.getIdentityWithCachingV2(pixelId, incomingIdentity, lambdaArn);
-            expect(result.summary.outcome).toBe(types_js_1.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 = {
@@ -271,18 +169,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 identity_gateway_service_js_1.IdentityGatewayService.getIdentityWithCachingV2(pixelId, incomingIdentity, lambdaArn);
+            const result = await identity_gateway_service_js_1.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 () => {
@@ -305,18 +198,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 identity_gateway_service_js_1.IdentityGatewayService.getIdentityWithCachingV2(pixelId, incomingIdentity, lambdaArn);
+            const result = await identity_gateway_service_js_1.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 () => {
@@ -337,20 +225,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 identity_gateway_service_js_1.IdentityGatewayService.getIdentityWithCachingV2(pixelId, incomingIdentity, lambdaArn);
-            expect(result.summary.outcome).toBe(types_js_1.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 identity_gateway_service_js_1.IdentityGatewayService.resolveIdentityWithCaching(pixelId, incomingIdentity);
+            expect(result.outcome).toBe(types_js_1.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', () => {
@@ -360,18 +243,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 identity_gateway_service_js_1.IdentityGatewayService.getIdentityWithCachingV2(pixelId, incomingIdentity, lambdaArn);
+            const result = await identity_gateway_service_js_1.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 () => {
@@ -380,19 +258,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 identity_gateway_service_js_1.IdentityGatewayService.getIdentityWithCachingV2(pixelId, incomingIdentity, lambdaArn);
-            expect(result.summary.outcome).toBe(types_js_1.IDENTITY_CACHE_WITH_CACHING_OUTCOME.NEPTUNE_RESOLVED);
-            expect(result.summary.didCallNeptune).toBe(true);
-            expect(result.summary.didWriteCache).toBe(false);
+            const result = await identity_gateway_service_js_1.IdentityGatewayService.resolveIdentityWithCaching(pixelId, incomingIdentity);
+            expect(result.outcome).toBe(types_js_1.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', () => {
@@ -408,35 +281,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 identity_gateway_service_js_1.IdentityGatewayService.getIdentityWithCachingV2(pixelId, incomingIdentity, lambdaArn);
+            const result = await identity_gateway_service_js_1.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();
         identity_gateway_service_js_1.IdentityGatewayService.lambdaInvokeClient = undefined;
     });
     it('should strip cra and upa from addresses during comparison', async () => {
@@ -475,9 +341,9 @@ describe('Identity Cache stripAddressTimestamps', () => {
             updatedAt: new Date().toISOString(),
         };
         mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-        const result = await identity_gateway_service_js_1.IdentityGatewayService.getIdentityWithCachingV2(pixelId, incomingIdentity, lambdaArn);
+        const result = await identity_gateway_service_js_1.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 = {
@@ -514,7 +380,7 @@ describe('Identity Cache stripAddressTimestamps', () => {
             updatedAt: new Date().toISOString(),
         };
         mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-        await identity_gateway_service_js_1.IdentityGatewayService.getIdentityWithCachingV2(pixelId, incomingIdentity, lambdaArn);
+        await identity_gateway_service_js_1.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');
@@ -540,9 +406,9 @@ describe('Identity Cache stripAddressTimestamps', () => {
             updatedAt: new Date().toISOString(),
         };
         mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-        const result = await identity_gateway_service_js_1.IdentityGatewayService.getIdentityWithCachingV2(pixelId, incomingIdentity, lambdaArn);
+        const result = await identity_gateway_service_js_1.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 = {
@@ -566,9 +432,9 @@ describe('Identity Cache stripAddressTimestamps', () => {
             updatedAt: new Date().toISOString(),
         };
         mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-        const result = await identity_gateway_service_js_1.IdentityGatewayService.getIdentityWithCachingV2(pixelId, incomingIdentity, lambdaArn);
+        const result = await identity_gateway_service_js_1.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 = {
@@ -592,19 +458,18 @@ describe('Identity Cache stripAddressTimestamps', () => {
             updatedAt: new Date().toISOString(),
         };
         mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-        const result = await identity_gateway_service_js_1.IdentityGatewayService.getIdentityWithCachingV2(pixelId, incomingIdentity, lambdaArn);
+        const result = await identity_gateway_service_js_1.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();
         identity_gateway_service_js_1.IdentityGatewayService.lambdaInvokeClient = undefined;
     });
     it('should treat cached and merged as equal when they differ ONLY in cra/upa', async () => {
@@ -647,9 +512,9 @@ describe('Identity Cache fastDeepEqual with Timestamp Stripping', () => {
             updatedAt: new Date().toISOString(),
         };
         mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-        const result = await identity_gateway_service_js_1.IdentityGatewayService.getIdentityWithCachingV2(pixelId, incomingIdentity, lambdaArn);
+        const result = await identity_gateway_service_js_1.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 () => {
@@ -690,18 +555,17 @@ describe('Identity Cache fastDeepEqual with Timestamp Stripping', () => {
             updatedAt: new Date().toISOString(),
         };
         mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-        const result = await identity_gateway_service_js_1.IdentityGatewayService.getIdentityWithCachingV2(pixelId, incomingIdentity, lambdaArn);
+        const result = await identity_gateway_service_js_1.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();
         identity_gateway_service_js_1.IdentityGatewayService.lambdaInvokeClient = undefined;
     });
     it('should return fresh cache hit without calling Neptune or writing cache', async () => {
@@ -724,45 +588,11 @@ describe('Identity Cache Logging Levels', () => {
             updatedAt: new Date().toISOString(),
         };
         mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-        const result = await identity_gateway_service_js_1.IdentityGatewayService.getIdentityWithCachingV2(pixelId, incomingIdentity, lambdaArn);
-        expect(result.summary.outcome).toBe(types_js_1.IDENTITY_CACHE_WITH_CACHING_OUTCOME.FRESH_CACHE_HIT);
-        expect(mockInvokeFunction).not.toHaveBeenCalled();
+        const result = await identity_gateway_service_js_1.IdentityGatewayService.resolveIdentityWithCaching(pixelId, incomingIdentity);
+        expect(result.outcome).toBe(types_js_1.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 () => {
-        identity_gateway_service_js_1.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: at_tracking_event_types_1.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 identity_gateway_service_js_1.IdentityGatewayService.getIdentityWithCachingV2(pixelId, incomingIdentity, lambdaArn);
-        expect(result.summary.outcome).toBe(types_js_1.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',
@@ -783,107 +613,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 identity_gateway_service_js_1.IdentityGatewayService.getIdentityWithCachingV2(pixelId, incomingIdentity, lambdaArn);
-        expect(result.summary.outcome).toBe(types_js_1.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 identity_cache_dynamodb_db_service_js_1.IdentityCacheDynamoDbDbService.getIdentityFromCache(pixelId, incomingIdentity);
-        expect(result.staleTier).toBe(at_shared_utils_1.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: at_tracking_event_types_1.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 identity_cache_dynamodb_db_service_js_1.IdentityCacheDynamoDbDbService.getIdentityFromCache(pixelId, incomingIdentity);
-        expect(result.staleTier).toBe(at_shared_utils_1.IDENTITY_CACHE_STALENESS_TIER.ADDRESS_UPDATE);
-        expect(result.isCacheStale).toBe(true);
-        expect(result.skipNeptune).toBe(true);
-        expect(result.writeReason).toBe(identity_cache_dynamodb_service_1.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 identity_cache_dynamodb_db_service_js_1.IdentityCacheDynamoDbDbService.getIdentityFromCache(pixelId, incomingIdentity);
-        expect(result.staleTier).toBe(at_shared_utils_1.IDENTITY_CACHE_STALENESS_TIER.IDENTITY_STALE);
-        expect(result.isCacheStale).toBe(true);
-        expect(result.skipNeptune).toBe(false);
-        expect(result.writeReason).toBe(identity_cache_dynamodb_service_1.CACHE_WRITE_REASON.STALE_TRAITS);
+            traits: { emails: ['old@email.com', 'new@email.com'] },
+        });
+        const result = await identity_gateway_service_js_1.IdentityGatewayService.resolveIdentityWithCaching(pixelId, incomingIdentity);
+        expect(result.outcome).toBe(types_js_1.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