@adtrackify/at-service-common 5.0.0 → 5.0.2

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

@@ -1,23 +1,23 @@
-import { EventIdentity } from '@adtrackify/at-tracking-event-types';
-import { EnqueueAsyncIdentityUpdateRequest, EnqueueAsyncIdentityUpdateResult, IdentityResolutionResult } from './types.js';
-export interface IdentityGatewayServiceOptions {
-    asyncUpdateQueueUrl?: string;
-    awsRegion?: string;
-    awsAccountId?: string;
-    asyncUpdateQueueName?: string;
-    identifyPrivateLambdaArn?: string;
-    identityBaseApiUrl?: string;
-}
-export declare class IdentityGatewayService {
-    private readonly identityClient;
-    private readonly sqsClient;
-    constructor(options: IdentityGatewayServiceOptions);
-    resolveIdentityWithCaching(pixelId: string, incomingIdentity: EventIdentity): Promise<IdentityResolutionResult>;
-    private createInitialResult;
-    private processCacheHit;
-    private processFreshCacheHit;
-    private processStaleCacheHit;
-    private resolveViaNeptune;
-    private resolveIdentity;
-    enqueueAsyncIdentityUpdate(request: EnqueueAsyncIdentityUpdateRequest): Promise<EnqueueAsyncIdentityUpdateResult>;
-}
+import { EventIdentity } from '@adtrackify/at-tracking-event-types';
+import { EnqueueAsyncIdentityUpdateRequest, EnqueueAsyncIdentityUpdateResult, IdentityResolutionResult } from './types.js';
+export interface IdentityGatewayServiceOptions {
+    asyncUpdateQueueUrl?: string;
+    awsRegion?: string;
+    awsAccountId?: string;
+    asyncUpdateQueueName?: string;
+    identifyPrivateLambdaArn?: string;
+    identityBaseApiUrl?: string;
+}
+export declare class IdentityGatewayService {
+    private readonly identityClient;
+    private readonly sqsClient;
+    constructor(options: IdentityGatewayServiceOptions);
+    resolveIdentityWithCaching(pixelId: string, incomingIdentity: EventIdentity): Promise<IdentityResolutionResult>;
+    private createInitialResult;
+    private processCacheHit;
+    private processFreshCacheHit;
+    private processStaleCacheHit;
+    private resolveViaNeptune;
+    private resolveIdentity;
+    enqueueAsyncIdentityUpdate(request: EnqueueAsyncIdentityUpdateRequest): Promise<EnqueueAsyncIdentityUpdateResult>;
+}

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

@@ -1,219 +1,219 @@
-import { mergeAndComputeIdentityStaleness, computeTraitChanges } from '@adtrackify/at-shared-utils';
-import { SQSClient } from '../../../clients/index.js';
-import { IdentityClient } from '../../../clients/internal-api/identity-client.js';
-import { Logger } from '../../../helpers/index.js';
-import { IdentityCacheDynamoDbDbService } from './identity-cache-dynamodb-db-service.js';
-import { IDENTITY_CACHE_WITH_CACHING_OUTCOME, } from './types.js';
-const IDENTIFY_ASYNC_UPDATE_MESSAGE_TYPE = 'identify.updateAsync';
-export class IdentityGatewayService {
-    identityClient;
-    sqsClient;
-    constructor(options) {
-        if (options.identifyPrivateLambdaArn) {
-            this.identityClient = new IdentityClient({
-                baseApiUrl: options.identityBaseApiUrl ?? '',
-                identifyPrivateLambdaArn: options.identifyPrivateLambdaArn,
-            });
-        }
-        else if (options.identityBaseApiUrl) {
-            this.identityClient = new IdentityClient({
-                baseApiUrl: options.identityBaseApiUrl,
-            });
-        }
-        if (options.asyncUpdateQueueUrl) {
-            const urlMatch = options.asyncUpdateQueueUrl.match(/^https:\/\/sqs\.([^.]+)\.amazonaws\.com\/(\d+)\/(.+)$/);
-            if (urlMatch) {
-                const [, region, accountId, queueName] = urlMatch;
-                this.sqsClient = new SQSClient(region, accountId, queueName);
-            }
-            else {
-                Logger.warn('IdentityGateway - constructor: invalid SQS URL format', {
-                    asyncUpdateQueueUrl: options.asyncUpdateQueueUrl,
-                });
-            }
-        }
-        else if (options.awsRegion && options.awsAccountId) {
-            const queueName = options.asyncUpdateQueueName ?? process.env.IDENTIFY_ASYNC_UPDATE_QUEUE_NAME;
-            if (queueName) {
-                this.sqsClient = new SQSClient(options.awsRegion, options.awsAccountId, queueName);
-            }
-        }
-    }
-    async resolveIdentityWithCaching(pixelId, incomingIdentity) {
-        const result = this.createInitialResult(pixelId, incomingIdentity);
-        if (!pixelId || !incomingIdentity) {
-            Logger.error('IdentityGateway - missing required params', { pixelId, incomingIdentity });
-            result.outcome = IDENTITY_CACHE_WITH_CACHING_OUTCOME.INVALID_INPUT;
-            return result;
-        }
-        try {
-            const pureCacheResult = await IdentityCacheDynamoDbDbService.getIdentityFromCachePure(pixelId, incomingIdentity);
-            result.didReadCache = true;
-            if (!pureCacheResult.cacheHit || !pureCacheResult.cachedIdentity) {
-                return await this.resolveViaNeptune(result, { discoveredIdentityId: pureCacheResult.discoveredIdentityId });
-            }
-            return await this.processCacheHit(result, pureCacheResult.cachedIdentity);
-        }
-        catch (error) {
-            Logger.error('IdentityGateway - resolveIdentityWithCaching failed', {
-                error,
-                errorMessage: error instanceof Error ? error.message : String(error),
-                pixelId,
-                identityId: incomingIdentity?.identityId,
-            });
-            result.outcome = IDENTITY_CACHE_WITH_CACHING_OUTCOME.FAILED;
-            result.errorMessage = error instanceof Error ? error.message : String(error);
-            return result;
-        }
-    }
-    createInitialResult(pixelId, incomingIdentity) {
-        return {
-            outcome: IDENTITY_CACHE_WITH_CACHING_OUTCOME.FAILED,
-            pixelId,
-            incomingIdentity,
-            didReadCache: false,
-            didCallNeptune: false,
-            didWriteCache: false,
-            didSkipNeptune: false,
-            didFallbackToIncoming: false,
-            didEnqueueAsync: false,
-        };
-    }
-    async processCacheHit(result, cachedIdentity) {
-        const incomingIdentity = result.incomingIdentity;
-        result.cachedIdentity = cachedIdentity;
-        result.stalenessResult = mergeAndComputeIdentityStaleness(incomingIdentity, cachedIdentity);
-        result.identity = result.stalenessResult.mergedIdentity;
-        result.identityId = result.identity?.identityId;
-        result.staleTier = result.stalenessResult.staleTier;
-        Logger.debug('IdentityGateway - cache hit staleness computed', {
-            pixelId: result.pixelId,
-            identityId: result.identityId,
-            stalenessResult: result.stalenessResult,
-        });
-        if (!result.stalenessResult.isCacheStale) {
-            return this.processFreshCacheHit(result);
-        }
-        return this.processStaleCacheHit(result);
-    }
-    processFreshCacheHit(result) {
-        const stalenessResult = result.stalenessResult;
-        result.outcome = stalenessResult.isVolatileOnly && !stalenessResult.isDeepEqual
-            ? IDENTITY_CACHE_WITH_CACHING_OUTCOME.VOLATILE_ONLY_CACHE_HIT
-            : IDENTITY_CACHE_WITH_CACHING_OUTCOME.FRESH_CACHE_HIT;
-        const tierLabel = stalenessResult.isVolatileOnly ? 'volatile_traits_only' : 'fresh';
-        Logger.debug(`IdentityGateway - cache hit: ${tierLabel}`, {
-            pixelId: result.pixelId,
-            identityId: result.identityId,
-            staleTier: result.staleTier,
-            outcome: result.outcome,
-        });
-        return result;
-    }
-    async processStaleCacheHit(result) {
-        Logger.debug('IdentityGateway - cache stale: calling Neptune', {
-            pixelId: result.pixelId,
-            identityId: result.incomingIdentity?.identityId,
-            stalenessResult: result.stalenessResult,
-            cachedIdentity: result.cachedIdentity,
-        });
-        return this.resolveViaNeptune(result);
-    }
-    async resolveViaNeptune(result, context) {
-        const incomingIdentity = result.incomingIdentity;
-        const discoveredIdentityId = context?.discoveredIdentityId;
-        const identityForNeptune = incomingIdentity.identityId
-            ? incomingIdentity
-            : discoveredIdentityId
-                ? { ...incomingIdentity, identityId: discoveredIdentityId }
-                : incomingIdentity;
-        const isCacheMiss = !result.cachedIdentity;
-        const contextLabel = isCacheMiss ? 'cache miss' : 'stale cache';
-        result.identityForNeptune = identityForNeptune;
-        result.didCallNeptune = true;
-        result.neptuneIdentity = await this.resolveIdentity(result.pixelId, identityForNeptune);
-        if (result.neptuneIdentity) {
-            result.identity = result.neptuneIdentity;
-            result.identityId = result.neptuneIdentity.identityId;
-            result.outcome = IDENTITY_CACHE_WITH_CACHING_OUTCOME.NEPTUNE_RESOLVED;
-            result.traitChanges = result.cachedIdentity
-                ? computeTraitChanges(result.cachedIdentity, result.neptuneIdentity)
-                : { reason: { resolved: 'no cached identity' } };
-            Logger.debug(`IdentityGateway - ${contextLabel}: Neptune resolved`, {
-                pixelId: result.pixelId,
-                identityId: result.identityId,
-                isCacheMiss,
-                usedDiscoveredId: !incomingIdentity.identityId && !!discoveredIdentityId,
-            });
-            return result;
-        }
-        result.identity = identityForNeptune;
-        result.identityId = identityForNeptune?.identityId;
-        result.didFallbackToIncoming = true;
-        result.outcome = IDENTITY_CACHE_WITH_CACHING_OUTCOME.NEPTUNE_RESOLUTION_FAILED;
-        Logger.warn(`IdentityGateway - ${contextLabel}: Neptune failed, using incoming`, {
-            pixelId: result.pixelId,
-            identityId: result.identityId,
-        });
-        return result;
-    }
-    async resolveIdentity(pixelId, incomingIdentity) {
-        if (!this.identityClient) {
-            Logger.error('IdentityGateway - identity client not configured', { pixelId });
-            return undefined;
-        }
-        try {
-            const identityResult = await this.identityClient.getIdentity(pixelId, { identity: incomingIdentity });
-            return identityResult ?? undefined;
-        }
-        catch (error) {
-            Logger.error('IdentityGateway - identity resolution failed', {
-                error,
-                errorMessage: error instanceof Error ? error.message : String(error),
-                pixelId,
-                incomingIdentity,
-            });
-            return undefined;
-        }
-    }
-    async enqueueAsyncIdentityUpdate(request) {
-        const { pixelId, identity, context, reason, eventId } = request;
-        const identityId = identity?.identityId;
-        if (!this.sqsClient) {
-            Logger.warn('IdentityGateway - enqueueAsyncIdentityUpdate: SQS client not configured', {
-                pixelId, identityId, reason, eventId,
-            });
-            return { success: false, error: 'SQS client not configured' };
-        }
-        if (!pixelId || !identityId) {
-            Logger.warn('IdentityGateway - enqueueAsyncIdentityUpdate: missing required params', {
-                pixelId, identityId, reason, eventId,
-            });
-            return { success: false, error: 'Missing required pixelId or identityId' };
-        }
-        try {
-            const message = {
-                pixelId,
-                incomingIdentityId: identityId,
-                context,
-            };
-            const response = await this.sqsClient.buildAndSendMessage(IDENTIFY_ASYNC_UPDATE_MESSAGE_TYPE, message);
-            Logger.debug('IdentityGateway - enqueueAsyncIdentityUpdate: message sent', {
-                pixelId, identityId, reason, eventId, sqsMessageId: response.MessageId,
-            });
-            return { success: true, messageId: response.MessageId };
-        }
-        catch (error) {
-            Logger.warn('IdentityGateway - enqueueAsyncIdentityUpdate: failed to enqueue (failing open)', {
-                error,
-                errorMessage: error instanceof Error ? error.message : String(error),
-                pixelId, identityId, reason, eventId,
-            });
-            return {
-                success: false,
-                error: error instanceof Error ? error.message : String(error),
-            };
-        }
-    }
-}
+import { mergeAndComputeIdentityStaleness, computeTraitChanges } from '@adtrackify/at-shared-utils';
+import { SQSClient } from '../../../clients/index.js';
+import { IdentityClient } from '../../../clients/internal-api/identity-client.js';
+import { Logger } from '../../../helpers/index.js';
+import { IdentityCacheDynamoDbDbService } from './identity-cache-dynamodb-db-service.js';
+import { IDENTITY_CACHE_WITH_CACHING_OUTCOME, } from './types.js';
+const IDENTIFY_ASYNC_UPDATE_MESSAGE_TYPE = 'identify.updateAsync';
+export class IdentityGatewayService {
+    identityClient;
+    sqsClient;
+    constructor(options) {
+        if (options.identifyPrivateLambdaArn) {
+            this.identityClient = new IdentityClient({
+                baseApiUrl: options.identityBaseApiUrl ?? '',
+                identifyPrivateLambdaArn: options.identifyPrivateLambdaArn,
+            });
+        }
+        else if (options.identityBaseApiUrl) {
+            this.identityClient = new IdentityClient({
+                baseApiUrl: options.identityBaseApiUrl,
+            });
+        }
+        if (options.asyncUpdateQueueUrl) {
+            const urlMatch = options.asyncUpdateQueueUrl.match(/^https:\/\/sqs\.([^.]+)\.amazonaws\.com\/(\d+)\/(.+)$/);
+            if (urlMatch) {
+                const [, region, accountId, queueName] = urlMatch;
+                this.sqsClient = new SQSClient(region, accountId, queueName);
+            }
+            else {
+                Logger.warn('IdentityGateway - constructor: invalid SQS URL format', {
+                    asyncUpdateQueueUrl: options.asyncUpdateQueueUrl,
+                });
+            }
+        }
+        else if (options.awsRegion && options.awsAccountId) {
+            const queueName = options.asyncUpdateQueueName ?? process.env.IDENTIFY_ASYNC_UPDATE_QUEUE_NAME;
+            if (queueName) {
+                this.sqsClient = new SQSClient(options.awsRegion, options.awsAccountId, queueName);
+            }
+        }
+    }
+    async resolveIdentityWithCaching(pixelId, incomingIdentity) {
+        const result = this.createInitialResult(pixelId, incomingIdentity);
+        if (!pixelId || !incomingIdentity) {
+            Logger.error('IdentityGateway - missing required params', { pixelId, incomingIdentity });
+            result.outcome = IDENTITY_CACHE_WITH_CACHING_OUTCOME.INVALID_INPUT;
+            return result;
+        }
+        try {
+            const pureCacheResult = await IdentityCacheDynamoDbDbService.getIdentityFromCachePure(pixelId, incomingIdentity);
+            result.didReadCache = true;
+            if (!pureCacheResult.cacheHit || !pureCacheResult.cachedIdentity) {
+                return await this.resolveViaNeptune(result, { discoveredIdentityId: pureCacheResult.discoveredIdentityId });
+            }
+            return await this.processCacheHit(result, pureCacheResult.cachedIdentity);
+        }
+        catch (error) {
+            Logger.error('IdentityGateway - resolveIdentityWithCaching failed', {
+                error,
+                errorMessage: error instanceof Error ? error.message : String(error),
+                pixelId,
+                identityId: incomingIdentity?.identityId,
+            });
+            result.outcome = IDENTITY_CACHE_WITH_CACHING_OUTCOME.FAILED;
+            result.errorMessage = error instanceof Error ? error.message : String(error);
+            return result;
+        }
+    }
+    createInitialResult(pixelId, incomingIdentity) {
+        return {
+            outcome: IDENTITY_CACHE_WITH_CACHING_OUTCOME.FAILED,
+            pixelId,
+            incomingIdentity,
+            didReadCache: false,
+            didCallNeptune: false,
+            didWriteCache: false,
+            didSkipNeptune: false,
+            didFallbackToIncoming: false,
+            didEnqueueAsync: false,
+        };
+    }
+    async processCacheHit(result, cachedIdentity) {
+        const incomingIdentity = result.incomingIdentity;
+        result.cachedIdentity = cachedIdentity;
+        result.stalenessResult = mergeAndComputeIdentityStaleness(incomingIdentity, cachedIdentity);
+        result.identity = result.stalenessResult.mergedIdentity;
+        result.identityId = result.identity?.identityId;
+        result.staleTier = result.stalenessResult.staleTier;
+        Logger.debug('IdentityGateway - cache hit staleness computed', {
+            pixelId: result.pixelId,
+            identityId: result.identityId,
+            stalenessResult: result.stalenessResult,
+        });
+        if (!result.stalenessResult.isCacheStale) {
+            return this.processFreshCacheHit(result);
+        }
+        return this.processStaleCacheHit(result);
+    }
+    processFreshCacheHit(result) {
+        const stalenessResult = result.stalenessResult;
+        result.outcome = stalenessResult.isVolatileOnly && !stalenessResult.isDeepEqual
+            ? IDENTITY_CACHE_WITH_CACHING_OUTCOME.VOLATILE_ONLY_CACHE_HIT
+            : IDENTITY_CACHE_WITH_CACHING_OUTCOME.FRESH_CACHE_HIT;
+        const tierLabel = stalenessResult.isVolatileOnly ? 'volatile_traits_only' : 'fresh';
+        Logger.debug(`IdentityGateway - cache hit: ${tierLabel}`, {
+            pixelId: result.pixelId,
+            identityId: result.identityId,
+            staleTier: result.staleTier,
+            outcome: result.outcome,
+        });
+        return result;
+    }
+    async processStaleCacheHit(result) {
+        Logger.debug('IdentityGateway - cache stale: calling Neptune', {
+            pixelId: result.pixelId,
+            identityId: result.incomingIdentity?.identityId,
+            stalenessResult: result.stalenessResult,
+            cachedIdentity: result.cachedIdentity,
+        });
+        return this.resolveViaNeptune(result);
+    }
+    async resolveViaNeptune(result, context) {
+        const incomingIdentity = result.incomingIdentity;
+        const discoveredIdentityId = context?.discoveredIdentityId;
+        const identityForNeptune = incomingIdentity.identityId
+            ? incomingIdentity
+            : discoveredIdentityId
+                ? { ...incomingIdentity, identityId: discoveredIdentityId }
+                : incomingIdentity;
+        const isCacheMiss = !result.cachedIdentity;
+        const contextLabel = isCacheMiss ? 'cache miss' : 'stale cache';
+        result.identityForNeptune = identityForNeptune;
+        result.didCallNeptune = true;
+        result.neptuneIdentity = await this.resolveIdentity(result.pixelId, identityForNeptune);
+        if (result.neptuneIdentity) {
+            result.identity = result.neptuneIdentity;
+            result.identityId = result.neptuneIdentity.identityId;
+            result.outcome = IDENTITY_CACHE_WITH_CACHING_OUTCOME.NEPTUNE_RESOLVED;
+            result.traitChanges = result.cachedIdentity
+                ? computeTraitChanges(result.cachedIdentity, result.neptuneIdentity)
+                : { reason: { resolved: 'no cached identity' } };
+            Logger.debug(`IdentityGateway - ${contextLabel}: Neptune resolved`, {
+                pixelId: result.pixelId,
+                identityId: result.identityId,
+                isCacheMiss,
+                usedDiscoveredId: !incomingIdentity.identityId && !!discoveredIdentityId,
+            });
+            return result;
+        }
+        result.identity = identityForNeptune;
+        result.identityId = identityForNeptune?.identityId;
+        result.didFallbackToIncoming = true;
+        result.outcome = IDENTITY_CACHE_WITH_CACHING_OUTCOME.NEPTUNE_RESOLUTION_FAILED;
+        Logger.warn(`IdentityGateway - ${contextLabel}: Neptune failed, using incoming`, {
+            pixelId: result.pixelId,
+            identityId: result.identityId,
+        });
+        return result;
+    }
+    async resolveIdentity(pixelId, incomingIdentity) {
+        if (!this.identityClient) {
+            Logger.error('IdentityGateway - identity client not configured', { pixelId });
+            return undefined;
+        }
+        try {
+            const identityResult = await this.identityClient.getIdentity(pixelId, { identity: incomingIdentity });
+            return identityResult ?? undefined;
+        }
+        catch (error) {
+            Logger.error('IdentityGateway - identity resolution failed', {
+                error,
+                errorMessage: error instanceof Error ? error.message : String(error),
+                pixelId,
+                incomingIdentity,
+            });
+            return undefined;
+        }
+    }
+    async enqueueAsyncIdentityUpdate(request) {
+        const { pixelId, identity, context, reason, eventId } = request;
+        const identityId = identity?.identityId;
+        if (!this.sqsClient) {
+            Logger.warn('IdentityGateway - enqueueAsyncIdentityUpdate: SQS client not configured', {
+                pixelId, identityId, reason, eventId,
+            });
+            return { success: false, error: 'SQS client not configured' };
+        }
+        if (!pixelId || !identityId) {
+            Logger.warn('IdentityGateway - enqueueAsyncIdentityUpdate: missing required params', {
+                pixelId, identityId, reason, eventId,
+            });
+            return { success: false, error: 'Missing required pixelId or identityId' };
+        }
+        try {
+            const message = {
+                pixelId,
+                incomingIdentityId: identityId,
+                context,
+            };
+            const response = await this.sqsClient.buildAndSendMessage(IDENTIFY_ASYNC_UPDATE_MESSAGE_TYPE, message);
+            Logger.debug('IdentityGateway - enqueueAsyncIdentityUpdate: message sent', {
+                pixelId, identityId, reason, eventId, sqsMessageId: response.MessageId,
+            });
+            return { success: true, messageId: response.MessageId };
+        }
+        catch (error) {
+            Logger.warn('IdentityGateway - enqueueAsyncIdentityUpdate: failed to enqueue (failing open)', {
+                error,
+                errorMessage: error instanceof Error ? error.message : String(error),
+                pixelId, identityId, reason, eventId,
+            });
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+            };
+        }
+    }
+}
 //# sourceMappingURL=identity-gateway-service.js.map

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

@@ -1,4 +1,4 @@
-export * from './types.js';
-export * from './key-builders.js';
-export * from './identity-gateway-service.js';
-export * from './identity-cache-dynamodb-db-service.js';
+export * from './types.js';
+export * from './key-builders.js';
+export * from './identity-gateway-service.js';
+export * from './identity-cache-dynamodb-db-service.js';

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

@@ -1,5 +1,5 @@
-export * from './types.js';
-export * from './key-builders.js';
-export * from './identity-gateway-service.js';
-export * from './identity-cache-dynamodb-db-service.js';
+export * from './types.js';
+export * from './key-builders.js';
+export * from './identity-gateway-service.js';
+export * from './identity-cache-dynamodb-db-service.js';
 //# sourceMappingURL=index.js.map

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

@@ -1,12 +1,12 @@
-export declare enum IDENTITY_CACHE_KEY_PREFIX {
-    IDENTITY = "identity",
-    EMAIL = "email",
-    USER_ID = "user_id",
-    IDENTITY_MAP = "identity_map",
-    FORCE_PURGE = "force_purge"
-}
-export declare function buildIdentityPk(pixelId: string, identityId: string): string;
-export declare function buildEmailPk(pixelId: string, email: string): string;
-export declare function buildUserIdPk(pixelId: string, userId: string): string;
-export declare function buildIdentityMapPk(pixelId: string, identityId: string): string;
-export declare function buildForcePurgePk(pixelId: string, identityId: string): string;
+export declare enum IDENTITY_CACHE_KEY_PREFIX {
+    IDENTITY = "identity",
+    EMAIL = "email",
+    USER_ID = "user_id",
+    IDENTITY_MAP = "identity_map",
+    FORCE_PURGE = "force_purge"
+}
+export declare function buildIdentityPk(pixelId: string, identityId: string): string;
+export declare function buildEmailPk(pixelId: string, email: string): string;
+export declare function buildUserIdPk(pixelId: string, userId: string): string;
+export declare function buildIdentityMapPk(pixelId: string, identityId: string): string;
+export declare function buildForcePurgePk(pixelId: string, identityId: string): string;

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

@@ -1,24 +1,24 @@
-export var IDENTITY_CACHE_KEY_PREFIX;
-(function (IDENTITY_CACHE_KEY_PREFIX) {
-    IDENTITY_CACHE_KEY_PREFIX["IDENTITY"] = "identity";
-    IDENTITY_CACHE_KEY_PREFIX["EMAIL"] = "email";
-    IDENTITY_CACHE_KEY_PREFIX["USER_ID"] = "user_id";
-    IDENTITY_CACHE_KEY_PREFIX["IDENTITY_MAP"] = "identity_map";
-    IDENTITY_CACHE_KEY_PREFIX["FORCE_PURGE"] = "force_purge";
-})(IDENTITY_CACHE_KEY_PREFIX || (IDENTITY_CACHE_KEY_PREFIX = {}));
-export function buildIdentityPk(pixelId, identityId) {
-    return `${IDENTITY_CACHE_KEY_PREFIX.IDENTITY}#${pixelId}#${identityId}`;
-}
-export function buildEmailPk(pixelId, email) {
-    return `${IDENTITY_CACHE_KEY_PREFIX.EMAIL}#${pixelId}#${email.toLowerCase()}`;
-}
-export function buildUserIdPk(pixelId, userId) {
-    return `${IDENTITY_CACHE_KEY_PREFIX.USER_ID}#${pixelId}#${userId.trim()}`;
-}
-export function buildIdentityMapPk(pixelId, identityId) {
-    return `${IDENTITY_CACHE_KEY_PREFIX.IDENTITY_MAP}#${pixelId}#${identityId}`;
-}
-export function buildForcePurgePk(pixelId, identityId) {
-    return `${IDENTITY_CACHE_KEY_PREFIX.FORCE_PURGE}#${pixelId}#${identityId}`;
-}
+export var IDENTITY_CACHE_KEY_PREFIX;
+(function (IDENTITY_CACHE_KEY_PREFIX) {
+    IDENTITY_CACHE_KEY_PREFIX["IDENTITY"] = "identity";
+    IDENTITY_CACHE_KEY_PREFIX["EMAIL"] = "email";
+    IDENTITY_CACHE_KEY_PREFIX["USER_ID"] = "user_id";
+    IDENTITY_CACHE_KEY_PREFIX["IDENTITY_MAP"] = "identity_map";
+    IDENTITY_CACHE_KEY_PREFIX["FORCE_PURGE"] = "force_purge";
+})(IDENTITY_CACHE_KEY_PREFIX || (IDENTITY_CACHE_KEY_PREFIX = {}));
+export function buildIdentityPk(pixelId, identityId) {
+    return `${IDENTITY_CACHE_KEY_PREFIX.IDENTITY}#${pixelId}#${identityId}`;
+}
+export function buildEmailPk(pixelId, email) {
+    return `${IDENTITY_CACHE_KEY_PREFIX.EMAIL}#${pixelId}#${email.toLowerCase()}`;
+}
+export function buildUserIdPk(pixelId, userId) {
+    return `${IDENTITY_CACHE_KEY_PREFIX.USER_ID}#${pixelId}#${userId.trim()}`;
+}
+export function buildIdentityMapPk(pixelId, identityId) {
+    return `${IDENTITY_CACHE_KEY_PREFIX.IDENTITY_MAP}#${pixelId}#${identityId}`;
+}
+export function buildForcePurgePk(pixelId, identityId) {
+    return `${IDENTITY_CACHE_KEY_PREFIX.FORCE_PURGE}#${pixelId}#${identityId}`;
+}
 //# sourceMappingURL=key-builders.js.map