@adtrackify/at-service-common 3.0.45 → 3.0.47

package/dist/esm/libs/referrer-parser/referrer-parser-util.d.ts

@@ -1,20 +1,20 @@
-/// <reference types="node" />
-import url from 'url';
-export interface ReferrerDictionary {
-    [domain: string]: {
-        name: string;
-        medium: string;
-        params?: string[];
-    };
-}
-export declare class Referrer {
-    known: boolean;
-    referrer: string | null;
-    medium: string;
-    search_parameter: string | null;
-    search_term: string | string[] | null | undefined;
-    referrers: any;
-    uri?: url.UrlWithStringQuery;
-    constructor(referrer_url?: string, current_url?: string);
-    _lookup_referrer: (ref_host: string | null | undefined, ref_path: string | null, include_path: boolean) => any;
-}
+/// <reference types="node" />
+import url from 'url';
+export interface ReferrerDictionary {
+    [domain: string]: {
+        name: string;
+        medium: string;
+        params?: string[];
+    };
+}
+export declare class Referrer {
+    known: boolean;
+    referrer: string | null;
+    medium: string;
+    search_parameter: string | null;
+    search_term: string | string[] | null | undefined;
+    referrers: any;
+    uri?: url.UrlWithStringQuery;
+    constructor(referrer_url?: string, current_url?: string);
+    _lookup_referrer: (ref_host: string | null | undefined, ref_path: string | null, include_path: boolean) => any;
+}

package/dist/esm/libs/referrer-parser/referrer-parser-util.js

@@ -1,122 +1,122 @@
-import url from 'url';
-import querystring from 'querystring';
-import { REFERRER_DATA } from './referrer-data.js';
-const REFERERS = loadReferrers(REFERRER_DATA);
-function loadReferrers(source) {
-    const referrers_dict = {};
-    for (const medium in source) {
-        const conf_list = source[medium];
-        for (const referrer_name in conf_list) {
-            const config = conf_list[referrer_name];
-            let params = null;
-            if (config.parameters) {
-                params = config.parameters.map(function (p) { return p.toLowerCase(); });
-            }
-            config.domains.forEach(function (domain) {
-                referrers_dict[domain] = {
-                    'name': referrer_name,
-                    'medium': medium
-                };
-                if (params) {
-                    referrers_dict[domain]['params'] = params;
-                }
-            });
-        }
-    }
-    return referrers_dict;
-}
-export class Referrer {
-    known;
-    referrer;
-    medium;
-    search_parameter;
-    search_term;
-    referrers;
-    uri;
-    constructor(referrer_url, current_url) {
-        this.known = false;
-        this.referrer = null;
-        this.medium = 'unknown';
-        this.search_parameter = null;
-        this.search_term = null;
-        if (!referrer_url) {
-            this.medium = 'none';
-            this.referrer = 'direct';
-            return;
-        }
-        const ref_uri = url.parse(referrer_url);
-        const ref_host = ref_uri.hostname;
-        this.known = Boolean(~['http:', 'https:'].indexOf(ref_uri.protocol));
-        this.uri = ref_uri;
-        if (!this.known)
-            return;
-        if (current_url) {
-            const curr_uri = url.parse(current_url);
-            const curr_host = curr_uri.hostname;
-            if (curr_host == ref_host) {
-                this.medium = 'internal';
-                this.referrer = 'internal';
-                return;
-            }
-        }
-        let referrer = this._lookup_referrer(ref_host, ref_uri.pathname, true);
-        if (!referrer) {
-            referrer = this._lookup_referrer(ref_host, ref_uri.pathname, false);
-            if (!referrer) {
-                this.medium = 'referral';
-                this.referrer = ref_host;
-                return;
-            }
-        }
-        this.referrer = referrer['name'];
-        this.medium = referrer['medium'];
-        if (referrer['medium'] == 'search') {
-            if (!referrer['params'])
-                return;
-            const pqs = querystring.parse(ref_uri?.query || '');
-            for (const param in pqs) {
-                const val = pqs[param];
-                if (referrer['params'].indexOf(param.toLowerCase()) !== -1) {
-                    this.search_parameter = param;
-                    this.search_term = val;
-                }
-            }
-        }
-    }
-    _lookup_referrer = (ref_host, ref_path, include_path) => {
-        let referrer = null;
-        if (include_path) {
-            const hostpath = (ref_host ?? '') + (ref_path ?? '');
-            referrer = REFERERS[hostpath];
-        }
-        else {
-            referrer = REFERERS[ref_host ?? ''];
-        }
-        if (!referrer) {
-            if (include_path) {
-                const path_parts = ref_path?.split('/');
-                if (path_parts && path_parts.length > 1) {
-                    try {
-                        referrer = REFERERS[ref_host + '/' + path_parts[1]];
-                    }
-                    catch (e) { }
-                }
-            }
-        }
-        if (!referrer) {
-            try {
-                const idx = (ref_host ?? '').indexOf('.');
-                if (idx === -1)
-                    return null;
-                const slicedHost = ref_host?.slice(idx + 1);
-                return this._lookup_referrer(slicedHost, ref_path, include_path);
-            }
-            catch (e) {
-                return null;
-            }
-        }
-        else
-            return referrer;
-    };
-}
+import url from 'url';
+import querystring from 'querystring';
+import { REFERRER_DATA } from './referrer-data.js';
+const REFERERS = loadReferrers(REFERRER_DATA);
+function loadReferrers(source) {
+    const referrers_dict = {};
+    for (const medium in source) {
+        const conf_list = source[medium];
+        for (const referrer_name in conf_list) {
+            const config = conf_list[referrer_name];
+            let params = null;
+            if (config.parameters) {
+                params = config.parameters.map(function (p) { return p.toLowerCase(); });
+            }
+            config.domains.forEach(function (domain) {
+                referrers_dict[domain] = {
+                    'name': referrer_name,
+                    'medium': medium
+                };
+                if (params) {
+                    referrers_dict[domain]['params'] = params;
+                }
+            });
+        }
+    }
+    return referrers_dict;
+}
+export class Referrer {
+    known;
+    referrer;
+    medium;
+    search_parameter;
+    search_term;
+    referrers;
+    uri;
+    constructor(referrer_url, current_url) {
+        this.known = false;
+        this.referrer = null;
+        this.medium = 'unknown';
+        this.search_parameter = null;
+        this.search_term = null;
+        if (!referrer_url) {
+            this.medium = 'none';
+            this.referrer = 'direct';
+            return;
+        }
+        const ref_uri = url.parse(referrer_url);
+        const ref_host = ref_uri.hostname;
+        this.known = Boolean(~['http:', 'https:'].indexOf(ref_uri.protocol));
+        this.uri = ref_uri;
+        if (!this.known)
+            return;
+        if (current_url) {
+            const curr_uri = url.parse(current_url);
+            const curr_host = curr_uri.hostname;
+            if (curr_host == ref_host) {
+                this.medium = 'internal';
+                this.referrer = 'internal';
+                return;
+            }
+        }
+        let referrer = this._lookup_referrer(ref_host, ref_uri.pathname, true);
+        if (!referrer) {
+            referrer = this._lookup_referrer(ref_host, ref_uri.pathname, false);
+            if (!referrer) {
+                this.medium = 'referral';
+                this.referrer = ref_host;
+                return;
+            }
+        }
+        this.referrer = referrer['name'];
+        this.medium = referrer['medium'];
+        if (referrer['medium'] == 'search') {
+            if (!referrer['params'])
+                return;
+            const pqs = querystring.parse(ref_uri?.query || '');
+            for (const param in pqs) {
+                const val = pqs[param];
+                if (referrer['params'].indexOf(param.toLowerCase()) !== -1) {
+                    this.search_parameter = param;
+                    this.search_term = val;
+                }
+            }
+        }
+    }
+    _lookup_referrer = (ref_host, ref_path, include_path) => {
+        let referrer = null;
+        if (include_path) {
+            const hostpath = (ref_host ?? '') + (ref_path ?? '');
+            referrer = REFERERS[hostpath];
+        }
+        else {
+            referrer = REFERERS[ref_host ?? ''];
+        }
+        if (!referrer) {
+            if (include_path) {
+                const path_parts = ref_path?.split('/');
+                if (path_parts && path_parts.length > 1) {
+                    try {
+                        referrer = REFERERS[ref_host + '/' + path_parts[1]];
+                    }
+                    catch (e) { }
+                }
+            }
+        }
+        if (!referrer) {
+            try {
+                const idx = (ref_host ?? '').indexOf('.');
+                if (idx === -1)
+                    return null;
+                const slicedHost = ref_host?.slice(idx + 1);
+                return this._lookup_referrer(slicedHost, ref_path, include_path);
+            }
+            catch (e) {
+                return null;
+            }
+        }
+        else
+            return referrer;
+    };
+}
 //# sourceMappingURL=referrer-parser-util.js.map

package/dist/esm/libs/url.d.ts

@@ -1 +1 @@
-export declare const mapObjectToQueryString: (inputObj: any) => string;
+export declare const mapObjectToQueryString: (inputObj: any) => string;

package/dist/esm/libs/url.js

@@ -1,10 +1,10 @@
-export const mapObjectToQueryString = (inputObj) => {
-    const qsp = Object.entries(inputObj).sort((a, b) => a[0] < b[0] ? -1 : 1);
-    const urlParams = new URLSearchParams();
-    qsp.map(p => {
-        urlParams.append(p[0], p[1]);
-    });
-    const qs = urlParams.toString();
-    return qs;
-};
+export const mapObjectToQueryString = (inputObj) => {
+    const qsp = Object.entries(inputObj).sort((a, b) => a[0] < b[0] ? -1 : 1);
+    const urlParams = new URLSearchParams();
+    qsp.map(p => {
+        urlParams.append(p[0], p[1]);
+    });
+    const qs = urlParams.toString();
+    return qs;
+};
 //# sourceMappingURL=url.js.map

package/dist/esm/services/db/destinations-service.d.ts

@@ -1,7 +1,7 @@
-import { Destination } from '@adtrackify/at-tracking-event-types';
-export declare class DestinationsService {
-    TABLE_NAME: string;
-    constructor(tableName: string);
-    getDestinationsByPixel: (indexName: string, pixelId: string) => Promise<Destination[]>;
-    getDestinationsByAccountId: (indexName: string, accountId: string) => Promise<Destination[]>;
-}
+import { Destination } from '@adtrackify/at-tracking-event-types';
+export declare class DestinationsService {
+    TABLE_NAME: string;
+    constructor(tableName: string);
+    getDestinationsByPixel: (indexName: string, pixelId: string) => Promise<Destination[]>;
+    getDestinationsByAccountId: (indexName: string, accountId: string) => Promise<Destination[]>;
+}

package/dist/esm/services/db/destinations-service.js

@@ -1,32 +1,32 @@
-import { DynamoDbClient } from '../../clients';
-export class DestinationsService {
-    TABLE_NAME;
-    constructor(tableName) {
-        this.TABLE_NAME = tableName;
-    }
-    getDestinationsByPixel = async (indexName, pixelId) => {
-        const query = {
-            TableName: this.TABLE_NAME,
-            IndexName: indexName,
-            KeyConditionExpression: 'pixelId = :pixelId',
-            ExpressionAttributeValues: {
-                ':pixelId': pixelId,
-            },
-        };
-        const destinations = await DynamoDbClient.queryAll(query);
-        return destinations || [];
-    };
-    getDestinationsByAccountId = async (indexName, accountId) => {
-        const query = {
-            TableName: this.TABLE_NAME,
-            IndexName: indexName,
-            KeyConditionExpression: 'accountId = :accountId',
-            ExpressionAttributeValues: {
-                ':accountId': accountId,
-            },
-        };
-        const destinations = await DynamoDbClient.queryAll(query);
-        return destinations || [];
-    };
-}
+import { DynamoDbClient } from '../../clients';
+export class DestinationsService {
+    TABLE_NAME;
+    constructor(tableName) {
+        this.TABLE_NAME = tableName;
+    }
+    getDestinationsByPixel = async (indexName, pixelId) => {
+        const query = {
+            TableName: this.TABLE_NAME,
+            IndexName: indexName,
+            KeyConditionExpression: 'pixelId = :pixelId',
+            ExpressionAttributeValues: {
+                ':pixelId': pixelId,
+            },
+        };
+        const destinations = await DynamoDbClient.queryAll(query);
+        return destinations || [];
+    };
+    getDestinationsByAccountId = async (indexName, accountId) => {
+        const query = {
+            TableName: this.TABLE_NAME,
+            IndexName: indexName,
+            KeyConditionExpression: 'accountId = :accountId',
+            ExpressionAttributeValues: {
+                ':accountId': accountId,
+            },
+        };
+        const destinations = await DynamoDbClient.queryAll(query);
+        return destinations || [];
+    };
+}
 //# sourceMappingURL=destinations-service.js.map

package/dist/esm/services/db/identity-cache-db-service.d.ts

@@ -1,22 +1,23 @@
-import { EventIdentity } from '@adtrackify/at-tracking-event-types';
-import { IdentityClient } from '../../clients';
-export interface IdentityCache {
-    identityId: string;
-    request: EventIdentity;
-    response: EventIdentity;
-    createdAt: string;
-    updatedAt: string;
-    expiresAt: number;
-}
-export declare class IdentityCacheDbService {
-    TABLE_NAME: string;
-    TABLE_KEY: string;
-    TTL_IN_MONTHS: number;
-    identityClient: IdentityClient;
-    constructor(tableName: string, tableKey: string, ttlInMonths: number, baseApiUrl: string, identityApiKey?: string);
-    lookupIdentityCache: (pixelId: string, identityId: string, incomingIdentity: EventIdentity) => Promise<any>;
-    putIdentityCache: (identityId: string, request: EventIdentity, response: EventIdentity) => Promise<import("@aws-sdk/lib-dynamodb").PutCommandOutput | null>;
-    updateIdentityCache: (identityId: string, request: EventIdentity, response: EventIdentity) => Promise<void>;
-    getIdentityCache: (identityId: string) => Promise<IdentityCache>;
-    deleteIdentityCache: (identityId: string) => Promise<import("@aws-sdk/lib-dynamodb").DeleteCommandOutput | null>;
-}
+import { EventIdentity } from '@adtrackify/at-tracking-event-types';
+import { IdentityClient } from '../../clients';
+export interface IdentityCache {
+    identityId: string;
+    request: EventIdentity;
+    response: EventIdentity;
+    createdAt: string;
+    updatedAt: string;
+    expiresAt: number;
+}
+export declare class IdentityCacheDbService {
+    TABLE_NAME: string;
+    TABLE_KEY: string;
+    TTL_IN_MONTHS: number;
+    identityClient: IdentityClient;
+    constructor(tableName: string, tableKey: string, baseApiUrl: string, cacheTtlInMonths?: number);
+    getIdentityWithCaching: (pixelId: string, identityId: string, incomingIdentity: EventIdentity, cacheExpiryInSeconds?: number) => Promise<EventIdentity>;
+    updateIdentityCache: (identityId: string, request: EventIdentity, response: EventIdentity) => Promise<void>;
+    putIdentityCache: (identityCache: IdentityCache) => Promise<import("@aws-sdk/lib-dynamodb").PutCommandOutput | null>;
+    getIdentityCache: (identityId: string) => Promise<IdentityCache>;
+    deleteIdentityCache: (identityId: string) => Promise<import("@aws-sdk/lib-dynamodb").DeleteCommandOutput | null>;
+    isIdentityCacheStale(identityCache: IdentityCache, incomingIdentity: EventIdentity): boolean;
+}

package/dist/esm/services/db/identity-cache-db-service.js

@@ -1,65 +1,149 @@
-import { DateTime } from 'luxon';
-import { DynamoDbClient, IdentityClient } from '../../clients';
-import { getCurrentTimestamp } from '../../libs';
-import { compareIdentityAndShouldUseCache } from '@adtrackify/at-shared-utils';
-import { Logger } from '../../helpers';
-export class IdentityCacheDbService {
-    TABLE_NAME;
-    TABLE_KEY;
-    TTL_IN_MONTHS;
-    identityClient;
-    constructor(tableName, tableKey, ttlInMonths, baseApiUrl, identityApiKey) {
-        this.TABLE_NAME = tableName;
-        this.TABLE_KEY = tableKey;
-        this.TTL_IN_MONTHS = ttlInMonths;
-        this.identityClient = new IdentityClient(baseApiUrl, identityApiKey);
-    }
-    lookupIdentityCache = async (pixelId, identityId, incomingIdentity) => {
-        const cachedIdentity = await this.getIdentityCache(identityId);
-        if (cachedIdentity && compareIdentityAndShouldUseCache(cachedIdentity, incomingIdentity)) {
-            Logger.debug('identity cache hit', { cachedIdentity, incomingIdentity });
-            if (incomingIdentity?.traits?.emails && cachedIdentity?.response?.traits?.emails && incomingIdentity?.traits?.emails?.length !== cachedIdentity.response?.traits?.emails?.length) {
-                Logger.warn('Incoming identity & response identity having different emails lengths', { incomingIdentity, cachedIdentity });
-            }
-            else if (incomingIdentity?.traits?.userIds && cachedIdentity?.response?.traits?.userIds && incomingIdentity?.traits?.userIds?.length !== cachedIdentity.response?.traits?.userIds?.length) {
-                Logger.warn('Incoming identity & response identity having different userIds lengths', { incomingIdentity, cachedIdentity });
-            }
-            return cachedIdentity.response;
-        }
-        else if (cachedIdentity) {
-            Logger.debug('identity cache miss - record exists but stale', { cachedIdentity, incomingIdentity });
-            return await this.identityClient.getIdentity(pixelId, { identity: incomingIdentity });
-        }
-    };
-    putIdentityCache = async (identityId, request, response) => {
-        const expiresAt = DateTime.now().plus({ months: this.TTL_IN_MONTHS }).toSeconds();
-        const identityCache = {
-            identityId,
-            request,
-            response,
-            createdAt: getCurrentTimestamp(),
-            updatedAt: getCurrentTimestamp(),
-            expiresAt
-        };
-        return await DynamoDbClient.safePut(this.TABLE_NAME, identityCache);
-    };
-    updateIdentityCache = async (identityId, request, response) => {
-        const cachedIdentity = await this.getIdentityCache(identityId);
-        if (cachedIdentity) {
-            cachedIdentity.request = request;
-            cachedIdentity.response = response;
-            cachedIdentity.updatedAt = getCurrentTimestamp();
-            await DynamoDbClient.safePut(this.TABLE_NAME, cachedIdentity);
-        }
-        else {
-            await this.putIdentityCache(identityId, request, response);
-        }
-    };
-    getIdentityCache = async (identityId) => {
-        return await DynamoDbClient.safeGet(this.TABLE_NAME, this.TABLE_KEY, identityId);
-    };
-    deleteIdentityCache = async (identityId) => {
-        return await DynamoDbClient.safeDelete(this.TABLE_NAME, this.TABLE_KEY, identityId);
-    };
-}
+import { DateTime } from 'luxon';
+import { DynamoDbClient, IdentityClient } from '../../clients';
+import { getCurrentTimestamp } from '../../libs';
+import { hasNewAddress, hasNewIncomingClickInfo, hasNewTrait } from '@adtrackify/at-shared-utils';
+import { Logger } from '../../helpers';
+const DEFAULT_CACHE_TTL_IN_MONTHS = 6;
+export class IdentityCacheDbService {
+    TABLE_NAME;
+    TABLE_KEY;
+    TTL_IN_MONTHS;
+    identityClient;
+    constructor(tableName, tableKey, baseApiUrl, cacheTtlInMonths) {
+        this.TABLE_NAME = tableName;
+        this.TABLE_KEY = tableKey;
+        if (cacheTtlInMonths) {
+            this.TTL_IN_MONTHS = cacheTtlInMonths;
+        }
+        else {
+            this.TTL_IN_MONTHS = DEFAULT_CACHE_TTL_IN_MONTHS;
+        }
+        this.identityClient = new IdentityClient(baseApiUrl);
+    }
+    getIdentityWithCaching = async (pixelId, identityId, incomingIdentity, cacheExpiryInSeconds) => {
+        const cachedIdentity = await this.getIdentityCache(identityId);
+        let resolvedIdentity = cachedIdentity?.response;
+        if (!cachedIdentity) {
+            resolvedIdentity = await this.identityClient.getIdentity(pixelId, { identity: incomingIdentity });
+        }
+        else if (cachedIdentity) {
+            let hasExpired = false;
+            if (cacheExpiryInSeconds) {
+                const updatedAt = DateTime.fromISO(cachedIdentity.updatedAt);
+                const currentTime = DateTime.now();
+                const timeSinceLastUpdate = currentTime.diff(updatedAt, 'seconds').toObject().seconds;
+                hasExpired = (timeSinceLastUpdate && (timeSinceLastUpdate > cacheExpiryInSeconds)) || false;
+            }
+            if (hasExpired) {
+                Logger.warn('Cache expired based on custom expiry time', { cachedIdentity });
+                resolvedIdentity = await this.identityClient.getIdentity(pixelId, { identity: incomingIdentity });
+            }
+            else if (this.isIdentityCacheStale(cachedIdentity, incomingIdentity)) {
+                Logger.debug('identity cache miss - record exists but stale', { cachedIdentity, incomingIdentity });
+                resolvedIdentity = await this.identityClient.getIdentity(pixelId, { identity: incomingIdentity });
+            }
+        }
+        await this.updateIdentityCache(identityId, incomingIdentity, resolvedIdentity);
+        return resolvedIdentity;
+    };
+    updateIdentityCache = async (identityId, request, response) => {
+        const identityCacheKeys = [identityId];
+        if (request?.identityId && identityCacheKeys.indexOf(request?.identityId) === -1) {
+            identityCacheKeys.push(request?.identityId);
+        }
+        if (response?.identityId && identityCacheKeys.indexOf(response?.identityId) === -1) {
+            identityCacheKeys.push(response?.identityId);
+        }
+        for (let i = 0; i < identityCacheKeys.length; i++) {
+            let cachedIdentity = await this.getIdentityCache(identityCacheKeys[i]);
+            if (cachedIdentity) {
+                cachedIdentity.request = request;
+                cachedIdentity.response = response;
+                cachedIdentity.updatedAt = getCurrentTimestamp();
+                cachedIdentity.expiresAt = DateTime.now().plus({ months: this.TTL_IN_MONTHS }).toSeconds();
+                await this.putIdentityCache(cachedIdentity);
+            }
+            else {
+                cachedIdentity = {
+                    identityId: identityCacheKeys[i],
+                    request,
+                    response,
+                    createdAt: getCurrentTimestamp(),
+                    updatedAt: getCurrentTimestamp(),
+                    expiresAt: DateTime.now().plus({ months: this.TTL_IN_MONTHS }).toSeconds()
+                };
+                await this.putIdentityCache(cachedIdentity);
+            }
+        }
+    };
+    putIdentityCache = async (identityCache) => {
+        return await DynamoDbClient.safePut(this.TABLE_NAME, identityCache);
+    };
+    getIdentityCache = async (identityId) => {
+        return await DynamoDbClient.safeGet(this.TABLE_NAME, this.TABLE_KEY, identityId);
+    };
+    deleteIdentityCache = async (identityId) => {
+        return await DynamoDbClient.safeDelete(this.TABLE_NAME, this.TABLE_KEY, identityId);
+    };
+    isIdentityCacheStale(identityCache, incomingIdentity) {
+        try {
+            const cachedTraits = identityCache.response?.traits ?? {};
+            const incomingTraits = incomingIdentity?.traits ?? {};
+            const isNewUserIds = hasNewTrait(cachedTraits?.userIds ?? [], incomingTraits?.userIds ?? []);
+            if (isNewUserIds) {
+                Logger.warn('identity cache miss - userIds changed', { cachedTraits, incomingTraits });
+                return true;
+            }
+            const isNewIds = hasNewTrait(cachedTraits?.ids ?? [], incomingTraits?.ids ?? []);
+            if (isNewIds) {
+                Logger.warn('identity cache miss - ids changed', { cachedTraits, incomingTraits });
+                return true;
+            }
+            const isNewEmails = hasNewTrait(cachedTraits?.emails ?? [], incomingTraits?.emails ?? []);
+            if (isNewEmails) {
+                Logger.warn('identity cache miss - emails changed', { cachedTraits, incomingTraits });
+                return true;
+            }
+            const isNewPhones = hasNewTrait(cachedTraits?.phones ?? [], incomingTraits?.phones ?? []);
+            if (isNewPhones) {
+                Logger.warn('identity cache miss - phones changed', { cachedTraits, incomingTraits });
+                return true;
+            }
+            const isNewShopifyYIds = hasNewTrait(cachedTraits?.shopifyYIds ?? [], incomingTraits?.shopifyYIds ?? []);
+            if (isNewShopifyYIds) {
+                Logger.warn('identity cache miss - shopify Y ids changed', { cachedTraits, incomingTraits });
+                return true;
+            }
+            const isNewGenders = hasNewTrait(cachedTraits?.genders ?? [], incomingTraits?.genders ?? []);
+            if (isNewGenders) {
+                Logger.warn('identity cache miss - genders changed', { cachedTraits, incomingTraits });
+                return true;
+            }
+            const isNewDobs = hasNewTrait(cachedTraits?.dobs ?? [], incomingTraits?.dobs ?? []);
+            if (isNewDobs) {
+                Logger.warn('identity cache miss - dobs changed', { cachedTraits, incomingTraits });
+                return true;
+            }
+            const isNewAddress = hasNewAddress(cachedTraits?.addresses ?? [], incomingTraits?.addresses ?? []);
+            if (isNewAddress) {
+                Logger.warn('identity cache miss - address changed', { cachedTraits, incomingTraits });
+                return true;
+            }
+            const isNewClick = hasNewIncomingClickInfo(cachedTraits?.click ?? {}, incomingTraits?.click ?? {});
+            if (isNewClick) {
+                Logger.warn('identity cache miss - clickInfos changed', { cachedTraits, incomingTraits });
+                return true;
+            }
+            if ((incomingTraits?.ipAddress && cachedTraits?.ipAddress !== incomingTraits?.ipAddress) || (incomingTraits?.userAgent && cachedTraits?.userAgent !== incomingTraits?.userAgent)) {
+                Logger.warn('identity cache miss - ip/userAgent changed', { cachedTraits, incomingTraits });
+                return true;
+            }
+            return false;
+        }
+        catch (error) {
+            Logger.error('Error while checking if identity cache is stale', { error });
+            return true;
+        }
+    }
+}
 //# sourceMappingURL=identity-cache-db-service.js.map