@adtrackify/at-service-common 3.19.7 → 3.19.9

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

@@ -1,314 +1,314 @@
-import { CacheLambdaClient, LambdaInvokeClient } from '../../clients';
-import { getCurrentTimestamp } from '../../libs';
-import { Logger } from '../../helpers';
-import { isIdentityCacheStale } from '../../helpers/identity-cache-helper';
-import fastDeepEqual from 'fast-deep-equal';
-import { mergeIdentityTraits } from '@adtrackify/at-shared-utils';
-const IDENTITY_CACHE_TTL_IN_SECONDS = 60 * 60 * 24 * 30 * 6;
-export class IdentityCacheDbService {
-    cacheLambdaClient;
-    identifyPrivateLambdaArn;
-    lambdaInvokeClient;
-    constructor(cacheLambdaFunctionArn, identifyPrivateLambdaArn) {
-        this.cacheLambdaClient = new CacheLambdaClient(cacheLambdaFunctionArn);
-        this.identifyPrivateLambdaArn = identifyPrivateLambdaArn;
-        this.lambdaInvokeClient = new LambdaInvokeClient();
-    }
-    getIdentityWithCaching = async (pixelId, incomingIdentity = {}) => {
-        try {
-            if (!pixelId || !incomingIdentity) {
-                Logger.error('getIdentityWithCaching -No pixelId or incomingIdentity', { pixelId, incomingIdentity });
-                return undefined;
-            }
-            const cacheResponse = await this.getIdentityFromCache(pixelId, incomingIdentity);
-            let resolvedIdentity = cacheResponse?.resolvedIdentity;
-            const isCacheStale = cacheResponse?.isCacheStale;
-            if (resolvedIdentity && !isCacheStale) {
-                Logger.debug('identity cache hit', { incomingIdentity });
-                return resolvedIdentity;
-            }
-            Logger.debug('identity cache stale - fetching from identity service', { incomingIdentity });
-            const response = await this.identifyPrivateLambda(pixelId, incomingIdentity);
-            if (response?.resolvedIdentity) {
-                resolvedIdentity = response.resolvedIdentity;
-            }
-            else {
-                Logger.error('Failed to getIdentity from identifyPrivateLambda', {
-                    response,
-                    pixelId,
-                    incomingIdentity,
-                    identifyPrivateLambdaArn: this.identifyPrivateLambdaArn,
-                });
-            }
-            if (isCacheStale && resolvedIdentity) {
-                await this.updateIdentityCacheRedis(pixelId, incomingIdentity, resolvedIdentity);
-            }
-            if (!resolvedIdentity) {
-                Logger.error('No identity found', { pixelId, incomingIdentity });
-                resolvedIdentity = incomingIdentity;
-            }
-            return resolvedIdentity;
-        }
-        catch (error) {
-            Logger.error('Error while getting identity with caching', { error });
-            return undefined;
-        }
-    };
-    async identifyPrivateLambda(pixelId, incomingIdentity) {
-        try {
-            const response = await this.lambdaInvokeClient.invokeFunction(this.identifyPrivateLambdaArn, {
-                pixelId,
-                context: { identity: incomingIdentity },
-            });
-            if (response?.statusCode === 200 && response?.body) {
-                const identifyResponse = JSON.parse(response.body);
-                return { resolvedIdentity: identifyResponse?.identity };
-            }
-            return { resolvedIdentity: incomingIdentity };
-        }
-        catch (err) {
-            Logger.error('Error while identifying private lambda', { err });
-            return { resolvedIdentity: undefined };
-        }
-    }
-    async getIdentityFromCache(pixelId, incomingIdentity) {
-        try {
-            if (!pixelId || !incomingIdentity) {
-                return { resolvedIdentity: undefined, isCacheStale: true };
-            }
-            let isCacheStale = true;
-            let cachedIdentityResponse;
-            let cacheKey;
-            if (incomingIdentity?.identityId) {
-                cacheKey = `identId_${pixelId}_${incomingIdentity.identityId}`;
-                Logger.debug(' try lookup with identityId', { cacheKey });
-                cachedIdentityResponse = await this.getIdentityCache(cacheKey);
-                if (!cachedIdentityResponse) {
-                    return { resolvedIdentity: undefined, isCacheStale: true };
-                }
-            }
-            else {
-                cachedIdentityResponse = await this.getIdentityCacheFromSecondaryKeys(pixelId, incomingIdentity);
-                if (!cachedIdentityResponse) {
-                    return { resolvedIdentity: undefined, isCacheStale: true };
-                }
-            }
-            Logger.debug(' found cached identity', { cacheKey, cachedIdentityResponse });
-            const mergedTraits = mergeIdentityTraits(incomingIdentity.traits, cachedIdentityResponse.response.traits);
-            const mergedIdentity = { ...incomingIdentity, traits: mergedTraits };
-            const identityStaleCacheTracker = isIdentityCacheStale(cachedIdentityResponse.response, mergedIdentity);
-            const isDeepEqual = fastDeepEqual(cachedIdentityResponse.response, mergedIdentity);
-            isCacheStale = identityStaleCacheTracker.isCacheStale;
-            if (isDeepEqual) {
-                Logger.debug('identity cache is deep equal', {
-                    pixelId,
-                    incomingIdentity,
-                    cacheKey,
-                    cachedIdentityResponse,
-                    mergedIdentity,
-                    identityStaleCacheTracker,
-                    isCacheStale,
-                });
-                isCacheStale = false;
-            }
-            else {
-                Logger.debug('identity cache is not deep equal', {
-                    pixelId,
-                    incomingIdentity,
-                    cacheKey,
-                    cachedIdentityResponse,
-                    mergedIdentity,
-                    identityStaleCacheTracker,
-                    isCacheStale,
-                });
-            }
-            if (isCacheStale) {
-                Logger.debug('identity cache stale', {
-                    isCacheStale,
-                    isDeepEqual,
-                    pixelId,
-                    incomingIdentity,
-                    cacheKey,
-                    cachedIdentityResponse,
-                    mergedIdentity,
-                    identityStaleCacheTracker,
-                });
-            }
-            else {
-                Logger.debug('identity cache not stale', {
-                    isCacheStale,
-                    isDeepEqual,
-                    pixelId,
-                    incomingIdentity,
-                    cacheKey,
-                    cachedIdentityResponse,
-                    mergedIdentity,
-                    identityStaleCacheTracker,
-                });
-            }
-            return { resolvedIdentity: mergedIdentity, isCacheStale };
-        }
-        catch (err) {
-            Logger.error('Error while getting identity from cache', { err });
-            return { resolvedIdentity: undefined, isCacheStale: true };
-        }
-    }
-    async getIdentityCacheFromSecondaryKeys(pixelId, incomingIdentity) {
-        try {
-            if (!pixelId || !incomingIdentity) {
-                return undefined;
-            }
-            if (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]}`;
-                    Logger.debug(' try lookup with email', { cacheKey });
-                    const identityCache = await this.getIdentityCache(cacheKey);
-                    if (identityCache && identityCache?.response) {
-                        Logger.debug(' found cached identity', { cacheKey, identityCache });
-                        return identityCache;
-                    }
-                }
-            }
-            if (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]}`;
-                    Logger.debug(' try lookup with userId', { cacheKey });
-                    const identityCache = await this.getIdentityCache(cacheKey);
-                    if (identityCache && identityCache?.response) {
-                        Logger.debug(' found cached identity', { cacheKey, identityCache });
-                        return identityCache;
-                    }
-                }
-            }
-            return undefined;
-        }
-        catch (err) {
-            Logger.error('Error while getting identity from secondary keys', { err });
-            return undefined;
-        }
-    }
-    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) {
-            Logger.error('Error while deleting identity cache', { err });
-        }
-    }
-    getIdentityCache = async (cacheKey) => {
-        const start = performance.now();
-        const cacheResponse = await this.cacheLambdaClient.invokeGet(cacheKey);
-        const end = performance.now();
-        Logger.debug('getIdentityCache', { cacheKey, cacheResponse, duration: end - start });
-        if (cacheResponse && cacheResponse.responseData) {
-            return cacheResponse.responseData;
-        }
-        return undefined;
-    };
-    updateIdentityCacheRedis = async (pixelId, request, response, enableSecondaryCacheKeys = false) => {
-        if (!response || !response.identityId || !pixelId) {
-            return;
-        }
-        const identityCache = {
-            identityId: response.identityId,
-            response,
-            updatedAt: 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 && request.identityId !== response.identityId) {
-            const cacheKey = `identId_${pixelId}_${request.identityId}`;
-            setCacheCommands.push({
-                cacheKey,
-                commandType: 'set',
-                data: JSON.stringify(identityCache),
-                expires: IDENTITY_CACHE_TTL_IN_SECONDS,
-            });
-        }
-        if (enableSecondaryCacheKeys) {
-            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();
-        Logger.debug('updated identity cache', { res, duration: end - start });
-        return res;
-    };
-}
+import { CacheLambdaClient, LambdaInvokeClient } from '../../clients';
+import { getCurrentTimestamp } from '../../libs';
+import { Logger } from '../../helpers';
+import { isIdentityCacheStale } from '../../helpers/identity-cache-helper';
+import fastDeepEqual from 'fast-deep-equal';
+import { mergeIdentityTraits } from '@adtrackify/at-shared-utils';
+const IDENTITY_CACHE_TTL_IN_SECONDS = 60 * 60 * 24 * 30 * 6;
+export class IdentityCacheDbService {
+    cacheLambdaClient;
+    identifyPrivateLambdaArn;
+    lambdaInvokeClient;
+    constructor(cacheLambdaFunctionArn, identifyPrivateLambdaArn) {
+        this.cacheLambdaClient = new CacheLambdaClient(cacheLambdaFunctionArn);
+        this.identifyPrivateLambdaArn = identifyPrivateLambdaArn;
+        this.lambdaInvokeClient = new LambdaInvokeClient();
+    }
+    getIdentityWithCaching = async (pixelId, incomingIdentity = {}) => {
+        try {
+            if (!pixelId || !incomingIdentity) {
+                Logger.error('getIdentityWithCaching -No pixelId or incomingIdentity', { pixelId, incomingIdentity });
+                return undefined;
+            }
+            const cacheResponse = await this.getIdentityFromCache(pixelId, incomingIdentity);
+            let resolvedIdentity = cacheResponse?.resolvedIdentity;
+            const isCacheStale = cacheResponse?.isCacheStale;
+            if (resolvedIdentity && !isCacheStale) {
+                Logger.debug('identity cache hit', { incomingIdentity });
+                return resolvedIdentity;
+            }
+            Logger.debug('identity cache stale - fetching from identity service', { incomingIdentity });
+            const response = await this.identifyPrivateLambda(pixelId, incomingIdentity);
+            if (response?.resolvedIdentity) {
+                resolvedIdentity = response.resolvedIdentity;
+            }
+            else {
+                Logger.error('Failed to getIdentity from identifyPrivateLambda', {
+                    response,
+                    pixelId,
+                    incomingIdentity,
+                    identifyPrivateLambdaArn: this.identifyPrivateLambdaArn,
+                });
+            }
+            if (isCacheStale && resolvedIdentity) {
+                await this.updateIdentityCacheRedis(pixelId, incomingIdentity, resolvedIdentity);
+            }
+            if (!resolvedIdentity) {
+                Logger.error('No identity found', { pixelId, incomingIdentity });
+                resolvedIdentity = incomingIdentity;
+            }
+            return resolvedIdentity;
+        }
+        catch (error) {
+            Logger.error('Error while getting identity with caching', { error });
+            return undefined;
+        }
+    };
+    async identifyPrivateLambda(pixelId, incomingIdentity) {
+        try {
+            const response = await this.lambdaInvokeClient.invokeFunction(this.identifyPrivateLambdaArn, {
+                pixelId,
+                context: { identity: incomingIdentity },
+            });
+            if (response?.statusCode === 200 && response?.body) {
+                const identifyResponse = JSON.parse(response.body);
+                return { resolvedIdentity: identifyResponse?.identity };
+            }
+            return { resolvedIdentity: incomingIdentity };
+        }
+        catch (err) {
+            Logger.error('Error while identifying private lambda', { err });
+            return { resolvedIdentity: undefined };
+        }
+    }
+    async getIdentityFromCache(pixelId, incomingIdentity) {
+        try {
+            if (!pixelId || !incomingIdentity) {
+                return { resolvedIdentity: undefined, isCacheStale: true };
+            }
+            let isCacheStale = true;
+            let cachedIdentityResponse;
+            let cacheKey;
+            if (incomingIdentity?.identityId) {
+                cacheKey = `identId_${pixelId}_${incomingIdentity.identityId}`;
+                Logger.debug(' try lookup with identityId', { cacheKey });
+                cachedIdentityResponse = await this.getIdentityCache(cacheKey);
+                if (!cachedIdentityResponse) {
+                    return { resolvedIdentity: undefined, isCacheStale: true };
+                }
+            }
+            else {
+                cachedIdentityResponse = await this.getIdentityCacheFromSecondaryKeys(pixelId, incomingIdentity);
+                if (!cachedIdentityResponse) {
+                    return { resolvedIdentity: undefined, isCacheStale: true };
+                }
+            }
+            Logger.debug(' found cached identity', { cacheKey, cachedIdentityResponse });
+            const mergedTraits = mergeIdentityTraits(incomingIdentity.traits, cachedIdentityResponse.response.traits);
+            const mergedIdentity = { ...incomingIdentity, traits: mergedTraits };
+            const identityStaleCacheTracker = isIdentityCacheStale(cachedIdentityResponse.response, mergedIdentity);
+            const isDeepEqual = fastDeepEqual(cachedIdentityResponse.response, mergedIdentity);
+            isCacheStale = identityStaleCacheTracker.isCacheStale;
+            if (isDeepEqual) {
+                Logger.debug('identity cache is deep equal', {
+                    pixelId,
+                    incomingIdentity,
+                    cacheKey,
+                    cachedIdentityResponse,
+                    mergedIdentity,
+                    identityStaleCacheTracker,
+                    isCacheStale,
+                });
+                isCacheStale = false;
+            }
+            else {
+                Logger.debug('identity cache is not deep equal', {
+                    pixelId,
+                    incomingIdentity,
+                    cacheKey,
+                    cachedIdentityResponse,
+                    mergedIdentity,
+                    identityStaleCacheTracker,
+                    isCacheStale,
+                });
+            }
+            if (isCacheStale) {
+                Logger.debug('identity cache stale', {
+                    isCacheStale,
+                    isDeepEqual,
+                    pixelId,
+                    incomingIdentity,
+                    cacheKey,
+                    cachedIdentityResponse,
+                    mergedIdentity,
+                    identityStaleCacheTracker,
+                });
+            }
+            else {
+                Logger.debug('identity cache not stale', {
+                    isCacheStale,
+                    isDeepEqual,
+                    pixelId,
+                    incomingIdentity,
+                    cacheKey,
+                    cachedIdentityResponse,
+                    mergedIdentity,
+                    identityStaleCacheTracker,
+                });
+            }
+            return { resolvedIdentity: mergedIdentity, isCacheStale };
+        }
+        catch (err) {
+            Logger.error('Error while getting identity from cache', { err });
+            return { resolvedIdentity: undefined, isCacheStale: true };
+        }
+    }
+    async getIdentityCacheFromSecondaryKeys(pixelId, incomingIdentity) {
+        try {
+            if (!pixelId || !incomingIdentity) {
+                return undefined;
+            }
+            if (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]}`;
+                    Logger.debug(' try lookup with email', { cacheKey });
+                    const identityCache = await this.getIdentityCache(cacheKey);
+                    if (identityCache && identityCache?.response) {
+                        Logger.debug(' found cached identity', { cacheKey, identityCache });
+                        return identityCache;
+                    }
+                }
+            }
+            if (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]}`;
+                    Logger.debug(' try lookup with userId', { cacheKey });
+                    const identityCache = await this.getIdentityCache(cacheKey);
+                    if (identityCache && identityCache?.response) {
+                        Logger.debug(' found cached identity', { cacheKey, identityCache });
+                        return identityCache;
+                    }
+                }
+            }
+            return undefined;
+        }
+        catch (err) {
+            Logger.error('Error while getting identity from secondary keys', { err });
+            return undefined;
+        }
+    }
+    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) {
+            Logger.error('Error while deleting identity cache', { err });
+        }
+    }
+    getIdentityCache = async (cacheKey) => {
+        const start = performance.now();
+        const cacheResponse = await this.cacheLambdaClient.invokeGet(cacheKey);
+        const end = performance.now();
+        Logger.debug('getIdentityCache', { cacheKey, cacheResponse, duration: end - start });
+        if (cacheResponse && cacheResponse.responseData) {
+            return cacheResponse.responseData;
+        }
+        return undefined;
+    };
+    updateIdentityCacheRedis = async (pixelId, request, response, enableSecondaryCacheKeys = false) => {
+        if (!response || !response.identityId || !pixelId) {
+            return;
+        }
+        const identityCache = {
+            identityId: response.identityId,
+            response,
+            updatedAt: 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 && request.identityId !== response.identityId) {
+            const cacheKey = `identId_${pixelId}_${request.identityId}`;
+            setCacheCommands.push({
+                cacheKey,
+                commandType: 'set',
+                data: JSON.stringify(identityCache),
+                expires: IDENTITY_CACHE_TTL_IN_SECONDS,
+            });
+        }
+        if (enableSecondaryCacheKeys) {
+            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();
+        Logger.debug('updated identity cache', { res, duration: end - start });
+        return res;
+    };
+}
 //# sourceMappingURL=identity-cache-db-service.js.map