@adtrackify/at-service-common 3.1.48 → 3.1.49

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

@@ -1,58 +1,58 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DestinationsDbService = void 0;
-const clients_1 = require("../../clients");
-class DestinationsDbService {
-    TABLE_NAME;
-    constructor(tableName) {
-        this.TABLE_NAME = tableName;
-    }
-    getDestinationById = async (id) => {
-        const query = {
-            TableName: this.TABLE_NAME,
-            Key: {
-                id
-            },
-        };
-        const destination = await clients_1.DynamoDbClient.get(query);
-        return destination?.Item ?? null;
-    };
-    getDestinationsByPixel = async (indexName, pixelId) => {
-        const query = {
-            TableName: this.TABLE_NAME,
-            IndexName: indexName,
-            KeyConditionExpression: 'pixelId = :pixelId',
-            ExpressionAttributeValues: {
-                ':pixelId': pixelId,
-            },
-        };
-        const destinations = await clients_1.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 clients_1.DynamoDbClient.queryAll(query);
-        return destinations || [];
-    };
-    getDestinationsByDestinationType = async (indexName, destinationType) => {
-        const query = {
-            TableName: this.TABLE_NAME,
-            IndexName: indexName,
-            KeyConditionExpression: 'destinationType = :destinationType',
-            ExpressionAttributeValues: {
-                ':destinationType': destinationType
-            }
-        };
-        const destinations = await clients_1.DynamoDbClient.queryAll(query);
-        return destinations || [];
-    };
-}
-exports.DestinationsDbService = DestinationsDbService;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DestinationsDbService = void 0;
+const clients_1 = require("../../clients");
+class DestinationsDbService {
+    TABLE_NAME;
+    constructor(tableName) {
+        this.TABLE_NAME = tableName;
+    }
+    getDestinationById = async (id) => {
+        const query = {
+            TableName: this.TABLE_NAME,
+            Key: {
+                id
+            },
+        };
+        const destination = await clients_1.DynamoDbClient.get(query);
+        return destination?.Item ?? null;
+    };
+    getDestinationsByPixel = async (indexName, pixelId) => {
+        const query = {
+            TableName: this.TABLE_NAME,
+            IndexName: indexName,
+            KeyConditionExpression: 'pixelId = :pixelId',
+            ExpressionAttributeValues: {
+                ':pixelId': pixelId,
+            },
+        };
+        const destinations = await clients_1.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 clients_1.DynamoDbClient.queryAll(query);
+        return destinations || [];
+    };
+    getDestinationsByDestinationType = async (indexName, destinationType) => {
+        const query = {
+            TableName: this.TABLE_NAME,
+            IndexName: indexName,
+            KeyConditionExpression: 'destinationType = :destinationType',
+            ExpressionAttributeValues: {
+                ':destinationType': destinationType
+            }
+        };
+        const destinations = await clients_1.DynamoDbClient.queryAll(query);
+        return destinations || [];
+    };
+}
+exports.DestinationsDbService = DestinationsDbService;
 //# sourceMappingURL=destinations-db-service.js.map

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

@@ -1,24 +1,24 @@
-import { EventIdentity } from '@adtrackify/at-tracking-event-types';
-export interface IdentityCache {
-    identityId: string;
-    request?: EventIdentity;
-    response: EventIdentity;
-    createdAt?: string;
-    updatedAt: string;
-    expiresAt?: number;
-}
-export declare class IdentityCacheDbService {
-    private cacheLambdaClient;
-    private identifyPrivateLambdaArn;
-    private lambdaInvokeClient;
-    constructor(cacheLambdaFunctionArn: string, identifyPrivateLambdaArn: string);
-    getIdentityWithCaching: (pixelId: string, incomingIdentity?: EventIdentity) => Promise<EventIdentity | undefined>;
-    updateIdentityCacheRedis: (pixelId: string, request: EventIdentity, response: EventIdentity) => Promise<import("../../clients").CacheRequestCommandResponse[] | undefined>;
-    private getIdentityCache;
-    getIdentityFromCache(pixelId: string, incomingIdentity: EventIdentity): Promise<{
-        resolvedIdentity: EventIdentity | undefined;
-        updateCache: boolean;
-    }>;
-    deleteIdentityCache(pixelId: string, incomingIdentity: EventIdentity, resolvedIdentity: EventIdentity): Promise<void>;
-    private deleteIdentityCacheRedis;
-}
+import { EventIdentity } from '@adtrackify/at-tracking-event-types';
+export interface IdentityCache {
+    identityId: string;
+    request?: EventIdentity;
+    response: EventIdentity;
+    createdAt?: string;
+    updatedAt: string;
+    expiresAt?: number;
+}
+export declare class IdentityCacheDbService {
+    private cacheLambdaClient;
+    private identifyPrivateLambdaArn;
+    private lambdaInvokeClient;
+    constructor(cacheLambdaFunctionArn: string, identifyPrivateLambdaArn: string);
+    getIdentityWithCaching: (pixelId: string, incomingIdentity?: EventIdentity) => Promise<EventIdentity | undefined>;
+    updateIdentityCacheRedis: (pixelId: string, request: EventIdentity, response: EventIdentity) => Promise<import("../../clients").CacheRequestCommandResponse[] | undefined>;
+    private getIdentityCache;
+    getIdentityFromCache(pixelId: string, incomingIdentity: EventIdentity): Promise<{
+        resolvedIdentity: EventIdentity | undefined;
+        updateCache: boolean;
+    }>;
+    deleteIdentityCache(pixelId: string, incomingIdentity: EventIdentity, resolvedIdentity: EventIdentity): Promise<void>;
+    private deleteIdentityCacheRedis;
+}

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

@@ -1,234 +1,234 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.IdentityCacheDbService = void 0;
-const clients_1 = require("../../clients");
-const libs_1 = require("../../libs");
-const helpers_1 = require("../../helpers");
-const identity_cache_helper_1 = require("../../helpers/identity-cache-helper");
-const IDENTITY_CACHE_TTL_IN_SECONDS = 60 * 60 * 24 * 30 * 6;
-class IdentityCacheDbService {
-    cacheLambdaClient;
-    identifyPrivateLambdaArn;
-    lambdaInvokeClient;
-    constructor(cacheLambdaFunctionArn, identifyPrivateLambdaArn) {
-        this.cacheLambdaClient = new clients_1.CacheLambdaClient(cacheLambdaFunctionArn);
-        this.identifyPrivateLambdaArn = identifyPrivateLambdaArn;
-        this.lambdaInvokeClient = new clients_1.LambdaInvokeClient();
-    }
-    getIdentityWithCaching = async (pixelId, incomingIdentity = {}) => {
-        try {
-            if (!pixelId || !incomingIdentity) {
-                helpers_1.Logger.error('getIdentityWithCaching -No pixelId or incomingIdentity', { pixelId, incomingIdentity });
-                return undefined;
-            }
-            let { resolvedIdentity, updateCache } = await this.getIdentityFromCache(pixelId, incomingIdentity);
-            if (!resolvedIdentity) {
-                helpers_1.Logger.debug('identity cache miss - fetching from identity service', { incomingIdentity });
-                const response = await this.lambdaInvokeClient.invokeFunction(this.identifyPrivateLambdaArn, { pixelId, context: { identity: incomingIdentity } });
-                if (response?.statusCode === 200 && response?.body) {
-                    const identifyResponse = JSON.parse(response.body);
-                    resolvedIdentity = identifyResponse?.identity;
-                    updateCache = true;
-                }
-                else {
-                    helpers_1.Logger.error('Failed to getIdentity from identifyPrivateLambda', { response, pixelId, incomingIdentity, identifyPrivateLambdaArn: this.identifyPrivateLambdaArn });
-                }
-            }
-            else {
-                helpers_1.Logger.debug('identity cache hit', { incomingIdentity });
-            }
-            if (updateCache && resolvedIdentity) {
-                await this.updateIdentityCacheRedis(pixelId, incomingIdentity, resolvedIdentity);
-            }
-            if (!resolvedIdentity) {
-                helpers_1.Logger.error('No identity found', { pixelId, incomingIdentity });
-            }
-            return resolvedIdentity;
-        }
-        catch (error) {
-            helpers_1.Logger.error('Error while getting identity with caching', { error });
-            return undefined;
-        }
-    };
-    updateIdentityCacheRedis = async (pixelId, request, response) => {
-        if (!response || !response.identityId || !pixelId) {
-            return;
-        }
-        const identityCache = {
-            identityId: response.identityId,
-            response,
-            updatedAt: (0, libs_1.getCurrentTimestamp)(),
-        };
-        const setCacheCommands = [];
-        const cacheKey = `identId_${pixelId}_${response.identityId}`;
-        setCacheCommands.push({
-            cacheKey,
-            commandType: 'set',
-            data: JSON.stringify(identityCache),
-            expires: IDENTITY_CACHE_TTL_IN_SECONDS,
-        });
-        if (request?.identityId) {
-            const cacheKey = `identId_${pixelId}_${request.identityId}`;
-            setCacheCommands.push({
-                cacheKey,
-                commandType: 'set',
-                data: JSON.stringify(identityCache),
-                expires: IDENTITY_CACHE_TTL_IN_SECONDS,
-            });
-        }
-        if (response?.traits?.emails && response?.traits?.emails?.length > 0) {
-            for (let i = 0; i < response.traits.emails.length; i++) {
-                const cacheKey = `identEmail_${pixelId}_${response.traits.emails[i]}`;
-                setCacheCommands.push({
-                    cacheKey,
-                    commandType: 'set',
-                    data: JSON.stringify(identityCache),
-                    expires: IDENTITY_CACHE_TTL_IN_SECONDS,
-                });
-            }
-        }
-        if (response?.traits?.userIds && response?.traits?.userIds?.length > 0) {
-            for (let i = 0; i < response.traits.userIds.length; i++) {
-                const cacheKey = `identUserId_${pixelId}_${response.traits.userIds[i]}`;
-                setCacheCommands.push({
-                    cacheKey,
-                    commandType: 'set',
-                    data: JSON.stringify(identityCache),
-                    expires: IDENTITY_CACHE_TTL_IN_SECONDS,
-                });
-            }
-        }
-        const start = performance.now();
-        const res = await this.cacheLambdaClient.batchInvoke(setCacheCommands);
-        const end = performance.now();
-        helpers_1.Logger.debug('updated identity cache', { res, duration: end - start });
-        return res;
-    };
-    getIdentityCache = async (cacheKey) => {
-        const start = performance.now();
-        const cacheResponse = await this.cacheLambdaClient.invokeGet(cacheKey);
-        const end = performance.now();
-        helpers_1.Logger.debug('getIdentityCache', { cacheKey, cacheResponse, duration: end - start });
-        if (cacheResponse && cacheResponse.responseData) {
-            return cacheResponse.responseData;
-        }
-        return undefined;
-    };
-    async getIdentityFromCache(pixelId, incomingIdentity) {
-        try {
-            if (!pixelId || !incomingIdentity) {
-                return { resolvedIdentity: undefined, updateCache: false };
-            }
-            let updateCache = false;
-            let resolvedIdentity;
-            if (incomingIdentity?.identityId) {
-                const cacheKey = `identId_${pixelId}_${incomingIdentity.identityId}`;
-                helpers_1.Logger.debug(' try lookup with identityId', { cacheKey });
-                const cachedIdentity = await this.getIdentityCache(cacheKey);
-                if (cachedIdentity) {
-                    helpers_1.Logger.debug(' found cached identity', { cacheKey, cachedIdentity });
-                    if (!(0, identity_cache_helper_1.isIdentityCacheStale)(cachedIdentity, incomingIdentity)) {
-                        helpers_1.Logger.debug('cache not stale', { cacheKey, cachedIdentity });
-                        resolvedIdentity = cachedIdentity.response;
-                    }
-                }
-            }
-            if (!resolvedIdentity && incomingIdentity?.traits?.emails && incomingIdentity?.traits?.emails?.length > 0) {
-                for (let i = 0; i < incomingIdentity.traits.emails.length; i++) {
-                    const cacheKey = `identEmail_${pixelId}_${incomingIdentity.traits.emails[i]}`;
-                    helpers_1.Logger.debug(' try lookup with email', { cacheKey });
-                    const cachedIdentity = await this.getIdentityCache(cacheKey);
-                    if (cachedIdentity) {
-                        helpers_1.Logger.debug(' found cached identity', { cacheKey, cachedIdentity });
-                        if (!(0, identity_cache_helper_1.isIdentityCacheStale)(cachedIdentity, incomingIdentity)) {
-                            helpers_1.Logger.debug('cache not stale', { cacheKey, cachedIdentity });
-                            resolvedIdentity = cachedIdentity.response;
-                            updateCache = true;
-                            break;
-                        }
-                    }
-                }
-            }
-            if (!resolvedIdentity && incomingIdentity?.traits?.userIds && incomingIdentity?.traits?.userIds?.length > 0) {
-                for (let i = 0; i < incomingIdentity.traits.userIds.length; i++) {
-                    const cacheKey = `identUserId_${pixelId}_${incomingIdentity.traits.userIds[i]}`;
-                    helpers_1.Logger.debug(' try lookup with userId', { cacheKey });
-                    const cachedIdentity = await this.getIdentityCache(cacheKey);
-                    if (cachedIdentity) {
-                        helpers_1.Logger.debug(' found cached identity', { cacheKey, cachedIdentity });
-                        if (!(0, identity_cache_helper_1.isIdentityCacheStale)(cachedIdentity, incomingIdentity)) {
-                            helpers_1.Logger.debug('cache not stale', { cacheKey, cachedIdentity });
-                            resolvedIdentity = cachedIdentity.response;
-                            updateCache = true;
-                            break;
-                        }
-                    }
-                }
-            }
-            return { resolvedIdentity, updateCache };
-        }
-        catch (err) {
-            helpers_1.Logger.error('Error while getting identity from cache', { err });
-            return { resolvedIdentity: undefined, updateCache: false };
-        }
-    }
-    async deleteIdentityCache(pixelId, incomingIdentity, resolvedIdentity) {
-        await this.deleteIdentityCacheRedis(pixelId, incomingIdentity, resolvedIdentity);
-    }
-    async deleteIdentityCacheRedis(pixelId, incomingIdentity, resolvedIdentity) {
-        try {
-            if (!pixelId) {
-                return;
-            }
-            const deleteCacheCommands = [];
-            if (incomingIdentity?.traits?.emails && incomingIdentity?.traits?.emails?.length > 0) {
-                const cmds = incomingIdentity.traits.emails.map(email => ({
-                    cacheKey: `identEmail_${pixelId}_${email}`,
-                    commandType: 'delete',
-                }));
-                deleteCacheCommands.push(...cmds);
-            }
-            if (incomingIdentity?.traits?.userIds && incomingIdentity?.traits?.userIds.length > 0) {
-                const cmds = incomingIdentity.traits.userIds.map(userId => ({
-                    cacheKey: `identUserId_${pixelId}_${userId}`,
-                    commandType: 'delete',
-                }));
-                deleteCacheCommands.push(...cmds);
-            }
-            if (incomingIdentity?.identityId) {
-                deleteCacheCommands.push({
-                    cacheKey: `identId_${pixelId}_${incomingIdentity.identityId}`,
-                    commandType: 'delete',
-                });
-            }
-            if (resolvedIdentity?.traits?.emails && resolvedIdentity?.traits?.emails.length > 0) {
-                const cmds = resolvedIdentity.traits.emails.map(email => ({
-                    cacheKey: `identEmail_${pixelId}_${email}`,
-                    commandType: 'delete',
-                }));
-                deleteCacheCommands.push(...cmds);
-            }
-            if (resolvedIdentity?.traits?.userIds && resolvedIdentity?.traits?.userIds.length > 0) {
-                const cmds = resolvedIdentity.traits.userIds.map(userId => ({
-                    cacheKey: `identUserId_${pixelId}_${userId}`,
-                    commandType: 'delete',
-                }));
-                deleteCacheCommands.push(...cmds);
-            }
-            if (resolvedIdentity?.identityId) {
-                deleteCacheCommands.push({
-                    cacheKey: `identId_${pixelId}_${resolvedIdentity.identityId}`,
-                    commandType: 'delete',
-                });
-            }
-            if (deleteCacheCommands.length > 0) {
-                await this.cacheLambdaClient.batchInvoke(deleteCacheCommands);
-            }
-        }
-        catch (err) {
-            helpers_1.Logger.error('Error while deleting identity cache', { err });
-        }
-    }
-}
-exports.IdentityCacheDbService = IdentityCacheDbService;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IdentityCacheDbService = void 0;
+const clients_1 = require("../../clients");
+const libs_1 = require("../../libs");
+const helpers_1 = require("../../helpers");
+const identity_cache_helper_1 = require("../../helpers/identity-cache-helper");
+const IDENTITY_CACHE_TTL_IN_SECONDS = 60 * 60 * 24 * 30 * 6;
+class IdentityCacheDbService {
+    cacheLambdaClient;
+    identifyPrivateLambdaArn;
+    lambdaInvokeClient;
+    constructor(cacheLambdaFunctionArn, identifyPrivateLambdaArn) {
+        this.cacheLambdaClient = new clients_1.CacheLambdaClient(cacheLambdaFunctionArn);
+        this.identifyPrivateLambdaArn = identifyPrivateLambdaArn;
+        this.lambdaInvokeClient = new clients_1.LambdaInvokeClient();
+    }
+    getIdentityWithCaching = async (pixelId, incomingIdentity = {}) => {
+        try {
+            if (!pixelId || !incomingIdentity) {
+                helpers_1.Logger.error('getIdentityWithCaching -No pixelId or incomingIdentity', { pixelId, incomingIdentity });
+                return undefined;
+            }
+            let { resolvedIdentity, updateCache } = await this.getIdentityFromCache(pixelId, incomingIdentity);
+            if (!resolvedIdentity) {
+                helpers_1.Logger.debug('identity cache miss - fetching from identity service', { incomingIdentity });
+                const response = await this.lambdaInvokeClient.invokeFunction(this.identifyPrivateLambdaArn, { pixelId, context: { identity: incomingIdentity } });
+                if (response?.statusCode === 200 && response?.body) {
+                    const identifyResponse = JSON.parse(response.body);
+                    resolvedIdentity = identifyResponse?.identity;
+                    updateCache = true;
+                }
+                else {
+                    helpers_1.Logger.error('Failed to getIdentity from identifyPrivateLambda', { response, pixelId, incomingIdentity, identifyPrivateLambdaArn: this.identifyPrivateLambdaArn });
+                }
+            }
+            else {
+                helpers_1.Logger.debug('identity cache hit', { incomingIdentity });
+            }
+            if (updateCache && resolvedIdentity) {
+                await this.updateIdentityCacheRedis(pixelId, incomingIdentity, resolvedIdentity);
+            }
+            if (!resolvedIdentity) {
+                helpers_1.Logger.error('No identity found', { pixelId, incomingIdentity });
+            }
+            return resolvedIdentity;
+        }
+        catch (error) {
+            helpers_1.Logger.error('Error while getting identity with caching', { error });
+            return undefined;
+        }
+    };
+    updateIdentityCacheRedis = async (pixelId, request, response) => {
+        if (!response || !response.identityId || !pixelId) {
+            return;
+        }
+        const identityCache = {
+            identityId: response.identityId,
+            response,
+            updatedAt: (0, libs_1.getCurrentTimestamp)(),
+        };
+        const setCacheCommands = [];
+        const cacheKey = `identId_${pixelId}_${response.identityId}`;
+        setCacheCommands.push({
+            cacheKey,
+            commandType: 'set',
+            data: JSON.stringify(identityCache),
+            expires: IDENTITY_CACHE_TTL_IN_SECONDS,
+        });
+        if (request?.identityId) {
+            const cacheKey = `identId_${pixelId}_${request.identityId}`;
+            setCacheCommands.push({
+                cacheKey,
+                commandType: 'set',
+                data: JSON.stringify(identityCache),
+                expires: IDENTITY_CACHE_TTL_IN_SECONDS,
+            });
+        }
+        if (response?.traits?.emails && response?.traits?.emails?.length > 0) {
+            for (let i = 0; i < response.traits.emails.length; i++) {
+                const cacheKey = `identEmail_${pixelId}_${response.traits.emails[i]}`;
+                setCacheCommands.push({
+                    cacheKey,
+                    commandType: 'set',
+                    data: JSON.stringify(identityCache),
+                    expires: IDENTITY_CACHE_TTL_IN_SECONDS,
+                });
+            }
+        }
+        if (response?.traits?.userIds && response?.traits?.userIds?.length > 0) {
+            for (let i = 0; i < response.traits.userIds.length; i++) {
+                const cacheKey = `identUserId_${pixelId}_${response.traits.userIds[i]}`;
+                setCacheCommands.push({
+                    cacheKey,
+                    commandType: 'set',
+                    data: JSON.stringify(identityCache),
+                    expires: IDENTITY_CACHE_TTL_IN_SECONDS,
+                });
+            }
+        }
+        const start = performance.now();
+        const res = await this.cacheLambdaClient.batchInvoke(setCacheCommands);
+        const end = performance.now();
+        helpers_1.Logger.debug('updated identity cache', { res, duration: end - start });
+        return res;
+    };
+    getIdentityCache = async (cacheKey) => {
+        const start = performance.now();
+        const cacheResponse = await this.cacheLambdaClient.invokeGet(cacheKey);
+        const end = performance.now();
+        helpers_1.Logger.debug('getIdentityCache', { cacheKey, cacheResponse, duration: end - start });
+        if (cacheResponse && cacheResponse.responseData) {
+            return cacheResponse.responseData;
+        }
+        return undefined;
+    };
+    async getIdentityFromCache(pixelId, incomingIdentity) {
+        try {
+            if (!pixelId || !incomingIdentity) {
+                return { resolvedIdentity: undefined, updateCache: false };
+            }
+            let updateCache = false;
+            let resolvedIdentity;
+            if (incomingIdentity?.identityId) {
+                const cacheKey = `identId_${pixelId}_${incomingIdentity.identityId}`;
+                helpers_1.Logger.debug(' try lookup with identityId', { cacheKey });
+                const cachedIdentity = await this.getIdentityCache(cacheKey);
+                if (cachedIdentity) {
+                    helpers_1.Logger.debug(' found cached identity', { cacheKey, cachedIdentity });
+                    if (!(0, identity_cache_helper_1.isIdentityCacheStale)(cachedIdentity, incomingIdentity)) {
+                        helpers_1.Logger.debug('cache not stale', { cacheKey, cachedIdentity });
+                        resolvedIdentity = cachedIdentity.response;
+                    }
+                }
+            }
+            if (!resolvedIdentity && incomingIdentity?.traits?.emails && incomingIdentity?.traits?.emails?.length > 0) {
+                for (let i = 0; i < incomingIdentity.traits.emails.length; i++) {
+                    const cacheKey = `identEmail_${pixelId}_${incomingIdentity.traits.emails[i]}`;
+                    helpers_1.Logger.debug(' try lookup with email', { cacheKey });
+                    const cachedIdentity = await this.getIdentityCache(cacheKey);
+                    if (cachedIdentity) {
+                        helpers_1.Logger.debug(' found cached identity', { cacheKey, cachedIdentity });
+                        if (!(0, identity_cache_helper_1.isIdentityCacheStale)(cachedIdentity, incomingIdentity)) {
+                            helpers_1.Logger.debug('cache not stale', { cacheKey, cachedIdentity });
+                            resolvedIdentity = cachedIdentity.response;
+                            updateCache = true;
+                            break;
+                        }
+                    }
+                }
+            }
+            if (!resolvedIdentity && incomingIdentity?.traits?.userIds && incomingIdentity?.traits?.userIds?.length > 0) {
+                for (let i = 0; i < incomingIdentity.traits.userIds.length; i++) {
+                    const cacheKey = `identUserId_${pixelId}_${incomingIdentity.traits.userIds[i]}`;
+                    helpers_1.Logger.debug(' try lookup with userId', { cacheKey });
+                    const cachedIdentity = await this.getIdentityCache(cacheKey);
+                    if (cachedIdentity) {
+                        helpers_1.Logger.debug(' found cached identity', { cacheKey, cachedIdentity });
+                        if (!(0, identity_cache_helper_1.isIdentityCacheStale)(cachedIdentity, incomingIdentity)) {
+                            helpers_1.Logger.debug('cache not stale', { cacheKey, cachedIdentity });
+                            resolvedIdentity = cachedIdentity.response;
+                            updateCache = true;
+                            break;
+                        }
+                    }
+                }
+            }
+            return { resolvedIdentity, updateCache };
+        }
+        catch (err) {
+            helpers_1.Logger.error('Error while getting identity from cache', { err });
+            return { resolvedIdentity: undefined, updateCache: false };
+        }
+    }
+    async deleteIdentityCache(pixelId, incomingIdentity, resolvedIdentity) {
+        await this.deleteIdentityCacheRedis(pixelId, incomingIdentity, resolvedIdentity);
+    }
+    async deleteIdentityCacheRedis(pixelId, incomingIdentity, resolvedIdentity) {
+        try {
+            if (!pixelId) {
+                return;
+            }
+            const deleteCacheCommands = [];
+            if (incomingIdentity?.traits?.emails && incomingIdentity?.traits?.emails?.length > 0) {
+                const cmds = incomingIdentity.traits.emails.map(email => ({
+                    cacheKey: `identEmail_${pixelId}_${email}`,
+                    commandType: 'delete',
+                }));
+                deleteCacheCommands.push(...cmds);
+            }
+            if (incomingIdentity?.traits?.userIds && incomingIdentity?.traits?.userIds.length > 0) {
+                const cmds = incomingIdentity.traits.userIds.map(userId => ({
+                    cacheKey: `identUserId_${pixelId}_${userId}`,
+                    commandType: 'delete',
+                }));
+                deleteCacheCommands.push(...cmds);
+            }
+            if (incomingIdentity?.identityId) {
+                deleteCacheCommands.push({
+                    cacheKey: `identId_${pixelId}_${incomingIdentity.identityId}`,
+                    commandType: 'delete',
+                });
+            }
+            if (resolvedIdentity?.traits?.emails && resolvedIdentity?.traits?.emails.length > 0) {
+                const cmds = resolvedIdentity.traits.emails.map(email => ({
+                    cacheKey: `identEmail_${pixelId}_${email}`,
+                    commandType: 'delete',
+                }));
+                deleteCacheCommands.push(...cmds);
+            }
+            if (resolvedIdentity?.traits?.userIds && resolvedIdentity?.traits?.userIds.length > 0) {
+                const cmds = resolvedIdentity.traits.userIds.map(userId => ({
+                    cacheKey: `identUserId_${pixelId}_${userId}`,
+                    commandType: 'delete',
+                }));
+                deleteCacheCommands.push(...cmds);
+            }
+            if (resolvedIdentity?.identityId) {
+                deleteCacheCommands.push({
+                    cacheKey: `identId_${pixelId}_${resolvedIdentity.identityId}`,
+                    commandType: 'delete',
+                });
+            }
+            if (deleteCacheCommands.length > 0) {
+                await this.cacheLambdaClient.batchInvoke(deleteCacheCommands);
+            }
+        }
+        catch (err) {
+            helpers_1.Logger.error('Error while deleting identity cache', { err });
+        }
+    }
+}
+exports.IdentityCacheDbService = IdentityCacheDbService;
 //# sourceMappingURL=identity-cache-db-service.js.map

package/dist/cjs/services/db/index.d.ts

@@ -1,7 +1,7 @@
-export * from './destinations-db-service.js';
-export * from './log-events-db-service.js';
-export * from './purchased-contacts-db-service.js';
-export * from './tracking-events-db-service.js';
-export * from './shopify-products-cache-db-service.js';
-export * from './shopify-app-installs-db-service.js';
-export * from './identity-cache-db-service.js';
+export * from './destinations-db-service.js';
+export * from './log-events-db-service.js';
+export * from './purchased-contacts-db-service.js';
+export * from './tracking-events-db-service.js';
+export * from './shopify-products-cache-db-service.js';
+export * from './shopify-app-installs-db-service.js';
+export * from './identity-cache-db-service.js';