@adtrackify/at-service-common 4.0.25 → 4.0.28

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

@@ -1,70 +1,70 @@
-import { IdentityGatewayService, mockSQSClientConstructor, resetAllMocks, } from './identity-gateway-test-setup.js';
-describe('IdentityGatewayService constructor()', () => {
-    beforeEach(() => {
-        resetAllMocks();
-    });
-    it('should configure with direct queue URL', () => {
-        const options = {
-            asyncUpdateQueueUrl: 'https://sqs.us-east-1.amazonaws.com/123456789/test-queue',
-        };
-        const service = new IdentityGatewayService(options);
-        expect(service.sqsClient).toBeDefined();
-    });
-    it('should configure with region/accountId/queueName', () => {
-        const options = {
-            awsRegion: 'us-east-1',
-            awsAccountId: '123456789',
-            asyncUpdateQueueName: 'identity-async-queue',
-        };
-        const service = new IdentityGatewayService(options);
-        expect(mockSQSClientConstructor).toHaveBeenCalledWith('us-east-1', '123456789', 'identity-async-queue');
-        expect(service.sqsClient).toBeDefined();
-    });
-    it('should fallback to environment variable for queue name', () => {
-        const originalEnv = process.env.IDENTIFY_ASYNC_UPDATE_QUEUE_NAME;
-        process.env.IDENTIFY_ASYNC_UPDATE_QUEUE_NAME = 'env-queue-name';
-        try {
-            const options = {
-                awsRegion: 'us-west-2',
-                awsAccountId: '987654321',
-            };
-            new IdentityGatewayService(options);
-            expect(mockSQSClientConstructor).toHaveBeenCalledWith('us-west-2', '987654321', 'env-queue-name');
-        }
-        finally {
-            if (originalEnv !== undefined) {
-                process.env.IDENTIFY_ASYNC_UPDATE_QUEUE_NAME = originalEnv;
-            }
-            else {
-                delete process.env.IDENTIFY_ASYNC_UPDATE_QUEUE_NAME;
-            }
-        }
-    });
-    it('should not configure SQS when region/accountId provided but no queue name', () => {
-        const originalEnv = process.env.IDENTIFY_ASYNC_UPDATE_QUEUE_NAME;
-        delete process.env.IDENTIFY_ASYNC_UPDATE_QUEUE_NAME;
-        try {
-            const options = {
-                awsRegion: 'us-east-1',
-                awsAccountId: '123456789',
-            };
-            const service = new IdentityGatewayService(options);
-            expect(mockSQSClientConstructor).not.toHaveBeenCalled();
-            expect(service.sqsClient).toBeUndefined();
-        }
-        finally {
-            if (originalEnv !== undefined) {
-                process.env.IDENTIFY_ASYNC_UPDATE_QUEUE_NAME = originalEnv;
-            }
-        }
-    });
-    it('should not configure SQS when only region provided', () => {
-        const options = {
-            awsRegion: 'us-east-1',
-        };
-        const service = new IdentityGatewayService(options);
-        expect(mockSQSClientConstructor).not.toHaveBeenCalled();
-        expect(service.sqsClient).toBeUndefined();
-    });
-});
+import { IdentityGatewayService, mockSQSClientConstructor, resetAllMocks, } from './identity-gateway-test-setup.js';
+describe('IdentityGatewayService constructor()', () => {
+    beforeEach(() => {
+        resetAllMocks();
+    });
+    it('should configure with direct queue URL', () => {
+        const options = {
+            asyncUpdateQueueUrl: 'https://sqs.us-east-1.amazonaws.com/123456789/test-queue',
+        };
+        const service = new IdentityGatewayService(options);
+        expect(service.sqsClient).toBeDefined();
+    });
+    it('should configure with region/accountId/queueName', () => {
+        const options = {
+            awsRegion: 'us-east-1',
+            awsAccountId: '123456789',
+            asyncUpdateQueueName: 'identity-async-queue',
+        };
+        const service = new IdentityGatewayService(options);
+        expect(mockSQSClientConstructor).toHaveBeenCalledWith('us-east-1', '123456789', 'identity-async-queue');
+        expect(service.sqsClient).toBeDefined();
+    });
+    it('should fallback to environment variable for queue name', () => {
+        const originalEnv = process.env.IDENTIFY_ASYNC_UPDATE_QUEUE_NAME;
+        process.env.IDENTIFY_ASYNC_UPDATE_QUEUE_NAME = 'env-queue-name';
+        try {
+            const options = {
+                awsRegion: 'us-west-2',
+                awsAccountId: '987654321',
+            };
+            new IdentityGatewayService(options);
+            expect(mockSQSClientConstructor).toHaveBeenCalledWith('us-west-2', '987654321', 'env-queue-name');
+        }
+        finally {
+            if (originalEnv !== undefined) {
+                process.env.IDENTIFY_ASYNC_UPDATE_QUEUE_NAME = originalEnv;
+            }
+            else {
+                delete process.env.IDENTIFY_ASYNC_UPDATE_QUEUE_NAME;
+            }
+        }
+    });
+    it('should not configure SQS when region/accountId provided but no queue name', () => {
+        const originalEnv = process.env.IDENTIFY_ASYNC_UPDATE_QUEUE_NAME;
+        delete process.env.IDENTIFY_ASYNC_UPDATE_QUEUE_NAME;
+        try {
+            const options = {
+                awsRegion: 'us-east-1',
+                awsAccountId: '123456789',
+            };
+            const service = new IdentityGatewayService(options);
+            expect(mockSQSClientConstructor).not.toHaveBeenCalled();
+            expect(service.sqsClient).toBeUndefined();
+        }
+        finally {
+            if (originalEnv !== undefined) {
+                process.env.IDENTIFY_ASYNC_UPDATE_QUEUE_NAME = originalEnv;
+            }
+        }
+    });
+    it('should not configure SQS when only region provided', () => {
+        const options = {
+            awsRegion: 'us-east-1',
+        };
+        const service = new IdentityGatewayService(options);
+        expect(mockSQSClientConstructor).not.toHaveBeenCalled();
+        expect(service.sqsClient).toBeUndefined();
+    });
+});
 //# sourceMappingURL=identity-gateway-constructor.spec.js.map

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

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

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

@@ -1,87 +1,87 @@
-import { createService, createServiceWithSqs, createCachedIdentity, mockGetIdentity, mockBuildAndSendMessage, mockedDynamoDbClient, mockedLogger, resetAllMocks, TEST_PIXEL_ID, IDENTITY_CACHE_WITH_CACHING_OUTCOME, } from './identity-gateway-test-setup.js';
-describe('IdentityGatewayService edge cases', () => {
-    const pixelId = TEST_PIXEL_ID;
-    beforeEach(() => {
-        resetAllMocks();
-    });
-    describe('invalid input handling', () => {
-        it('should return invalid input when pixelId is undefined', async () => {
-            const service = createService();
-            const result = await service.resolveIdentityWithCaching(undefined, { identityId: 'test' });
-            expect(result.identity).toBeUndefined();
-            expect(result.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.INVALID_INPUT);
-            expect(result.didReadCache).toBe(false);
-            expect(result.didWriteCache).toBe(false);
-        });
-        it('should return invalid input when incomingIdentity is null', async () => {
-            const service = createService();
-            const result = await service.resolveIdentityWithCaching(pixelId, null);
-            expect(result.identity).toBeUndefined();
-            expect(result.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.INVALID_INPUT);
-        });
-        it('should return invalid input when both pixelId and identity are missing', async () => {
-            const service = createService();
-            const result = await service.resolveIdentityWithCaching('', undefined);
-            expect(result.identity).toBeUndefined();
-            expect(result.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.INVALID_INPUT);
-        });
-    });
-    describe('enqueue validation', () => {
-        it('should reject identity with undefined identityId', async () => {
-            const service = createServiceWithSqs();
-            const identity = { traits: { emails: ['test@email.com'] } };
-            const context = { identity };
-            const result = await service.enqueueAsyncIdentityUpdate({
-                pixelId,
-                identity,
-                context,
-                reason: 'anonymous user',
-            });
-            expect(result.success).toBe(false);
-            expect(result.error).toBe('Missing required pixelId or identityId');
-            expect(mockBuildAndSendMessage).not.toHaveBeenCalled();
-            expect(mockedLogger.warn).toHaveBeenCalledWith('IdentityGateway - enqueueAsyncIdentityUpdate: missing required params', expect.objectContaining({
-                pixelId,
-                identityId: undefined,
-            }));
-        });
-    });
-    describe('result fields consistency', () => {
-        it('should include all required fields in result', async () => {
-            const service = createService();
-            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(null);
-            mockGetIdentity.mockResolvedValueOnce({
-                identityId: 'resolved-id',
-                traits: { emails: ['test@email.com'] },
-            });
-            const result = await service.resolveIdentityWithCaching(pixelId, { identityId: 'incoming-id', traits: { emails: ['test@email.com'] } });
-            expect(result).toEqual(expect.objectContaining({
-                outcome: expect.any(String),
-                pixelId,
-                identityId: 'resolved-id',
-                didReadCache: true,
-                didCallNeptune: true,
-                didWriteCache: false,
-                didSkipNeptune: false,
-                didFallbackToIncoming: false,
-                didEnqueueAsync: false,
-            }));
-        });
-        it('should include traitChanges when identity changes via Neptune', async () => {
-            const service = createService();
-            const cachedResponse = createCachedIdentity(pixelId, 'identity456', {
-                emails: ['old@email.com'],
-            });
-            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
-            mockGetIdentity.mockResolvedValueOnce({
-                identityId: 'identity456',
-                traits: { emails: ['old@email.com', 'new@email.com'] },
-            });
-            const result = await service.resolveIdentityWithCaching(pixelId, { identityId: 'identity456', traits: { emails: ['old@email.com', 'new@email.com'] } });
-            if (result.outcome === IDENTITY_CACHE_WITH_CACHING_OUTCOME.NEPTUNE_RESOLVED) {
-                expect(result.traitChanges).toBeDefined();
-            }
-        });
-    });
-});
+import { createService, createServiceWithSqs, createCachedIdentity, mockGetIdentity, mockBuildAndSendMessage, mockedDynamoDbClient, mockedLogger, resetAllMocks, TEST_PIXEL_ID, IDENTITY_CACHE_WITH_CACHING_OUTCOME, } from './identity-gateway-test-setup.js';
+describe('IdentityGatewayService edge cases', () => {
+    const pixelId = TEST_PIXEL_ID;
+    beforeEach(() => {
+        resetAllMocks();
+    });
+    describe('invalid input handling', () => {
+        it('should return invalid input when pixelId is undefined', async () => {
+            const service = createService();
+            const result = await service.resolveIdentityWithCaching(undefined, { identityId: 'test' });
+            expect(result.identity).toBeUndefined();
+            expect(result.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.INVALID_INPUT);
+            expect(result.didReadCache).toBe(false);
+            expect(result.didWriteCache).toBe(false);
+        });
+        it('should return invalid input when incomingIdentity is null', async () => {
+            const service = createService();
+            const result = await service.resolveIdentityWithCaching(pixelId, null);
+            expect(result.identity).toBeUndefined();
+            expect(result.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.INVALID_INPUT);
+        });
+        it('should return invalid input when both pixelId and identity are missing', async () => {
+            const service = createService();
+            const result = await service.resolveIdentityWithCaching('', undefined);
+            expect(result.identity).toBeUndefined();
+            expect(result.outcome).toBe(IDENTITY_CACHE_WITH_CACHING_OUTCOME.INVALID_INPUT);
+        });
+    });
+    describe('enqueue validation', () => {
+        it('should reject identity with undefined identityId', async () => {
+            const service = createServiceWithSqs();
+            const identity = { traits: { emails: ['test@email.com'] } };
+            const context = { identity };
+            const result = await service.enqueueAsyncIdentityUpdate({
+                pixelId,
+                identity,
+                context,
+                reason: 'anonymous user',
+            });
+            expect(result.success).toBe(false);
+            expect(result.error).toBe('Missing required pixelId or identityId');
+            expect(mockBuildAndSendMessage).not.toHaveBeenCalled();
+            expect(mockedLogger.warn).toHaveBeenCalledWith('IdentityGateway - enqueueAsyncIdentityUpdate: missing required params', expect.objectContaining({
+                pixelId,
+                identityId: undefined,
+            }));
+        });
+    });
+    describe('result fields consistency', () => {
+        it('should include all required fields in result', async () => {
+            const service = createService();
+            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(null);
+            mockGetIdentity.mockResolvedValueOnce({
+                identityId: 'resolved-id',
+                traits: { emails: ['test@email.com'] },
+            });
+            const result = await service.resolveIdentityWithCaching(pixelId, { identityId: 'incoming-id', traits: { emails: ['test@email.com'] } });
+            expect(result).toEqual(expect.objectContaining({
+                outcome: expect.any(String),
+                pixelId,
+                identityId: 'resolved-id',
+                didReadCache: true,
+                didCallNeptune: true,
+                didWriteCache: false,
+                didSkipNeptune: false,
+                didFallbackToIncoming: false,
+                didEnqueueAsync: false,
+            }));
+        });
+        it('should include traitChanges when identity changes via Neptune', async () => {
+            const service = createService();
+            const cachedResponse = createCachedIdentity(pixelId, 'identity456', {
+                emails: ['old@email.com'],
+            });
+            mockedDynamoDbClient.safeGet.mockResolvedValueOnce(cachedResponse);
+            mockGetIdentity.mockResolvedValueOnce({
+                identityId: 'identity456',
+                traits: { emails: ['old@email.com', 'new@email.com'] },
+            });
+            const result = await service.resolveIdentityWithCaching(pixelId, { identityId: 'identity456', traits: { emails: ['old@email.com', 'new@email.com'] } });
+            if (result.outcome === IDENTITY_CACHE_WITH_CACHING_OUTCOME.NEPTUNE_RESOLVED) {
+                expect(result.traitChanges).toBeDefined();
+            }
+        });
+    });
+});
 //# sourceMappingURL=identity-gateway-edge-cases.spec.js.map

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

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

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

@@ -1,134 +1,134 @@
-import { createService, createServiceWithSqs, mockBuildAndSendMessage, mockedLogger, resetAllMocks, TEST_PIXEL_ID, TEST_LAMBDA_ARN, } from './identity-gateway-test-setup.js';
-describe('IdentityGatewayService enqueueAsyncIdentityUpdate()', () => {
-    const pixelId = TEST_PIXEL_ID;
-    const testIdentity = {
-        identityId: 'identity456',
-        traits: { emails: ['test@email.com'] },
-    };
-    const testContext = {
-        identity: testIdentity,
-    };
-    beforeEach(() => {
-        resetAllMocks();
-    });
-    it('should return error result when SQS client is not configured', async () => {
-        const service = createService({ identifyPrivateLambdaArn: TEST_LAMBDA_ARN });
-        const result = await service.enqueueAsyncIdentityUpdate({
-            pixelId,
-            identity: testIdentity,
-            context: testContext,
-            reason: 'test reason',
-            eventId: 'event123',
-        });
-        expect(result.success).toBe(false);
-        expect(result.error).toBe('SQS client not configured');
-        expect(result.messageId).toBeUndefined();
-        expect(mockedLogger.warn).toHaveBeenCalledWith('IdentityGateway - enqueueAsyncIdentityUpdate: SQS client not configured', expect.objectContaining({
-            pixelId,
-            identityId: testIdentity.identityId,
-            reason: 'test reason',
-            eventId: 'event123',
-        }));
-    });
-    it('should successfully enqueue message when SQS client is configured', async () => {
-        const service = createServiceWithSqs();
-        mockBuildAndSendMessage.mockResolvedValueOnce({
-            MessageId: 'sqs-message-id-123',
-        });
-        const result = await service.enqueueAsyncIdentityUpdate({
-            pixelId,
-            identity: testIdentity,
-            context: testContext,
-            reason: 'stale cache traits',
-            eventId: 'event456',
-        });
-        expect(result.success).toBe(true);
-        expect(result.messageId).toBe('sqs-message-id-123');
-        expect(result.error).toBeUndefined();
-        expect(mockBuildAndSendMessage).toHaveBeenCalledWith('identify.updateAsync', expect.objectContaining({
-            pixelId,
-            incomingIdentityId: testIdentity.identityId,
-            context: testContext,
-        }));
-        expect(mockedLogger.debug).toHaveBeenCalledWith('IdentityGateway - enqueueAsyncIdentityUpdate: message sent', expect.objectContaining({
-            pixelId,
-            identityId: testIdentity.identityId,
-            reason: 'stale cache traits',
-            eventId: 'event456',
-            sqsMessageId: 'sqs-message-id-123',
-        }));
-    });
-    it('should fail open with logging when SQS send fails', async () => {
-        const service = createServiceWithSqs();
-        mockBuildAndSendMessage.mockRejectedValueOnce(new Error('SQS send failed'));
-        const result = await service.enqueueAsyncIdentityUpdate({
-            pixelId,
-            identity: testIdentity,
-            context: testContext,
-            reason: 'test reason',
-            eventId: 'event789',
-        });
-        expect(result.success).toBe(false);
-        expect(result.error).toBe('SQS send failed');
-        expect(result.messageId).toBeUndefined();
-        expect(mockedLogger.warn).toHaveBeenCalledWith('IdentityGateway - enqueueAsyncIdentityUpdate: failed to enqueue (failing open)', expect.objectContaining({
-            error: expect.any(Error),
-            errorMessage: 'SQS send failed',
-            pixelId,
-            identityId: testIdentity.identityId,
-            reason: 'test reason',
-            eventId: 'event789',
-        }));
-    });
-    it('should build message shape matching IdentifyAsyncUpdateMessage interface', async () => {
-        const service = createServiceWithSqs();
-        mockBuildAndSendMessage.mockResolvedValueOnce({ MessageId: 'test-id' });
-        const identity = {
-            identityId: 'id-xyz',
-            traits: { emails: ['user@example.com'], userIds: ['user-1'] },
-        };
-        const context = { identity };
-        await service.enqueueAsyncIdentityUpdate({
-            pixelId: 'pixel-abc',
-            identity,
-            context,
-            reason: 'test',
-        });
-        const messageArg = mockBuildAndSendMessage.mock.calls[0][1];
-        expect(messageArg).toEqual({
-            pixelId: 'pixel-abc',
-            incomingIdentityId: 'id-xyz',
-            context,
-        });
-    });
-    it('should return error when identity has no identityId', async () => {
-        const service = createServiceWithSqs();
-        const identityWithoutId = {
-            traits: { emails: ['anon@example.com'] },
-        };
-        const context = { identity: identityWithoutId };
-        const result = await service.enqueueAsyncIdentityUpdate({
-            pixelId,
-            identity: identityWithoutId,
-            context,
-            reason: 'anonymous identity',
-        });
-        expect(result.success).toBe(false);
-        expect(result.error).toBe('Missing required pixelId or identityId');
-        expect(mockBuildAndSendMessage).not.toHaveBeenCalled();
-    });
-    it('should handle optional eventId parameter', async () => {
-        const service = createServiceWithSqs();
-        mockBuildAndSendMessage.mockResolvedValueOnce({ MessageId: 'test-id' });
-        await service.enqueueAsyncIdentityUpdate({
-            pixelId,
-            identity: testIdentity,
-            context: testContext,
-            reason: 'test',
-        });
-        expect(mockedLogger.debug).toHaveBeenCalledWith('IdentityGateway - enqueueAsyncIdentityUpdate: message sent', expect.objectContaining({
-            eventId: undefined,
-        }));
-    });
-});
+import { createService, createServiceWithSqs, mockBuildAndSendMessage, mockedLogger, resetAllMocks, TEST_PIXEL_ID, TEST_LAMBDA_ARN, } from './identity-gateway-test-setup.js';
+describe('IdentityGatewayService enqueueAsyncIdentityUpdate()', () => {
+    const pixelId = TEST_PIXEL_ID;
+    const testIdentity = {
+        identityId: 'identity456',
+        traits: { emails: ['test@email.com'] },
+    };
+    const testContext = {
+        identity: testIdentity,
+    };
+    beforeEach(() => {
+        resetAllMocks();
+    });
+    it('should return error result when SQS client is not configured', async () => {
+        const service = createService({ identifyPrivateLambdaArn: TEST_LAMBDA_ARN });
+        const result = await service.enqueueAsyncIdentityUpdate({
+            pixelId,
+            identity: testIdentity,
+            context: testContext,
+            reason: 'test reason',
+            eventId: 'event123',
+        });
+        expect(result.success).toBe(false);
+        expect(result.error).toBe('SQS client not configured');
+        expect(result.messageId).toBeUndefined();
+        expect(mockedLogger.warn).toHaveBeenCalledWith('IdentityGateway - enqueueAsyncIdentityUpdate: SQS client not configured', expect.objectContaining({
+            pixelId,
+            identityId: testIdentity.identityId,
+            reason: 'test reason',
+            eventId: 'event123',
+        }));
+    });
+    it('should successfully enqueue message when SQS client is configured', async () => {
+        const service = createServiceWithSqs();
+        mockBuildAndSendMessage.mockResolvedValueOnce({
+            MessageId: 'sqs-message-id-123',
+        });
+        const result = await service.enqueueAsyncIdentityUpdate({
+            pixelId,
+            identity: testIdentity,
+            context: testContext,
+            reason: 'stale cache traits',
+            eventId: 'event456',
+        });
+        expect(result.success).toBe(true);
+        expect(result.messageId).toBe('sqs-message-id-123');
+        expect(result.error).toBeUndefined();
+        expect(mockBuildAndSendMessage).toHaveBeenCalledWith('identify.updateAsync', expect.objectContaining({
+            pixelId,
+            incomingIdentityId: testIdentity.identityId,
+            context: testContext,
+        }));
+        expect(mockedLogger.debug).toHaveBeenCalledWith('IdentityGateway - enqueueAsyncIdentityUpdate: message sent', expect.objectContaining({
+            pixelId,
+            identityId: testIdentity.identityId,
+            reason: 'stale cache traits',
+            eventId: 'event456',
+            sqsMessageId: 'sqs-message-id-123',
+        }));
+    });
+    it('should fail open with logging when SQS send fails', async () => {
+        const service = createServiceWithSqs();
+        mockBuildAndSendMessage.mockRejectedValueOnce(new Error('SQS send failed'));
+        const result = await service.enqueueAsyncIdentityUpdate({
+            pixelId,
+            identity: testIdentity,
+            context: testContext,
+            reason: 'test reason',
+            eventId: 'event789',
+        });
+        expect(result.success).toBe(false);
+        expect(result.error).toBe('SQS send failed');
+        expect(result.messageId).toBeUndefined();
+        expect(mockedLogger.warn).toHaveBeenCalledWith('IdentityGateway - enqueueAsyncIdentityUpdate: failed to enqueue (failing open)', expect.objectContaining({
+            error: expect.any(Error),
+            errorMessage: 'SQS send failed',
+            pixelId,
+            identityId: testIdentity.identityId,
+            reason: 'test reason',
+            eventId: 'event789',
+        }));
+    });
+    it('should build message shape matching IdentifyAsyncUpdateMessage interface', async () => {
+        const service = createServiceWithSqs();
+        mockBuildAndSendMessage.mockResolvedValueOnce({ MessageId: 'test-id' });
+        const identity = {
+            identityId: 'id-xyz',
+            traits: { emails: ['user@example.com'], userIds: ['user-1'] },
+        };
+        const context = { identity };
+        await service.enqueueAsyncIdentityUpdate({
+            pixelId: 'pixel-abc',
+            identity,
+            context,
+            reason: 'test',
+        });
+        const messageArg = mockBuildAndSendMessage.mock.calls[0][1];
+        expect(messageArg).toEqual({
+            pixelId: 'pixel-abc',
+            incomingIdentityId: 'id-xyz',
+            context,
+        });
+    });
+    it('should return error when identity has no identityId', async () => {
+        const service = createServiceWithSqs();
+        const identityWithoutId = {
+            traits: { emails: ['anon@example.com'] },
+        };
+        const context = { identity: identityWithoutId };
+        const result = await service.enqueueAsyncIdentityUpdate({
+            pixelId,
+            identity: identityWithoutId,
+            context,
+            reason: 'anonymous identity',
+        });
+        expect(result.success).toBe(false);
+        expect(result.error).toBe('Missing required pixelId or identityId');
+        expect(mockBuildAndSendMessage).not.toHaveBeenCalled();
+    });
+    it('should handle optional eventId parameter', async () => {
+        const service = createServiceWithSqs();
+        mockBuildAndSendMessage.mockResolvedValueOnce({ MessageId: 'test-id' });
+        await service.enqueueAsyncIdentityUpdate({
+            pixelId,
+            identity: testIdentity,
+            context: testContext,
+            reason: 'test',
+        });
+        expect(mockedLogger.debug).toHaveBeenCalledWith('IdentityGateway - enqueueAsyncIdentityUpdate: message sent', expect.objectContaining({
+            eventId: undefined,
+        }));
+    });
+});
 //# sourceMappingURL=identity-gateway-enqueue-async.spec.js.map

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

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