@adtrackify/at-service-common 5.1.0 → 5.1.2

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

@@ -1,522 +1,526 @@
-import { DateTime } from 'luxon';
-import { DynamoDbClient } from '../../../clients/index.js';
-import { Logger } from '../../../helpers/index.js';
-import { FORCE_PURGE_TTL_SECONDS, IDENTITY_CACHE_GSI1_NAME, IDENTITY_CACHE_TABLE_NAME } from './constants.js';
-import { buildEmailPk, buildForcePurgePk, buildIdentityMapPk, buildIdentityPk, } from './key-builders.js';
-import { PURE_CACHE_LOOKUP_PATH, } from './types.js';
-export class IdentityCacheDynamoDbDbService {
-    static getIdentityFromCachePure = async (pixelId, incomingIdentity) => {
-        try {
-            if (!pixelId || !incomingIdentity) {
-                return { lookupPath: PURE_CACHE_LOOKUP_PATH.MISS, cacheHit: false };
-            }
-            if (incomingIdentity.identityId) {
-                return await this.resolveCacheByIdentityIdPure(pixelId, incomingIdentity.identityId);
-            }
-            return await this.resolveCacheByEmailPointerPure(pixelId, incomingIdentity);
-        }
-        catch (error) {
-            Logger.error('IdentityCache - getIdentityFromCachePure failed', {
-                error,
-                errorMessage: error instanceof Error ? error.message : String(error),
-                pixelId,
-                incomingIdentity,
-            });
-            return { lookupPath: PURE_CACHE_LOOKUP_PATH.MISS, cacheHit: false };
-        }
-    };
-    static resolveCacheByIdentityIdPure = async (pixelId, identityId) => {
-        const pk = buildIdentityPk(pixelId, identityId);
-        Logger.debug('IdentityCache - pure lookup by identityId', { pixelId, pk, identityId });
-        const cachedIdentityResponse = await this.getItemByPk(pk);
-        if (!cachedIdentityResponse?.response) {
-            Logger.debug('IdentityCache - pure lookup miss', { pixelId, identityId });
-            return { lookupPath: PURE_CACHE_LOOKUP_PATH.IDENTITY_ID, cacheHit: false };
-        }
-        Logger.debug('IdentityCache - pure lookup hit', {
-            pixelId,
-            identityId,
-            cachedIdentity: cachedIdentityResponse.response,
-        });
-        return {
-            cachedIdentity: cachedIdentityResponse.response,
-            lookupPath: PURE_CACHE_LOOKUP_PATH.IDENTITY_ID,
-            cacheHit: true,
-        };
-    };
-    static resolveCacheByEmailPointerPure = async (pixelId, incomingIdentity) => {
-        const discoveredIdentityId = await this.getIdentityIdFromEmailLookup(pixelId, incomingIdentity);
-        if (!discoveredIdentityId) {
-            Logger.debug('IdentityCache - pure email pointer miss', { pixelId, incomingIdentity });
-            return { lookupPath: PURE_CACHE_LOOKUP_PATH.MISS, cacheHit: false };
-        }
-        Logger.debug('IdentityCache - pure email pointer discovery', {
-            pixelId,
-            discoveredIdentityId,
-            incomingIdentity,
-        });
-        return {
-            lookupPath: PURE_CACHE_LOOKUP_PATH.EMAIL_POINTER,
-            discoveredIdentityId,
-            cacheHit: true,
-        };
-    };
-    static getIdentityMap = async (pixelId, identityId) => {
-        try {
-            if (!pixelId || !identityId) {
-                return undefined;
-            }
-            const pk = buildIdentityMapPk(pixelId, identityId);
-            const result = (await DynamoDbClient.safeGet(IDENTITY_CACHE_TABLE_NAME, 'pk', pk));
-            return result ?? undefined;
-        }
-        catch (error) {
-            Logger.error('IdentityCache - getIdentityMap failed', {
-                error,
-                errorMessage: error instanceof Error ? error.message : String(error),
-                pixelId,
-                identityId,
-            });
-            return undefined;
-        }
-    };
-    static getForcePurgeFlag = async (pixelId, identityId) => {
-        try {
-            if (!pixelId || !identityId) {
-                return false;
-            }
-            const pk = buildForcePurgePk(pixelId, identityId);
-            const result = await DynamoDbClient.safeGet(IDENTITY_CACHE_TABLE_NAME, 'pk', pk);
-            return result !== null;
-        }
-        catch (error) {
-            Logger.error('IdentityCache - getForcePurgeFlag failed', {
-                error,
-                errorMessage: error instanceof Error ? error.message : String(error),
-                pixelId,
-                identityId,
-            });
-            return false;
-        }
-    };
-    static updateIdentityCache = async (pixelId, response, aliasIdentityIds = []) => {
-        try {
-            if (!response?.identityId || !pixelId) {
-                return;
-            }
-            const items = [];
-            const now = new Date().toISOString();
-            items.push({
-                pk: buildIdentityPk(pixelId, response.identityId),
-                response,
-                updatedAt: now,
-                pixelId,
-                identityId: response.identityId,
-                gsi1pk: response.identityId,
-            });
-            const emails = response.traits?.emails ?? [];
-            for (const email of emails) {
-                if (email) {
-                    const pointerRecord = {
-                        pk: buildEmailPk(pixelId, email),
-                        updatedAt: now,
-                        pixelId,
-                        identityId: response.identityId,
-                        gsi1pk: response.identityId,
-                    };
-                    items.push(pointerRecord);
-                }
-            }
-            for (const aliasIdentityId of aliasIdentityIds) {
-                if (!aliasIdentityId || aliasIdentityId === response.identityId) {
-                    continue;
-                }
-                items.push({
-                    pk: buildIdentityPk(pixelId, aliasIdentityId),
-                    response,
-                    updatedAt: now,
-                    pixelId,
-                    identityId: response.identityId,
-                    gsi1pk: response.identityId,
-                });
-            }
-            await DynamoDbClient.safeBatchWrite(IDENTITY_CACHE_TABLE_NAME, items);
-            Logger.debug('IdentityCache - cache written', {
-                pixelId,
-                identityId: response.identityId,
-                aliasIdentityIds,
-                itemCount: items.length,
-            });
-        }
-        catch (error) {
-            Logger.error('IdentityCache - updateIdentityCache failed', {
-                error,
-                errorMessage: error instanceof Error ? error.message : String(error),
-                pixelId,
-            });
-        }
-    };
-    static getClusterIdentityRecords = async (pixelId, identityIds) => {
-        const uniqueIdentityIds = [...new Set(identityIds)];
-        const recordsByIdentityId = new Map();
-        const failedIdentityIds = [];
-        const chunks = this.chunkArray(uniqueIdentityIds, 100);
-        for (const chunk of chunks) {
-            const chunkResult = await this.getClusterIdentityRecordsChunk(pixelId, chunk);
-            for (const [identityId, record] of chunkResult.recordsByIdentityId) {
-                recordsByIdentityId.set(identityId, record);
-            }
-            failedIdentityIds.push(...chunkResult.failedIdentityIds);
-        }
-        const result = {
-            complete: failedIdentityIds.length === 0,
-            recordsByIdentityId,
-            failedIdentityIds: [...new Set(failedIdentityIds)],
-        };
-        Logger.debug('IdentityCache [cluster traits read]: completed', {
-            pixelId,
-            identityIds: uniqueIdentityIds,
-            result: {
-                ...result,
-                recordsByIdentityId: [...recordsByIdentityId.entries()],
-            },
-        });
-        return result;
-    };
-    static putPrimaryIdentityTraits = async (input) => {
-        const { pixelId, primaryIdentityId, traits } = input;
-        const response = { identityId: primaryIdentityId, traits };
-        const item = {
-            pk: buildIdentityPk(pixelId, primaryIdentityId),
-            pixelId,
-            identityId: primaryIdentityId,
-            response,
-            updatedAt: new Date().toISOString(),
-            gsi1pk: primaryIdentityId,
-            traitsInDynamo: true,
-        };
-        try {
-            const writeResult = await DynamoDbClient.safePut(IDENTITY_CACHE_TABLE_NAME, item);
-            const success = writeResult !== null;
-            Logger.debug('IdentityCache [primary traits write]: completed', {
-                pixelId,
-                primaryIdentityId,
-                item,
-                writeResult,
-                success,
-            });
-            return success;
-        }
-        catch (error) {
-            Logger.error('IdentityCache [primary traits write]: failed', {
-                error,
-                pixelId,
-                primaryIdentityId,
-                item,
-            });
-            return false;
-        }
-    };
-    static deleteIdentityRecords = async (pixelId, identityIds) => {
-        const uniqueIdentityIds = [...new Set(identityIds)];
-        const failedIdentityIds = [];
-        const chunks = this.chunkArray(uniqueIdentityIds, 25);
-        for (const chunk of chunks) {
-            const chunkFailedIdentityIds = await this.deleteIdentityRecordsChunk(pixelId, chunk);
-            failedIdentityIds.push(...chunkFailedIdentityIds);
-        }
-        const uniqueFailedIdentityIds = [...new Set(failedIdentityIds)];
-        Logger.debug('IdentityCache [exact identity delete]: completed', {
-            pixelId,
-            identityIds: uniqueIdentityIds,
-            failedIdentityIds: uniqueFailedIdentityIds,
-        });
-        return uniqueFailedIdentityIds;
-    };
-    static putIdentityMap = async (pixelId, identityId, linkedIdentities) => {
-        try {
-            if (!pixelId || !identityId) {
-                return;
-            }
-            const item = {
-                pk: buildIdentityMapPk(pixelId, identityId),
-                pixelId,
-                identityId,
-                linkedIdentities,
-                updatedAt: new Date().toISOString(),
-            };
-            await DynamoDbClient.safePut(IDENTITY_CACHE_TABLE_NAME, item);
-            Logger.debug('IdentityCache - identity map written', { pixelId, identityId, linkedIdentities });
-        }
-        catch (error) {
-            Logger.error('IdentityCache - putIdentityMap failed', {
-                error,
-                errorMessage: error instanceof Error ? error.message : String(error),
-                pixelId,
-                identityId,
-            });
-        }
-    };
-    static setForcePurgeFlag = async (pixelId, identityId, ttlSeconds = FORCE_PURGE_TTL_SECONDS) => {
-        try {
-            if (!pixelId || !identityId) {
-                return;
-            }
-            const now = new Date().toISOString();
-            const ttl = DateTime.utc().plus({ seconds: ttlSeconds }).toSeconds();
-            const item = {
-                pk: buildForcePurgePk(pixelId, identityId),
-                pixelId,
-                identityId,
-                createdAt: now,
-                ttl: Math.floor(ttl),
-            };
-            await DynamoDbClient.safePut(IDENTITY_CACHE_TABLE_NAME, item);
-            Logger.debug('IdentityCache - force purge flag set', { pixelId, identityId, ttlSeconds });
-        }
-        catch (error) {
-            Logger.error('IdentityCache - setForcePurgeFlag failed', {
-                error,
-                errorMessage: error instanceof Error ? error.message : String(error),
-                pixelId,
-                identityId,
-            });
-        }
-    };
-    static deleteIdentityCache = async (pixelId, incomingIdentity, resolvedIdentity) => {
-        try {
-            if (!pixelId) {
-                return;
-            }
-            const deleteKeys = [];
-            const identityIdsToDelete = new Set();
-            if (incomingIdentity?.identityId) {
-                identityIdsToDelete.add(incomingIdentity.identityId);
-            }
-            if (resolvedIdentity?.identityId) {
-                identityIdsToDelete.add(resolvedIdentity.identityId);
-            }
-            for (const identityId of identityIdsToDelete) {
-                const relatedItems = await this.queryByGsi1(identityId);
-                for (const item of relatedItems) {
-                    if (item.pk && item.pixelId === pixelId) {
-                        deleteKeys.push({ pk: item.pk });
-                    }
-                }
-            }
-            if (incomingIdentity?.traits?.emails) {
-                for (const email of incomingIdentity.traits.emails) {
-                    deleteKeys.push({ pk: buildEmailPk(pixelId, email) });
-                }
-            }
-            if (resolvedIdentity?.traits?.emails) {
-                for (const email of resolvedIdentity.traits.emails) {
-                    deleteKeys.push({ pk: buildEmailPk(pixelId, email) });
-                }
-            }
-            const uniqueKeys = Array.from(new Set(deleteKeys.map((k) => k.pk))).map((pk) => ({ pk }));
-            if (uniqueKeys.length > 0) {
-                await this.safeBatchDelete(uniqueKeys);
-                Logger.debug('IdentityCache - cache items deleted', { pixelId, deletedCount: uniqueKeys.length });
-            }
-        }
-        catch (error) {
-            Logger.error('IdentityCache - deleteIdentityCache failed', {
-                error,
-                errorMessage: error instanceof Error ? error.message : String(error),
-                pixelId,
-            });
-        }
-    };
-    static deleteIdentityMap = async (pixelId, identityId) => {
-        try {
-            if (!pixelId || !identityId) {
-                return;
-            }
-            const pk = buildIdentityMapPk(pixelId, identityId);
-            await DynamoDbClient.safeDelete(IDENTITY_CACHE_TABLE_NAME, 'pk', pk);
-            Logger.debug('IdentityCache - identity map deleted', { pixelId, identityId });
-        }
-        catch (error) {
-            Logger.error('IdentityCache - deleteIdentityMap failed', {
-                error,
-                errorMessage: error instanceof Error ? error.message : String(error),
-                pixelId,
-                identityId,
-            });
-        }
-    };
-    static deleteForcePurgeFlag = async (pixelId, identityId) => {
-        try {
-            if (!pixelId || !identityId) {
-                return;
-            }
-            const pk = buildForcePurgePk(pixelId, identityId);
-            await DynamoDbClient.safeDelete(IDENTITY_CACHE_TABLE_NAME, 'pk', pk);
-            Logger.debug('IdentityCache - force purge flag deleted', { pixelId, identityId });
-        }
-        catch (error) {
-            Logger.error('IdentityCache - deleteForcePurgeFlag failed', {
-                error,
-                errorMessage: error instanceof Error ? error.message : String(error),
-                pixelId,
-                identityId,
-            });
-        }
-    };
-    static getIdentityIdFromEmailLookup = async (pixelId, incomingIdentity) => {
-        try {
-            if (!pixelId || !incomingIdentity) {
-                return undefined;
-            }
-            const firstEmail = incomingIdentity.traits?.emails?.[0];
-            if (!firstEmail) {
-                return undefined;
-            }
-            const pk = buildEmailPk(pixelId, firstEmail);
-            Logger.debug('IdentityCache - email secondary lookup', { pixelId, pk, email: firstEmail });
-            const result = (await DynamoDbClient.safeGet(IDENTITY_CACHE_TABLE_NAME, 'pk', pk));
-            if (!result) {
-                return undefined;
-            }
-            Logger.debug('IdentityCache - identityId from email lookup', { pixelId, identityId: result.identityId, email: firstEmail });
-            return result.identityId;
-        }
-        catch (error) {
-            Logger.error('IdentityCache - email lookup failed', {
-                error,
-                errorMessage: error instanceof Error ? error.message : String(error),
-                pixelId,
-                incomingIdentity,
-            });
-            return undefined;
-        }
-    };
-    static getItemByPk = async (pk) => {
-        try {
-            const result = (await DynamoDbClient.safeGet(IDENTITY_CACHE_TABLE_NAME, 'pk', pk));
-            return result ?? undefined;
-        }
-        catch (error) {
-            Logger.error('IdentityCache - getItemByPk failed', {
-                error,
-                errorMessage: error instanceof Error ? error.message : String(error),
-                pk,
-            });
-            return undefined;
-        }
-    };
-    static getClusterIdentityRecordsChunk = async (pixelId, identityIds) => {
-        const keys = identityIds.map((identityId) => ({
-            pk: buildIdentityPk(pixelId, identityId),
-        }));
-        const identityIdByPk = new Map(identityIds.map((identityId) => [buildIdentityPk(pixelId, identityId), identityId]));
-        try {
-            const response = await DynamoDbClient.batchGet({
-                RequestItems: { [IDENTITY_CACHE_TABLE_NAME]: { Keys: keys } },
-            });
-            const records = (response.Responses?.[IDENTITY_CACHE_TABLE_NAME] ?? []);
-            const unprocessedKeys = (response.UnprocessedKeys?.[IDENTITY_CACHE_TABLE_NAME]?.Keys ?? []);
-            const recordsByIdentityId = new Map();
-            for (const record of records) {
-                const lookupIdentityId = identityIdByPk.get(record.pk);
-                if (lookupIdentityId) {
-                    recordsByIdentityId.set(lookupIdentityId, record);
-                }
-            }
-            const failedIdentityIds = unprocessedKeys
-                .map((key) => identityIdByPk.get(key.pk))
-                .filter((identityId) => Boolean(identityId));
-            return {
-                complete: failedIdentityIds.length === 0,
-                recordsByIdentityId,
-                failedIdentityIds,
-            };
-        }
-        catch (error) {
-            Logger.error('IdentityCache [cluster traits read]: chunk failed', {
-                error,
-                pixelId,
-                identityIds,
-                keys,
-            });
-            return {
-                complete: false,
-                recordsByIdentityId: new Map(),
-                failedIdentityIds: identityIds,
-            };
-        }
-    };
-    static deleteIdentityRecordsChunk = async (pixelId, identityIds) => {
-        const identityIdByPk = new Map(identityIds.map((identityId) => [buildIdentityPk(pixelId, identityId), identityId]));
-        const deleteRequests = [...identityIdByPk.keys()].map((pk) => ({
-            DeleteRequest: { Key: { pk } },
-        }));
-        try {
-            const response = await DynamoDbClient.batchWrite({
-                RequestItems: { [IDENTITY_CACHE_TABLE_NAME]: deleteRequests },
-            });
-            const unprocessedItems = (response.UnprocessedItems?.[IDENTITY_CACHE_TABLE_NAME] ?? []);
-            return unprocessedItems
-                .map((item) => {
-                const pk = item.DeleteRequest?.Key?.pk;
-                return pk ? identityIdByPk.get(pk) : undefined;
-            })
-                .filter((identityId) => Boolean(identityId));
-        }
-        catch (error) {
-            Logger.error('IdentityCache [exact identity delete]: chunk failed', {
-                error,
-                pixelId,
-                identityIds,
-                deleteRequests,
-            });
-            return identityIds;
-        }
-    };
-    static queryByGsi1 = async (identityId) => {
-        try {
-            const results = await DynamoDbClient.safeQueryByGSI(IDENTITY_CACHE_TABLE_NAME, IDENTITY_CACHE_GSI1_NAME, 'gsi1pk', identityId);
-            return (results ?? []);
-        }
-        catch (error) {
-            Logger.error('IdentityCache - queryByGsi1 failed', {
-                error,
-                errorMessage: error instanceof Error ? error.message : String(error),
-                identityId,
-            });
-            return [];
-        }
-    };
-    static safeBatchDelete = async (keys) => {
-        if (keys.length === 0) {
-            return;
-        }
-        const chunks = this.chunkArray(keys, 25);
-        for (const chunk of chunks) {
-            try {
-                const deleteRequests = chunk.map((key) => ({
-                    DeleteRequest: { Key: { pk: key.pk } },
-                }));
-                await DynamoDbClient.batchWrite({
-                    RequestItems: { [IDENTITY_CACHE_TABLE_NAME]: deleteRequests },
-                });
-            }
-            catch (error) {
-                Logger.error('IdentityCache - batch delete failed', {
-                    error,
-                    errorMessage: error instanceof Error ? error.message : String(error),
-                    chunkSize: chunk.length,
-                });
-            }
-        }
-    };
-    static chunkArray(items, size) {
-        const chunks = [];
-        for (let i = 0; i < items.length; i += size) {
-            chunks.push(items.slice(i, i + size));
-        }
-        return chunks;
-    }
-}
+import { DateTime } from 'luxon';
+import { DynamoDbClient } from '../../../clients/index.js';
+import { Logger } from '../../../helpers/index.js';
+import { FORCE_PURGE_TTL_SECONDS, IDENTITY_CACHE_GSI1_NAME, IDENTITY_CACHE_TABLE_NAME } from './constants.js';
+import { buildEmailPk, buildForcePurgePk, buildIdentityMapPk, buildIdentityPk } from './key-builders.js';
+import { PURE_CACHE_LOOKUP_PATH, } from './types.js';
+export class IdentityCacheDynamoDbDbService {
+    static getIdentityFromCachePure = async (pixelId, incomingIdentity) => {
+        try {
+            if (!pixelId || !incomingIdentity) {
+                return { lookupPath: PURE_CACHE_LOOKUP_PATH.MISS, cacheHit: false };
+            }
+            if (incomingIdentity.identityId) {
+                return await this.resolveCacheByIdentityIdPure(pixelId, incomingIdentity.identityId);
+            }
+            return await this.resolveCacheByEmailPointerPure(pixelId, incomingIdentity);
+        }
+        catch (error) {
+            Logger.error('IdentityCache - getIdentityFromCachePure failed', {
+                error,
+                errorMessage: error instanceof Error ? error.message : String(error),
+                pixelId,
+                incomingIdentity,
+            });
+            return { lookupPath: PURE_CACHE_LOOKUP_PATH.MISS, cacheHit: false };
+        }
+    };
+    static resolveCacheByIdentityIdPure = async (pixelId, identityId) => {
+        const pk = buildIdentityPk(pixelId, identityId);
+        Logger.debug('IdentityCache - pure lookup by identityId', { pixelId, pk, identityId });
+        const cachedIdentityResponse = await this.getItemByPk(pk);
+        if (!cachedIdentityResponse?.response) {
+            Logger.debug('IdentityCache - pure lookup miss', { pixelId, identityId });
+            return { lookupPath: PURE_CACHE_LOOKUP_PATH.IDENTITY_ID, cacheHit: false };
+        }
+        Logger.debug('IdentityCache - pure lookup hit', {
+            pixelId,
+            identityId,
+            cachedIdentity: cachedIdentityResponse.response,
+        });
+        return {
+            cachedIdentity: cachedIdentityResponse.response,
+            lookupPath: PURE_CACHE_LOOKUP_PATH.IDENTITY_ID,
+            cacheHit: true,
+        };
+    };
+    static resolveCacheByEmailPointerPure = async (pixelId, incomingIdentity) => {
+        const discoveredIdentityId = await this.getIdentityIdFromEmailLookup(pixelId, incomingIdentity);
+        if (!discoveredIdentityId) {
+            Logger.debug('IdentityCache - pure email pointer miss', { pixelId, incomingIdentity });
+            return { lookupPath: PURE_CACHE_LOOKUP_PATH.MISS, cacheHit: false };
+        }
+        Logger.debug('IdentityCache - pure email pointer discovery', {
+            pixelId,
+            discoveredIdentityId,
+            incomingIdentity,
+        });
+        return {
+            lookupPath: PURE_CACHE_LOOKUP_PATH.EMAIL_POINTER,
+            discoveredIdentityId,
+            cacheHit: true,
+        };
+    };
+    static getIdentityMap = async (pixelId, identityId) => {
+        try {
+            if (!pixelId || !identityId) {
+                return undefined;
+            }
+            const pk = buildIdentityMapPk(pixelId, identityId);
+            const result = (await DynamoDbClient.safeGet(IDENTITY_CACHE_TABLE_NAME, 'pk', pk));
+            return result ?? undefined;
+        }
+        catch (error) {
+            Logger.error('IdentityCache - getIdentityMap failed', {
+                error,
+                errorMessage: error instanceof Error ? error.message : String(error),
+                pixelId,
+                identityId,
+            });
+            return undefined;
+        }
+    };
+    static getForcePurgeFlag = async (pixelId, identityId) => {
+        try {
+            if (!pixelId || !identityId) {
+                return false;
+            }
+            const pk = buildForcePurgePk(pixelId, identityId);
+            const result = await DynamoDbClient.safeGet(IDENTITY_CACHE_TABLE_NAME, 'pk', pk);
+            return result !== null;
+        }
+        catch (error) {
+            Logger.error('IdentityCache - getForcePurgeFlag failed', {
+                error,
+                errorMessage: error instanceof Error ? error.message : String(error),
+                pixelId,
+                identityId,
+            });
+            return false;
+        }
+    };
+    static updateIdentityCache = async (pixelId, response, aliasIdentityIds = []) => {
+        try {
+            if (!response?.identityId || !pixelId) {
+                return;
+            }
+            const items = [];
+            const now = new Date().toISOString();
+            items.push({
+                pk: buildIdentityPk(pixelId, response.identityId),
+                response,
+                updatedAt: now,
+                pixelId,
+                identityId: response.identityId,
+                gsi1pk: response.identityId,
+            });
+            const emails = response.traits?.emails ?? [];
+            for (const email of emails) {
+                if (email) {
+                    const pointerRecord = {
+                        pk: buildEmailPk(pixelId, email),
+                        updatedAt: now,
+                        pixelId,
+                        identityId: response.identityId,
+                        gsi1pk: response.identityId,
+                    };
+                    items.push(pointerRecord);
+                }
+            }
+            for (const aliasIdentityId of aliasIdentityIds) {
+                if (!aliasIdentityId || aliasIdentityId === response.identityId) {
+                    continue;
+                }
+                items.push({
+                    pk: buildIdentityPk(pixelId, aliasIdentityId),
+                    response,
+                    updatedAt: now,
+                    pixelId,
+                    identityId: response.identityId,
+                    gsi1pk: response.identityId,
+                });
+            }
+            await DynamoDbClient.safeBatchWrite(IDENTITY_CACHE_TABLE_NAME, items);
+            Logger.debug('IdentityCache - cache written', {
+                pixelId,
+                identityId: response.identityId,
+                aliasIdentityIds,
+                itemCount: items.length,
+            });
+        }
+        catch (error) {
+            Logger.error('IdentityCache - updateIdentityCache failed', {
+                error,
+                errorMessage: error instanceof Error ? error.message : String(error),
+                pixelId,
+            });
+        }
+    };
+    static getClusterIdentityRecords = async (pixelId, identityIds) => {
+        const uniqueIdentityIds = [...new Set(identityIds)];
+        const recordsByIdentityId = new Map();
+        const failedIdentityIds = [];
+        const chunks = this.chunkArray(uniqueIdentityIds, 100);
+        for (const chunk of chunks) {
+            const chunkResult = await this.getClusterIdentityRecordsChunk(pixelId, chunk);
+            for (const [identityId, record] of chunkResult.recordsByIdentityId) {
+                recordsByIdentityId.set(identityId, record);
+            }
+            failedIdentityIds.push(...chunkResult.failedIdentityIds);
+        }
+        const result = {
+            complete: failedIdentityIds.length === 0,
+            recordsByIdentityId,
+            failedIdentityIds: [...new Set(failedIdentityIds)],
+        };
+        Logger.debug('IdentityCache [cluster traits read]: completed', {
+            pixelId,
+            identityIds: uniqueIdentityIds,
+            result: {
+                ...result,
+                recordsByIdentityId: [...recordsByIdentityId.entries()],
+            },
+        });
+        return result;
+    };
+    static putPrimaryIdentityTraits = async (input) => {
+        const { pixelId, primaryIdentityId, traits } = input;
+        const response = { identityId: primaryIdentityId, traits };
+        const item = {
+            pk: buildIdentityPk(pixelId, primaryIdentityId),
+            pixelId,
+            identityId: primaryIdentityId,
+            response,
+            updatedAt: new Date().toISOString(),
+            gsi1pk: primaryIdentityId,
+            traitsInDynamo: true,
+        };
+        try {
+            const writeResult = await DynamoDbClient.safePut(IDENTITY_CACHE_TABLE_NAME, item);
+            const success = writeResult !== null;
+            Logger.debug('IdentityCache [primary traits write]: completed', {
+                pixelId,
+                primaryIdentityId,
+                item,
+                writeResult,
+                success,
+            });
+            return success;
+        }
+        catch (error) {
+            Logger.error('IdentityCache [primary traits write]: failed', {
+                error,
+                pixelId,
+                primaryIdentityId,
+                item,
+            });
+            return false;
+        }
+    };
+    static deleteIdentityRecords = async (pixelId, identityIds) => {
+        const uniqueIdentityIds = [...new Set(identityIds)];
+        const failedIdentityIds = [];
+        const chunks = this.chunkArray(uniqueIdentityIds, 25);
+        for (const chunk of chunks) {
+            const chunkFailedIdentityIds = await this.deleteIdentityRecordsChunk(pixelId, chunk);
+            failedIdentityIds.push(...chunkFailedIdentityIds);
+        }
+        const uniqueFailedIdentityIds = [...new Set(failedIdentityIds)];
+        Logger.debug('IdentityCache [exact identity delete]: completed', {
+            pixelId,
+            identityIds: uniqueIdentityIds,
+            failedIdentityIds: uniqueFailedIdentityIds,
+        });
+        return uniqueFailedIdentityIds;
+    };
+    static putIdentityMap = async (pixelId, identityId, linkedIdentities) => {
+        try {
+            if (!pixelId || !identityId) {
+                return;
+            }
+            const item = {
+                pk: buildIdentityMapPk(pixelId, identityId),
+                pixelId,
+                identityId,
+                linkedIdentities,
+                updatedAt: new Date().toISOString(),
+            };
+            await DynamoDbClient.safePut(IDENTITY_CACHE_TABLE_NAME, item);
+            Logger.debug('IdentityCache - identity map written', { pixelId, identityId, linkedIdentities });
+        }
+        catch (error) {
+            Logger.error('IdentityCache - putIdentityMap failed', {
+                error,
+                errorMessage: error instanceof Error ? error.message : String(error),
+                pixelId,
+                identityId,
+            });
+        }
+    };
+    static setForcePurgeFlag = async (pixelId, identityId, ttlSeconds = FORCE_PURGE_TTL_SECONDS) => {
+        try {
+            if (!pixelId || !identityId) {
+                return;
+            }
+            const now = new Date().toISOString();
+            const ttl = DateTime.utc().plus({ seconds: ttlSeconds }).toSeconds();
+            const item = {
+                pk: buildForcePurgePk(pixelId, identityId),
+                pixelId,
+                identityId,
+                createdAt: now,
+                ttl: Math.floor(ttl),
+            };
+            await DynamoDbClient.safePut(IDENTITY_CACHE_TABLE_NAME, item);
+            Logger.debug('IdentityCache - force purge flag set', { pixelId, identityId, ttlSeconds });
+        }
+        catch (error) {
+            Logger.error('IdentityCache - setForcePurgeFlag failed', {
+                error,
+                errorMessage: error instanceof Error ? error.message : String(error),
+                pixelId,
+                identityId,
+            });
+        }
+    };
+    static deleteIdentityCache = async (pixelId, incomingIdentity, resolvedIdentity) => {
+        try {
+            if (!pixelId) {
+                return;
+            }
+            const deleteKeys = [];
+            const identityIdsToDelete = new Set();
+            if (incomingIdentity?.identityId) {
+                identityIdsToDelete.add(incomingIdentity.identityId);
+            }
+            if (resolvedIdentity?.identityId) {
+                identityIdsToDelete.add(resolvedIdentity.identityId);
+            }
+            for (const identityId of identityIdsToDelete) {
+                const relatedItems = await this.queryByGsi1(identityId);
+                for (const item of relatedItems) {
+                    if (item.pk && item.pixelId === pixelId) {
+                        deleteKeys.push({ pk: item.pk });
+                    }
+                }
+            }
+            if (incomingIdentity?.traits?.emails) {
+                for (const email of incomingIdentity.traits.emails) {
+                    deleteKeys.push({ pk: buildEmailPk(pixelId, email) });
+                }
+            }
+            if (resolvedIdentity?.traits?.emails) {
+                for (const email of resolvedIdentity.traits.emails) {
+                    deleteKeys.push({ pk: buildEmailPk(pixelId, email) });
+                }
+            }
+            const uniqueKeys = Array.from(new Set(deleteKeys.map((k) => k.pk))).map((pk) => ({ pk }));
+            if (uniqueKeys.length > 0) {
+                await this.safeBatchDelete(uniqueKeys);
+                Logger.debug('IdentityCache - cache items deleted', { pixelId, deletedCount: uniqueKeys.length });
+            }
+        }
+        catch (error) {
+            Logger.error('IdentityCache - deleteIdentityCache failed', {
+                error,
+                errorMessage: error instanceof Error ? error.message : String(error),
+                pixelId,
+            });
+        }
+    };
+    static deleteIdentityMap = async (pixelId, identityId) => {
+        try {
+            if (!pixelId || !identityId) {
+                return;
+            }
+            const pk = buildIdentityMapPk(pixelId, identityId);
+            await DynamoDbClient.safeDelete(IDENTITY_CACHE_TABLE_NAME, 'pk', pk);
+            Logger.debug('IdentityCache - identity map deleted', { pixelId, identityId });
+        }
+        catch (error) {
+            Logger.error('IdentityCache - deleteIdentityMap failed', {
+                error,
+                errorMessage: error instanceof Error ? error.message : String(error),
+                pixelId,
+                identityId,
+            });
+        }
+    };
+    static deleteForcePurgeFlag = async (pixelId, identityId) => {
+        try {
+            if (!pixelId || !identityId) {
+                return;
+            }
+            const pk = buildForcePurgePk(pixelId, identityId);
+            await DynamoDbClient.safeDelete(IDENTITY_CACHE_TABLE_NAME, 'pk', pk);
+            Logger.debug('IdentityCache - force purge flag deleted', { pixelId, identityId });
+        }
+        catch (error) {
+            Logger.error('IdentityCache - deleteForcePurgeFlag failed', {
+                error,
+                errorMessage: error instanceof Error ? error.message : String(error),
+                pixelId,
+                identityId,
+            });
+        }
+    };
+    static getIdentityIdFromEmailLookup = async (pixelId, incomingIdentity) => {
+        try {
+            if (!pixelId || !incomingIdentity) {
+                return undefined;
+            }
+            const firstEmail = incomingIdentity.traits?.emails?.[0];
+            if (!firstEmail) {
+                return undefined;
+            }
+            const pk = buildEmailPk(pixelId, firstEmail);
+            Logger.debug('IdentityCache - email secondary lookup', { pixelId, pk, email: firstEmail });
+            const result = (await DynamoDbClient.safeGet(IDENTITY_CACHE_TABLE_NAME, 'pk', pk));
+            if (!result) {
+                return undefined;
+            }
+            Logger.debug('IdentityCache - identityId from email lookup', {
+                pixelId,
+                identityId: result.identityId,
+                email: firstEmail,
+            });
+            return result.identityId;
+        }
+        catch (error) {
+            Logger.error('IdentityCache - email lookup failed', {
+                error,
+                errorMessage: error instanceof Error ? error.message : String(error),
+                pixelId,
+                incomingIdentity,
+            });
+            return undefined;
+        }
+    };
+    static getItemByPk = async (pk) => {
+        try {
+            const result = (await DynamoDbClient.safeGet(IDENTITY_CACHE_TABLE_NAME, 'pk', pk));
+            return result ?? undefined;
+        }
+        catch (error) {
+            Logger.error('IdentityCache - getItemByPk failed', {
+                error,
+                errorMessage: error instanceof Error ? error.message : String(error),
+                pk,
+            });
+            return undefined;
+        }
+    };
+    static getClusterIdentityRecordsChunk = async (pixelId, identityIds) => {
+        const keys = identityIds.map((identityId) => ({
+            pk: buildIdentityPk(pixelId, identityId),
+        }));
+        const identityIdByPk = new Map(identityIds.map((identityId) => [buildIdentityPk(pixelId, identityId), identityId]));
+        try {
+            const response = await DynamoDbClient.batchGet({
+                RequestItems: { [IDENTITY_CACHE_TABLE_NAME]: { Keys: keys } },
+            });
+            const records = (response.Responses?.[IDENTITY_CACHE_TABLE_NAME] ?? []);
+            const unprocessedKeys = (response.UnprocessedKeys?.[IDENTITY_CACHE_TABLE_NAME]?.Keys ?? []);
+            const recordsByIdentityId = new Map();
+            for (const record of records) {
+                const lookupIdentityId = identityIdByPk.get(record.pk);
+                if (lookupIdentityId) {
+                    recordsByIdentityId.set(lookupIdentityId, record);
+                }
+            }
+            const failedIdentityIds = unprocessedKeys
+                .map((key) => identityIdByPk.get(key.pk))
+                .filter((identityId) => Boolean(identityId));
+            return {
+                complete: failedIdentityIds.length === 0,
+                recordsByIdentityId,
+                failedIdentityIds,
+            };
+        }
+        catch (error) {
+            Logger.error('IdentityCache [cluster traits read]: chunk failed', {
+                error,
+                pixelId,
+                identityIds,
+                keys,
+            });
+            return {
+                complete: false,
+                recordsByIdentityId: new Map(),
+                failedIdentityIds: identityIds,
+            };
+        }
+    };
+    static deleteIdentityRecordsChunk = async (pixelId, identityIds) => {
+        const identityIdByPk = new Map(identityIds.map((identityId) => [buildIdentityPk(pixelId, identityId), identityId]));
+        const deleteRequests = [...identityIdByPk.keys()].map((pk) => ({
+            DeleteRequest: { Key: { pk } },
+        }));
+        try {
+            const response = await DynamoDbClient.batchWrite({
+                RequestItems: { [IDENTITY_CACHE_TABLE_NAME]: deleteRequests },
+            });
+            const unprocessedItems = (response.UnprocessedItems?.[IDENTITY_CACHE_TABLE_NAME] ?? []);
+            return unprocessedItems
+                .map((item) => {
+                const pk = item.DeleteRequest?.Key?.pk;
+                return pk ? identityIdByPk.get(pk) : undefined;
+            })
+                .filter((identityId) => Boolean(identityId));
+        }
+        catch (error) {
+            Logger.error('IdentityCache [exact identity delete]: chunk failed', {
+                error,
+                pixelId,
+                identityIds,
+                deleteRequests,
+            });
+            return identityIds;
+        }
+    };
+    static queryByGsi1 = async (identityId) => {
+        try {
+            const results = await DynamoDbClient.safeQueryByGSI(IDENTITY_CACHE_TABLE_NAME, IDENTITY_CACHE_GSI1_NAME, 'gsi1pk', identityId);
+            return (results ?? []);
+        }
+        catch (error) {
+            Logger.error('IdentityCache - queryByGsi1 failed', {
+                error,
+                errorMessage: error instanceof Error ? error.message : String(error),
+                identityId,
+            });
+            return [];
+        }
+    };
+    static safeBatchDelete = async (keys) => {
+        if (keys.length === 0) {
+            return;
+        }
+        const chunks = this.chunkArray(keys, 25);
+        for (const chunk of chunks) {
+            try {
+                const deleteRequests = chunk.map((key) => ({
+                    DeleteRequest: { Key: { pk: key.pk } },
+                }));
+                await DynamoDbClient.batchWrite({
+                    RequestItems: { [IDENTITY_CACHE_TABLE_NAME]: deleteRequests },
+                });
+            }
+            catch (error) {
+                Logger.error('IdentityCache - batch delete failed', {
+                    error,
+                    errorMessage: error instanceof Error ? error.message : String(error),
+                    chunkSize: chunk.length,
+                });
+            }
+        }
+    };
+    static chunkArray(items, size) {
+        const chunks = [];
+        for (let i = 0; i < items.length; i += size) {
+            chunks.push(items.slice(i, i + size));
+        }
+        return chunks;
+    }
+}
 //# sourceMappingURL=identity-cache-dynamodb-db-service.js.map