@adtrackify/at-service-common 3.17.2 → 3.17.3

package/dist/esm/__tests__/identity-cache/trait-merging-and-staleness.spec.js

@@ -1,587 +1,587 @@
-import { mergeIdentityTraits } from '@adtrackify/at-shared-utils';
-import { isIdentityCacheStale, isClickInfosStale } from '../../helpers/identity-cache-helper';
-describe('Identity Trait Merging Tests', () => {
-    afterEach(() => {
-        jest.resetModules();
-    });
-    describe('mergeIdentityTraits function', () => {
-        it('should merge simple string arrays correctly', () => {
-            const incomingTraits = {
-                emails: ['new@email.com'],
-                userIds: ['user1', 'user2'],
-            };
-            const cachedTraits = {
-                emails: ['existing@email.com'],
-                userIds: ['user2', 'user3'],
-                phones: ['+1234567890'],
-            };
-            const merged = mergeIdentityTraits(incomingTraits, cachedTraits);
-            expect(merged.emails).toEqual(['new@email.com', 'existing@email.com']);
-            expect(merged.userIds).toEqual(['user1', 'user2', 'user3']);
-            expect(merged.phones).toEqual(['+1234567890']);
-        });
-        it('should handle null and undefined values in arrays', () => {
-            const incomingTraits = {
-                emails: ['test@email.com', null, undefined],
-                userIds: ['user1'],
-            };
-            const cachedTraits = {
-                emails: [null, 'cached@email.com', undefined],
-                userIds: null,
-            };
-            const merged = mergeIdentityTraits(incomingTraits, cachedTraits);
-            expect(merged.emails).toContain('test@email.com');
-            expect(merged.emails).toContain('cached@email.com');
-            expect(merged.userIds).toEqual(['user1']);
-        });
-        it('should merge addresses correctly', () => {
-            const incomingTraits = {
-                addresses: [
-                    {
-                        city: 'New York',
-                        country: 'USA',
-                        countryCode: 'US',
-                        province: 'NY',
-                        provinceCode: '10001',
-                    },
-                ],
-            };
-            const cachedTraits = {
-                addresses: [
-                    {
-                        city: 'Los Angeles',
-                        country: 'USA',
-                        countryCode: 'US',
-                        province: 'CA',
-                        provinceCode: '90210',
-                    },
-                ],
-            };
-            const merged = mergeIdentityTraits(incomingTraits, cachedTraits);
-            expect(merged.addresses).toHaveLength(2);
-            expect(merged.addresses).toEqual(expect.arrayContaining([
-                expect.objectContaining({ city: 'New York' }),
-                expect.objectContaining({ city: 'Los Angeles' }),
-            ]));
-        });
-        it('should merge click information correctly', () => {
-            const incomingTraits = {
-                click: {
-                    fbp: 'fb.new.123',
-                    fbpCollectedAt: '2024-01-01T00:00:00.000Z',
-                    gclid: 'new_gclid',
-                },
-            };
-            const cachedTraits = {
-                click: {
-                    fbp: 'fb.old.456',
-                    fbpCollectedAt: '2023-12-01T00:00:00.000Z',
-                    fbclid: 'cached_fbclid',
-                },
-            };
-            const merged = mergeIdentityTraits(incomingTraits, cachedTraits);
-            expect(merged.click?.fbp).toBe('fb.new.123');
-            expect(merged.click?.gclid).toBe('new_gclid');
-            expect(merged.click?.fbpCollectedAt).toBe('2024-01-01T00:00:00.000Z');
-            expect(merged.click?.fbclid).toBeUndefined();
-        });
-        it('should handle empty traits correctly', () => {
-            const incomingTraits = {};
-            const cachedTraits = {
-                emails: ['cached@email.com'],
-                userIds: ['user1'],
-            };
-            const merged = mergeIdentityTraits(incomingTraits, cachedTraits);
-            expect(merged.emails).toEqual(['cached@email.com']);
-            expect(merged.userIds).toEqual(['user1']);
-        });
-        it('should handle undefined traits correctly', () => {
-            const merged1 = mergeIdentityTraits(undefined, { emails: ['test@email.com'] });
-            expect(merged1.emails).toEqual(['test@email.com']);
-            const merged2 = mergeIdentityTraits({ emails: ['test@email.com'] }, undefined);
-            expect(merged2.emails).toEqual(['test@email.com']);
-            const merged3 = mergeIdentityTraits(undefined, undefined);
-            expect(merged3).toEqual({});
-        });
-        it('should preserve version information', () => {
-            const incomingTraits = {
-                version: '3',
-                emails: ['new@email.com'],
-            };
-            const cachedTraits = {
-                version: '2',
-                emails: ['old@email.com'],
-            };
-            const merged = mergeIdentityTraits(incomingTraits, cachedTraits);
-            expect(merged.version).toBe('3');
-            expect(merged.emails).toEqual(['new@email.com', 'old@email.com']);
-        });
-        it('should handle complex nested objects', () => {
-            const incomingTraits = {
-                click: {
-                    googleClientInfos: [{ id: 'new1', clickId: 'click1', sessionId: 'session1' }],
-                },
-            };
-            const cachedTraits = {
-                click: {
-                    googleClientInfos: [{ id: 'cached1', clickId: 'click2', sessionId: 'session2' }],
-                },
-            };
-            const merged = mergeIdentityTraits(incomingTraits, cachedTraits);
-            expect(merged.click?.googleClientInfos).toBeDefined();
-            expect(Array.isArray(merged.click?.googleClientInfos)).toBe(true);
-            expect(merged.click?.googleClientInfos).toEqual([{ id: 'cached1', clickId: 'click2', sessionId: 'session2' }]);
-        });
-    });
-    describe('Integration: Merging + Staleness Checking', () => {
-        it('should not be stale when merged identity matches cached identity', () => {
-            const cachedIdentity = {
-                identityId: 'test-id-123',
-                traits: {
-                    emails: ['cached@email.com', 'shared@email.com'],
-                    userIds: ['user1', 'user2'],
-                    addresses: [
-                        {
-                            city: 'New York',
-                            country: 'USA',
-                            countryCode: 'US',
-                        },
-                    ],
-                    version: '2',
-                },
-            };
-            const incomingIdentity = {
-                identityId: 'test-id-123',
-                traits: {
-                    emails: ['shared@email.com'],
-                    userIds: ['user1'],
-                    version: '2',
-                },
-            };
-            const mergedTraits = mergeIdentityTraits(incomingIdentity.traits, cachedIdentity.traits);
-            const mergedIdentity = { ...incomingIdentity, traits: mergedTraits };
-            const staleTracker = isIdentityCacheStale(cachedIdentity, mergedIdentity);
-            expect(staleTracker.isCacheStale).toBe(false);
-            expect(mergedIdentity.traits?.emails).toEqual(['shared@email.com', 'cached@email.com']);
-        });
-        it('should be stale when merged identity has new traits', () => {
-            const cachedIdentity = {
-                identityId: 'test-id-123',
-                traits: {
-                    emails: ['cached@email.com'],
-                    version: '2',
-                },
-            };
-            const incomingIdentity = {
-                identityId: 'test-id-123',
-                traits: {
-                    emails: ['cached@email.com', 'new@email.com'],
-                    version: '2',
-                },
-            };
-            const mergedTraits = mergeIdentityTraits(incomingIdentity.traits, cachedIdentity.traits);
-            const mergedIdentity = { ...incomingIdentity, traits: mergedTraits };
-            const staleTracker = isIdentityCacheStale(cachedIdentity, mergedIdentity);
-            expect(staleTracker.isCacheStale).toBe(true);
-            expect(staleTracker.isEmailsStale).toBe(true);
-        });
-    });
-});
-describe('Identity Cache Staleness Tests', () => {
-    afterEach(() => {
-        jest.resetModules();
-    });
-    describe('isIdentityCacheStale function', () => {
-        it('should detect identity ID changes', () => {
-            const cachedIdentity = {
-                identityId: 'old-id',
-                traits: { emails: ['test@email.com'] },
-            };
-            const incomingIdentity = {
-                identityId: 'new-id',
-                traits: { emails: ['test@email.com'] },
-            };
-            const result = isIdentityCacheStale(cachedIdentity, incomingIdentity);
-            expect(result.isCacheStale).toBe(true);
-            expect(result.isIdentityIdStale).toBe(true);
-        });
-        it('should detect new emails', () => {
-            const cachedIdentity = {
-                identityId: 'test-id',
-                traits: { emails: ['old@email.com'] },
-            };
-            const incomingIdentity = {
-                identityId: 'test-id',
-                traits: { emails: ['old@email.com', 'new@email.com'] },
-            };
-            const result = isIdentityCacheStale(cachedIdentity, incomingIdentity);
-            expect(result.isCacheStale).toBe(true);
-            expect(result.isEmailsStale).toBe(true);
-        });
-        it('should detect new user IDs', () => {
-            const cachedIdentity = {
-                identityId: 'test-id',
-                traits: { userIds: ['user1'] },
-            };
-            const incomingIdentity = {
-                identityId: 'test-id',
-                traits: { userIds: ['user1', 'user2'] },
-            };
-            const result = isIdentityCacheStale(cachedIdentity, incomingIdentity);
-            expect(result.isCacheStale).toBe(true);
-            expect(result.isUserIdsStale).toBe(true);
-        });
-        it('should detect new phones', () => {
-            const cachedIdentity = {
-                identityId: 'test-id',
-                traits: { phones: ['+1234567890'] },
-            };
-            const incomingIdentity = {
-                identityId: 'test-id',
-                traits: { phones: ['+1234567890', '+9876543210'] },
-            };
-            const result = isIdentityCacheStale(cachedIdentity, incomingIdentity);
-            expect(result.isCacheStale).toBe(true);
-            expect(result.isPhonesStale).toBe(true);
-        });
-        it('should detect new addresses', () => {
-            const cachedIdentity = {
-                identityId: 'test-id',
-                traits: {
-                    addresses: [
-                        {
-                            city: 'New York',
-                            country: 'USA',
-                        },
-                    ],
-                },
-            };
-            const incomingIdentity = {
-                identityId: 'test-id',
-                traits: {
-                    addresses: [
-                        { city: 'New York', country: 'USA' },
-                        { city: 'Los Angeles', country: 'USA' },
-                    ],
-                },
-            };
-            const result = isIdentityCacheStale(cachedIdentity, incomingIdentity);
-            expect(result.isCacheStale).toBe(true);
-            expect(result.isAddressesStale).toBe(true);
-        });
-        it('should detect IP address changes', () => {
-            const cachedIdentity = {
-                identityId: 'test-id',
-                traits: { ipAddress: '192.168.1.1' },
-            };
-            const incomingIdentity = {
-                identityId: 'test-id',
-                traits: { ipAddress: '10.0.0.1' },
-            };
-            const result = isIdentityCacheStale(cachedIdentity, incomingIdentity);
-            expect(result.isCacheStale).toBe(true);
-            expect(result.isIpAddressStale).toBe(true);
-        });
-        it('should detect user agent changes', () => {
-            const cachedIdentity = {
-                identityId: 'test-id',
-                traits: { userAgent: 'Mozilla/5.0 (old browser)' },
-            };
-            const incomingIdentity = {
-                identityId: 'test-id',
-                traits: { userAgent: 'Mozilla/5.0 (new browser)' },
-            };
-            const result = isIdentityCacheStale(cachedIdentity, incomingIdentity);
-            expect(result.isCacheStale).toBe(true);
-            expect(result.isUserAgentStale).toBe(true);
-        });
-        it('should not be stale when no new information is provided', () => {
-            const cachedIdentity = {
-                identityId: 'test-id',
-                traits: {
-                    emails: ['test@email.com'],
-                    userIds: ['user1'],
-                    phones: ['+1234567890'],
-                },
-            };
-            const incomingIdentity = {
-                identityId: 'test-id',
-                traits: {
-                    emails: ['test@email.com'],
-                    userIds: ['user1'],
-                },
-            };
-            const result = isIdentityCacheStale(cachedIdentity, incomingIdentity);
-            expect(result.isCacheStale).toBe(false);
-        });
-        it('should handle empty traits gracefully', () => {
-            const cachedIdentity = {
-                identityId: 'test-id',
-                traits: {},
-            };
-            const incomingIdentity = {
-                identityId: 'test-id',
-                traits: {},
-            };
-            const result = isIdentityCacheStale(cachedIdentity, incomingIdentity);
-            expect(result.isCacheStale).toBe(false);
-        });
-        it('should handle undefined traits gracefully', () => {
-            const cachedIdentity = {
-                identityId: 'test-id',
-            };
-            const incomingIdentity = {
-                identityId: 'test-id',
-            };
-            const result = isIdentityCacheStale(cachedIdentity, incomingIdentity);
-            expect(result.isCacheStale).toBe(false);
-        });
-        it('should detect multiple stale conditions', () => {
-            const cachedIdentity = {
-                identityId: 'test-id',
-                traits: {
-                    emails: ['old@email.com'],
-                    userIds: ['user1'],
-                    ipAddress: '192.168.1.1',
-                },
-            };
-            const incomingIdentity = {
-                identityId: 'test-id',
-                traits: {
-                    emails: ['old@email.com', 'new@email.com'],
-                    userIds: ['user1', 'user2'],
-                    ipAddress: '10.0.0.1',
-                },
-            };
-            const result = isIdentityCacheStale(cachedIdentity, incomingIdentity);
-            expect(result.isCacheStale).toBe(true);
-            expect(result.isEmailsStale).toBe(true);
-            expect(result.isUserIdsStale).toBe(true);
-            expect(result.isIpAddressStale).toBe(true);
-        });
-    });
-    describe('isClickInfosStale function', () => {
-        it('should detect new FBC values', () => {
-            const cachedClick = {
-                fbc: 'fb.1.123.old_fbclid',
-            };
-            const incomingClick = {
-                fbc: 'fb.1.123.new_fbclid',
-            };
-            const result = isClickInfosStale(cachedClick, incomingClick);
-            expect(result).toBe(true);
-        });
-        it('should detect new click IDs', () => {
-            const cachedClick = {
-                gclid: 'old_gclid',
-            };
-            const incomingClick = {
-                gclid: 'new_gclid',
-            };
-            const result = isClickInfosStale(cachedClick, incomingClick);
-            expect(result).toBe(true);
-        });
-        it('should ignore collection timestamps', () => {
-            const cachedClick = {
-                fbp: 'fb.2.123.456',
-                fbpCollectedAt: '2023-01-01T00:00:00.000Z',
-            };
-            const incomingClick = {
-                fbp: 'fb.2.123.456',
-                fbpCollectedAt: '2024-01-01T00:00:00.000Z',
-            };
-            const result = isClickInfosStale(cachedClick, incomingClick);
-            expect(result).toBe(false);
-        });
-        it('should ignore googleClientInfos', () => {
-            const cachedClick = {
-                googleClientInfos: [{ id: 'old', clickId: 'old_click' }],
-            };
-            const incomingClick = {
-                googleClientInfos: [{ id: 'new', clickId: 'new_click' }],
-            };
-            const result = isClickInfosStale(cachedClick, incomingClick);
-            expect(result).toBe(false);
-        });
-        it('should handle empty click info', () => {
-            const result = isClickInfosStale({}, {});
-            expect(result).toBe(false);
-        });
-        it('should detect when incoming has new click info but cached is empty', () => {
-            const cachedClick = {};
-            const incomingClick = {
-                fbp: 'fb.2.123.456',
-            };
-            const result = isClickInfosStale(cachedClick, incomingClick);
-            expect(result).toBe(true);
-        });
-    });
-    describe('Edge Cases and Error Handling', () => {
-        it('should handle malformed FBC values gracefully', () => {
-            const cachedClick = {
-                fbc: 'malformed_fbc',
-            };
-            const incomingClick = {
-                fbc: 'also_malformed',
-            };
-            const result = isClickInfosStale(cachedClick, incomingClick);
-            expect(result).toBe(true);
-        });
-        it('should handle null/undefined arrays in traits', () => {
-            const cachedIdentity = {
-                identityId: 'test-id',
-                traits: {
-                    emails: null,
-                    userIds: undefined,
-                },
-            };
-            const incomingIdentity = {
-                identityId: 'test-id',
-                traits: {
-                    emails: ['new@email.com'],
-                    userIds: ['user1'],
-                },
-            };
-            const result = isIdentityCacheStale(cachedIdentity, incomingIdentity);
-            expect(result.isCacheStale).toBe(true);
-            expect(result.isEmailsStale).toBe(true);
-            expect(result.isUserIdsStale).toBe(true);
-        });
-        it('should handle arrays with null/undefined elements', () => {
-            const cachedIdentity = {
-                identityId: 'test-id',
-                traits: {
-                    emails: ['valid@email.com', null, undefined],
-                },
-            };
-            const incomingIdentity = {
-                identityId: 'test-id',
-                traits: {
-                    emails: ['valid@email.com', null, undefined, 'new@email.com'],
-                },
-            };
-            const result = isIdentityCacheStale(cachedIdentity, incomingIdentity);
-            expect(result.isCacheStale).toBe(true);
-            expect(result.isEmailsStale).toBe(true);
-        });
-        it('should handle error conditions gracefully', () => {
-            const result = isIdentityCacheStale(null, undefined);
-            expect(result.isCacheStale).toBe(false);
-        });
-    });
-    describe('Comprehensive Scenario Tests', () => {
-        it('should handle complex real-world scenario', () => {
-            const cachedIdentity = {
-                identityId: '01HXRZ27H4TXWBBTRK09Q7APDP',
-                traits: {
-                    emails: ['user@domain.com'],
-                    userIds: ['shopify_123'],
-                    addresses: [
-                        {
-                            city: 'New York',
-                            country: 'USA',
-                            countryCode: 'US',
-                            province: 'NY',
-                            provinceCode: '10001',
-                        },
-                    ],
-                    click: {
-                        fbp: 'fb.2.1715603578424.5068754021',
-                        fbpCollectedAt: '2024-05-13T12:32:58.424Z',
-                        gclid: 'original_gclid',
-                    },
-                    ipAddress: '192.168.1.100',
-                    version: '2',
-                },
-            };
-            const incomingIdentity = {
-                identityId: '01HXRZ27H4TXWBBTRK09Q7APDP',
-                traits: {
-                    emails: ['user@domain.com', 'user.secondary@domain.com'],
-                    phones: ['+1234567890'],
-                    addresses: [
-                        {
-                            city: 'New York',
-                            country: 'USA',
-                            countryCode: 'US',
-                            province: 'NY',
-                            provinceCode: '10001',
-                        },
-                    ],
-                    click: {
-                        fbp: 'fb.2.1715603578424.5068754021',
-                        fbpCollectedAt: '2024-05-13T15:30:00.000Z',
-                        gclid: 'updated_gclid',
-                    },
-                    ipAddress: '192.168.1.100',
-                    version: '2',
-                },
-            };
-            const mergedTraits = mergeIdentityTraits(cachedIdentity.traits, incomingIdentity.traits);
-            const mergedIdentity = { ...incomingIdentity, traits: mergedTraits };
-            const result = isIdentityCacheStale(cachedIdentity, mergedIdentity);
-            expect(result.isCacheStale).toBe(true);
-            expect(result.isEmailsStale).toBe(true);
-            expect(result.isPhonesStale).toBe(true);
-            expect(result.isClickInfosStale).toBe(true);
-            expect(result.isAddressesStale).toBe(false);
-            expect(result.isIpAddressStale).toBe(false);
-            expect(mergedIdentity.traits?.emails).toEqual(['user@domain.com', 'user.secondary@domain.com']);
-            expect(mergedIdentity.traits?.phones).toEqual(['+1234567890']);
-            expect(mergedIdentity.traits?.userIds).toEqual(['shopify_123']);
-            expect(mergedIdentity.traits?.click?.gclid).toEqual('updated_gclid');
-        });
-        it('should properly detect click staleness when click info actually differs', () => {
-            const cachedIdentity = {
-                identityId: 'test-id',
-                traits: {
-                    click: {
-                        gclid: 'original_gclid',
-                        gclidCollectedAt: '2024-05-15T12:32:58.424Z',
-                    },
-                },
-            };
-            const incomingIdentity = {
-                identityId: 'test-id',
-                traits: {
-                    click: {
-                        gclid: 'completely_different_gclid',
-                        gclidCollectedAt: '2024-05-13T12:32:58.424Z',
-                    },
-                },
-            };
-            const mergedTraits = mergeIdentityTraits(cachedIdentity.traits, incomingIdentity.traits);
-            const mergedIdentity = { ...incomingIdentity, traits: mergedTraits };
-            const result = isIdentityCacheStale(cachedIdentity, mergedIdentity);
-            expect(mergedTraits?.click?.gclid).toEqual('original_gclid');
-            expect(result.isCacheStale).toBe(false);
-        });
-        it('should handle scenario where cache is fresh', () => {
-            const cachedIdentity = {
-                identityId: 'test-id',
-                traits: {
-                    emails: ['user@domain.com', 'secondary@domain.com'],
-                    userIds: ['user1', 'user2'],
-                    phones: ['+1234567890'],
-                    version: '2',
-                },
-            };
-            const incomingIdentity = {
-                identityId: 'test-id',
-                traits: {
-                    emails: ['user@domain.com'],
-                    userIds: ['user1'],
-                    version: '2',
-                },
-            };
-            const mergedTraits = mergeIdentityTraits(cachedIdentity.traits, incomingIdentity.traits);
-            const mergedIdentity = { ...incomingIdentity, traits: mergedTraits };
-            const result = isIdentityCacheStale(cachedIdentity, mergedIdentity);
-            expect(result.isCacheStale).toBe(false);
-            expect(mergedIdentity.traits?.emails).toEqual(['user@domain.com', 'secondary@domain.com']);
-            expect(mergedIdentity.traits?.userIds).toEqual(['user1', 'user2']);
-            expect(mergedIdentity.traits?.phones).toEqual(['+1234567890']);
-        });
-    });
-});
+import { mergeIdentityTraits } from '@adtrackify/at-shared-utils';
+import { isIdentityCacheStale, isClickInfosStale } from '../../helpers/identity-cache-helper';
+describe('Identity Trait Merging Tests', () => {
+    afterEach(() => {
+        jest.resetModules();
+    });
+    describe('mergeIdentityTraits function', () => {
+        it('should merge simple string arrays correctly', () => {
+            const incomingTraits = {
+                emails: ['new@email.com'],
+                userIds: ['user1', 'user2'],
+            };
+            const cachedTraits = {
+                emails: ['existing@email.com'],
+                userIds: ['user2', 'user3'],
+                phones: ['+1234567890'],
+            };
+            const merged = mergeIdentityTraits(incomingTraits, cachedTraits);
+            expect(merged.emails).toEqual(['new@email.com', 'existing@email.com']);
+            expect(merged.userIds).toEqual(['user1', 'user2', 'user3']);
+            expect(merged.phones).toEqual(['+1234567890']);
+        });
+        it('should handle null and undefined values in arrays', () => {
+            const incomingTraits = {
+                emails: ['test@email.com', null, undefined],
+                userIds: ['user1'],
+            };
+            const cachedTraits = {
+                emails: [null, 'cached@email.com', undefined],
+                userIds: null,
+            };
+            const merged = mergeIdentityTraits(incomingTraits, cachedTraits);
+            expect(merged.emails).toContain('test@email.com');
+            expect(merged.emails).toContain('cached@email.com');
+            expect(merged.userIds).toEqual(['user1']);
+        });
+        it('should merge addresses correctly', () => {
+            const incomingTraits = {
+                addresses: [
+                    {
+                        city: 'New York',
+                        country: 'USA',
+                        countryCode: 'US',
+                        province: 'NY',
+                        provinceCode: '10001',
+                    },
+                ],
+            };
+            const cachedTraits = {
+                addresses: [
+                    {
+                        city: 'Los Angeles',
+                        country: 'USA',
+                        countryCode: 'US',
+                        province: 'CA',
+                        provinceCode: '90210',
+                    },
+                ],
+            };
+            const merged = mergeIdentityTraits(incomingTraits, cachedTraits);
+            expect(merged.addresses).toHaveLength(2);
+            expect(merged.addresses).toEqual(expect.arrayContaining([
+                expect.objectContaining({ city: 'New York' }),
+                expect.objectContaining({ city: 'Los Angeles' }),
+            ]));
+        });
+        it('should merge click information correctly', () => {
+            const incomingTraits = {
+                click: {
+                    fbp: 'fb.new.123',
+                    fbpCollectedAt: '2024-01-01T00:00:00.000Z',
+                    gclid: 'new_gclid',
+                },
+            };
+            const cachedTraits = {
+                click: {
+                    fbp: 'fb.old.456',
+                    fbpCollectedAt: '2023-12-01T00:00:00.000Z',
+                    fbclid: 'cached_fbclid',
+                },
+            };
+            const merged = mergeIdentityTraits(incomingTraits, cachedTraits);
+            expect(merged.click?.fbp).toBe('fb.new.123');
+            expect(merged.click?.gclid).toBe('new_gclid');
+            expect(merged.click?.fbpCollectedAt).toBe('2024-01-01T00:00:00.000Z');
+            expect(merged.click?.fbclid).toBeUndefined();
+        });
+        it('should handle empty traits correctly', () => {
+            const incomingTraits = {};
+            const cachedTraits = {
+                emails: ['cached@email.com'],
+                userIds: ['user1'],
+            };
+            const merged = mergeIdentityTraits(incomingTraits, cachedTraits);
+            expect(merged.emails).toEqual(['cached@email.com']);
+            expect(merged.userIds).toEqual(['user1']);
+        });
+        it('should handle undefined traits correctly', () => {
+            const merged1 = mergeIdentityTraits(undefined, { emails: ['test@email.com'] });
+            expect(merged1.emails).toEqual(['test@email.com']);
+            const merged2 = mergeIdentityTraits({ emails: ['test@email.com'] }, undefined);
+            expect(merged2.emails).toEqual(['test@email.com']);
+            const merged3 = mergeIdentityTraits(undefined, undefined);
+            expect(merged3).toEqual({});
+        });
+        it('should preserve version information', () => {
+            const incomingTraits = {
+                version: '3',
+                emails: ['new@email.com'],
+            };
+            const cachedTraits = {
+                version: '2',
+                emails: ['old@email.com'],
+            };
+            const merged = mergeIdentityTraits(incomingTraits, cachedTraits);
+            expect(merged.version).toBe('3');
+            expect(merged.emails).toEqual(['new@email.com', 'old@email.com']);
+        });
+        it('should handle complex nested objects', () => {
+            const incomingTraits = {
+                click: {
+                    googleClientInfos: [{ id: 'new1', clickId: 'click1', sessionId: 'session1' }],
+                },
+            };
+            const cachedTraits = {
+                click: {
+                    googleClientInfos: [{ id: 'cached1', clickId: 'click2', sessionId: 'session2' }],
+                },
+            };
+            const merged = mergeIdentityTraits(incomingTraits, cachedTraits);
+            expect(merged.click?.googleClientInfos).toBeDefined();
+            expect(Array.isArray(merged.click?.googleClientInfos)).toBe(true);
+            expect(merged.click?.googleClientInfos).toEqual([{ id: 'cached1', clickId: 'click2', sessionId: 'session2' }]);
+        });
+    });
+    describe('Integration: Merging + Staleness Checking', () => {
+        it('should not be stale when merged identity matches cached identity', () => {
+            const cachedIdentity = {
+                identityId: 'test-id-123',
+                traits: {
+                    emails: ['cached@email.com', 'shared@email.com'],
+                    userIds: ['user1', 'user2'],
+                    addresses: [
+                        {
+                            city: 'New York',
+                            country: 'USA',
+                            countryCode: 'US',
+                        },
+                    ],
+                    version: '2',
+                },
+            };
+            const incomingIdentity = {
+                identityId: 'test-id-123',
+                traits: {
+                    emails: ['shared@email.com'],
+                    userIds: ['user1'],
+                    version: '2',
+                },
+            };
+            const mergedTraits = mergeIdentityTraits(incomingIdentity.traits, cachedIdentity.traits);
+            const mergedIdentity = { ...incomingIdentity, traits: mergedTraits };
+            const staleTracker = isIdentityCacheStale(cachedIdentity, mergedIdentity);
+            expect(staleTracker.isCacheStale).toBe(false);
+            expect(mergedIdentity.traits?.emails).toEqual(['shared@email.com', 'cached@email.com']);
+        });
+        it('should be stale when merged identity has new traits', () => {
+            const cachedIdentity = {
+                identityId: 'test-id-123',
+                traits: {
+                    emails: ['cached@email.com'],
+                    version: '2',
+                },
+            };
+            const incomingIdentity = {
+                identityId: 'test-id-123',
+                traits: {
+                    emails: ['cached@email.com', 'new@email.com'],
+                    version: '2',
+                },
+            };
+            const mergedTraits = mergeIdentityTraits(incomingIdentity.traits, cachedIdentity.traits);
+            const mergedIdentity = { ...incomingIdentity, traits: mergedTraits };
+            const staleTracker = isIdentityCacheStale(cachedIdentity, mergedIdentity);
+            expect(staleTracker.isCacheStale).toBe(true);
+            expect(staleTracker.isEmailsStale).toBe(true);
+        });
+    });
+});
+describe('Identity Cache Staleness Tests', () => {
+    afterEach(() => {
+        jest.resetModules();
+    });
+    describe('isIdentityCacheStale function', () => {
+        it('should detect identity ID changes', () => {
+            const cachedIdentity = {
+                identityId: 'old-id',
+                traits: { emails: ['test@email.com'] },
+            };
+            const incomingIdentity = {
+                identityId: 'new-id',
+                traits: { emails: ['test@email.com'] },
+            };
+            const result = isIdentityCacheStale(cachedIdentity, incomingIdentity);
+            expect(result.isCacheStale).toBe(true);
+            expect(result.isIdentityIdStale).toBe(true);
+        });
+        it('should detect new emails', () => {
+            const cachedIdentity = {
+                identityId: 'test-id',
+                traits: { emails: ['old@email.com'] },
+            };
+            const incomingIdentity = {
+                identityId: 'test-id',
+                traits: { emails: ['old@email.com', 'new@email.com'] },
+            };
+            const result = isIdentityCacheStale(cachedIdentity, incomingIdentity);
+            expect(result.isCacheStale).toBe(true);
+            expect(result.isEmailsStale).toBe(true);
+        });
+        it('should detect new user IDs', () => {
+            const cachedIdentity = {
+                identityId: 'test-id',
+                traits: { userIds: ['user1'] },
+            };
+            const incomingIdentity = {
+                identityId: 'test-id',
+                traits: { userIds: ['user1', 'user2'] },
+            };
+            const result = isIdentityCacheStale(cachedIdentity, incomingIdentity);
+            expect(result.isCacheStale).toBe(true);
+            expect(result.isUserIdsStale).toBe(true);
+        });
+        it('should detect new phones', () => {
+            const cachedIdentity = {
+                identityId: 'test-id',
+                traits: { phones: ['+1234567890'] },
+            };
+            const incomingIdentity = {
+                identityId: 'test-id',
+                traits: { phones: ['+1234567890', '+9876543210'] },
+            };
+            const result = isIdentityCacheStale(cachedIdentity, incomingIdentity);
+            expect(result.isCacheStale).toBe(true);
+            expect(result.isPhonesStale).toBe(true);
+        });
+        it('should detect new addresses', () => {
+            const cachedIdentity = {
+                identityId: 'test-id',
+                traits: {
+                    addresses: [
+                        {
+                            city: 'New York',
+                            country: 'USA',
+                        },
+                    ],
+                },
+            };
+            const incomingIdentity = {
+                identityId: 'test-id',
+                traits: {
+                    addresses: [
+                        { city: 'New York', country: 'USA' },
+                        { city: 'Los Angeles', country: 'USA' },
+                    ],
+                },
+            };
+            const result = isIdentityCacheStale(cachedIdentity, incomingIdentity);
+            expect(result.isCacheStale).toBe(true);
+            expect(result.isAddressesStale).toBe(true);
+        });
+        it('should detect IP address changes', () => {
+            const cachedIdentity = {
+                identityId: 'test-id',
+                traits: { ipAddress: '192.168.1.1' },
+            };
+            const incomingIdentity = {
+                identityId: 'test-id',
+                traits: { ipAddress: '10.0.0.1' },
+            };
+            const result = isIdentityCacheStale(cachedIdentity, incomingIdentity);
+            expect(result.isCacheStale).toBe(true);
+            expect(result.isIpAddressStale).toBe(true);
+        });
+        it('should detect user agent changes', () => {
+            const cachedIdentity = {
+                identityId: 'test-id',
+                traits: { userAgent: 'Mozilla/5.0 (old browser)' },
+            };
+            const incomingIdentity = {
+                identityId: 'test-id',
+                traits: { userAgent: 'Mozilla/5.0 (new browser)' },
+            };
+            const result = isIdentityCacheStale(cachedIdentity, incomingIdentity);
+            expect(result.isCacheStale).toBe(true);
+            expect(result.isUserAgentStale).toBe(true);
+        });
+        it('should not be stale when no new information is provided', () => {
+            const cachedIdentity = {
+                identityId: 'test-id',
+                traits: {
+                    emails: ['test@email.com'],
+                    userIds: ['user1'],
+                    phones: ['+1234567890'],
+                },
+            };
+            const incomingIdentity = {
+                identityId: 'test-id',
+                traits: {
+                    emails: ['test@email.com'],
+                    userIds: ['user1'],
+                },
+            };
+            const result = isIdentityCacheStale(cachedIdentity, incomingIdentity);
+            expect(result.isCacheStale).toBe(false);
+        });
+        it('should handle empty traits gracefully', () => {
+            const cachedIdentity = {
+                identityId: 'test-id',
+                traits: {},
+            };
+            const incomingIdentity = {
+                identityId: 'test-id',
+                traits: {},
+            };
+            const result = isIdentityCacheStale(cachedIdentity, incomingIdentity);
+            expect(result.isCacheStale).toBe(false);
+        });
+        it('should handle undefined traits gracefully', () => {
+            const cachedIdentity = {
+                identityId: 'test-id',
+            };
+            const incomingIdentity = {
+                identityId: 'test-id',
+            };
+            const result = isIdentityCacheStale(cachedIdentity, incomingIdentity);
+            expect(result.isCacheStale).toBe(false);
+        });
+        it('should detect multiple stale conditions', () => {
+            const cachedIdentity = {
+                identityId: 'test-id',
+                traits: {
+                    emails: ['old@email.com'],
+                    userIds: ['user1'],
+                    ipAddress: '192.168.1.1',
+                },
+            };
+            const incomingIdentity = {
+                identityId: 'test-id',
+                traits: {
+                    emails: ['old@email.com', 'new@email.com'],
+                    userIds: ['user1', 'user2'],
+                    ipAddress: '10.0.0.1',
+                },
+            };
+            const result = isIdentityCacheStale(cachedIdentity, incomingIdentity);
+            expect(result.isCacheStale).toBe(true);
+            expect(result.isEmailsStale).toBe(true);
+            expect(result.isUserIdsStale).toBe(true);
+            expect(result.isIpAddressStale).toBe(true);
+        });
+    });
+    describe('isClickInfosStale function', () => {
+        it('should detect new FBC values', () => {
+            const cachedClick = {
+                fbc: 'fb.1.123.old_fbclid',
+            };
+            const incomingClick = {
+                fbc: 'fb.1.123.new_fbclid',
+            };
+            const result = isClickInfosStale(cachedClick, incomingClick);
+            expect(result).toBe(true);
+        });
+        it('should detect new click IDs', () => {
+            const cachedClick = {
+                gclid: 'old_gclid',
+            };
+            const incomingClick = {
+                gclid: 'new_gclid',
+            };
+            const result = isClickInfosStale(cachedClick, incomingClick);
+            expect(result).toBe(true);
+        });
+        it('should ignore collection timestamps', () => {
+            const cachedClick = {
+                fbp: 'fb.2.123.456',
+                fbpCollectedAt: '2023-01-01T00:00:00.000Z',
+            };
+            const incomingClick = {
+                fbp: 'fb.2.123.456',
+                fbpCollectedAt: '2024-01-01T00:00:00.000Z',
+            };
+            const result = isClickInfosStale(cachedClick, incomingClick);
+            expect(result).toBe(false);
+        });
+        it('should ignore googleClientInfos', () => {
+            const cachedClick = {
+                googleClientInfos: [{ id: 'old', clickId: 'old_click' }],
+            };
+            const incomingClick = {
+                googleClientInfos: [{ id: 'new', clickId: 'new_click' }],
+            };
+            const result = isClickInfosStale(cachedClick, incomingClick);
+            expect(result).toBe(false);
+        });
+        it('should handle empty click info', () => {
+            const result = isClickInfosStale({}, {});
+            expect(result).toBe(false);
+        });
+        it('should detect when incoming has new click info but cached is empty', () => {
+            const cachedClick = {};
+            const incomingClick = {
+                fbp: 'fb.2.123.456',
+            };
+            const result = isClickInfosStale(cachedClick, incomingClick);
+            expect(result).toBe(true);
+        });
+    });
+    describe('Edge Cases and Error Handling', () => {
+        it('should handle malformed FBC values gracefully', () => {
+            const cachedClick = {
+                fbc: 'malformed_fbc',
+            };
+            const incomingClick = {
+                fbc: 'also_malformed',
+            };
+            const result = isClickInfosStale(cachedClick, incomingClick);
+            expect(result).toBe(true);
+        });
+        it('should handle null/undefined arrays in traits', () => {
+            const cachedIdentity = {
+                identityId: 'test-id',
+                traits: {
+                    emails: null,
+                    userIds: undefined,
+                },
+            };
+            const incomingIdentity = {
+                identityId: 'test-id',
+                traits: {
+                    emails: ['new@email.com'],
+                    userIds: ['user1'],
+                },
+            };
+            const result = isIdentityCacheStale(cachedIdentity, incomingIdentity);
+            expect(result.isCacheStale).toBe(true);
+            expect(result.isEmailsStale).toBe(true);
+            expect(result.isUserIdsStale).toBe(true);
+        });
+        it('should handle arrays with null/undefined elements', () => {
+            const cachedIdentity = {
+                identityId: 'test-id',
+                traits: {
+                    emails: ['valid@email.com', null, undefined],
+                },
+            };
+            const incomingIdentity = {
+                identityId: 'test-id',
+                traits: {
+                    emails: ['valid@email.com', null, undefined, 'new@email.com'],
+                },
+            };
+            const result = isIdentityCacheStale(cachedIdentity, incomingIdentity);
+            expect(result.isCacheStale).toBe(true);
+            expect(result.isEmailsStale).toBe(true);
+        });
+        it('should handle error conditions gracefully', () => {
+            const result = isIdentityCacheStale(null, undefined);
+            expect(result.isCacheStale).toBe(false);
+        });
+    });
+    describe('Comprehensive Scenario Tests', () => {
+        it('should handle complex real-world scenario', () => {
+            const cachedIdentity = {
+                identityId: '01HXRZ27H4TXWBBTRK09Q7APDP',
+                traits: {
+                    emails: ['user@domain.com'],
+                    userIds: ['shopify_123'],
+                    addresses: [
+                        {
+                            city: 'New York',
+                            country: 'USA',
+                            countryCode: 'US',
+                            province: 'NY',
+                            provinceCode: '10001',
+                        },
+                    ],
+                    click: {
+                        fbp: 'fb.2.1715603578424.5068754021',
+                        fbpCollectedAt: '2024-05-13T12:32:58.424Z',
+                        gclid: 'original_gclid',
+                    },
+                    ipAddress: '192.168.1.100',
+                    version: '2',
+                },
+            };
+            const incomingIdentity = {
+                identityId: '01HXRZ27H4TXWBBTRK09Q7APDP',
+                traits: {
+                    emails: ['user@domain.com', 'user.secondary@domain.com'],
+                    phones: ['+1234567890'],
+                    addresses: [
+                        {
+                            city: 'New York',
+                            country: 'USA',
+                            countryCode: 'US',
+                            province: 'NY',
+                            provinceCode: '10001',
+                        },
+                    ],
+                    click: {
+                        fbp: 'fb.2.1715603578424.5068754021',
+                        fbpCollectedAt: '2024-05-13T15:30:00.000Z',
+                        gclid: 'updated_gclid',
+                    },
+                    ipAddress: '192.168.1.100',
+                    version: '2',
+                },
+            };
+            const mergedTraits = mergeIdentityTraits(cachedIdentity.traits, incomingIdentity.traits);
+            const mergedIdentity = { ...incomingIdentity, traits: mergedTraits };
+            const result = isIdentityCacheStale(cachedIdentity, mergedIdentity);
+            expect(result.isCacheStale).toBe(true);
+            expect(result.isEmailsStale).toBe(true);
+            expect(result.isPhonesStale).toBe(true);
+            expect(result.isClickInfosStale).toBe(true);
+            expect(result.isAddressesStale).toBe(false);
+            expect(result.isIpAddressStale).toBe(false);
+            expect(mergedIdentity.traits?.emails).toEqual(['user@domain.com', 'user.secondary@domain.com']);
+            expect(mergedIdentity.traits?.phones).toEqual(['+1234567890']);
+            expect(mergedIdentity.traits?.userIds).toEqual(['shopify_123']);
+            expect(mergedIdentity.traits?.click?.gclid).toEqual('updated_gclid');
+        });
+        it('should properly detect click staleness when click info actually differs', () => {
+            const cachedIdentity = {
+                identityId: 'test-id',
+                traits: {
+                    click: {
+                        gclid: 'original_gclid',
+                        gclidCollectedAt: '2024-05-15T12:32:58.424Z',
+                    },
+                },
+            };
+            const incomingIdentity = {
+                identityId: 'test-id',
+                traits: {
+                    click: {
+                        gclid: 'completely_different_gclid',
+                        gclidCollectedAt: '2024-05-13T12:32:58.424Z',
+                    },
+                },
+            };
+            const mergedTraits = mergeIdentityTraits(cachedIdentity.traits, incomingIdentity.traits);
+            const mergedIdentity = { ...incomingIdentity, traits: mergedTraits };
+            const result = isIdentityCacheStale(cachedIdentity, mergedIdentity);
+            expect(mergedTraits?.click?.gclid).toEqual('original_gclid');
+            expect(result.isCacheStale).toBe(false);
+        });
+        it('should handle scenario where cache is fresh', () => {
+            const cachedIdentity = {
+                identityId: 'test-id',
+                traits: {
+                    emails: ['user@domain.com', 'secondary@domain.com'],
+                    userIds: ['user1', 'user2'],
+                    phones: ['+1234567890'],
+                    version: '2',
+                },
+            };
+            const incomingIdentity = {
+                identityId: 'test-id',
+                traits: {
+                    emails: ['user@domain.com'],
+                    userIds: ['user1'],
+                    version: '2',
+                },
+            };
+            const mergedTraits = mergeIdentityTraits(cachedIdentity.traits, incomingIdentity.traits);
+            const mergedIdentity = { ...incomingIdentity, traits: mergedTraits };
+            const result = isIdentityCacheStale(cachedIdentity, mergedIdentity);
+            expect(result.isCacheStale).toBe(false);
+            expect(mergedIdentity.traits?.emails).toEqual(['user@domain.com', 'secondary@domain.com']);
+            expect(mergedIdentity.traits?.userIds).toEqual(['user1', 'user2']);
+            expect(mergedIdentity.traits?.phones).toEqual(['+1234567890']);
+        });
+    });
+});
 //# sourceMappingURL=trait-merging-and-staleness.spec.js.map