@adtrackify/at-service-common 3.1.52 → 3.1.54

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

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

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

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

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

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

package/dist/esm/services/db/index.js

@@ -1,8 +1,8 @@
-export * from './destinations-db-service.js';
-export * from './log-events-db-service.js';
-export * from './purchased-contacts-db-service.js';
-export * from './tracking-events-db-service.js';
-export * from './shopify-products-cache-db-service.js';
-export * from './shopify-app-installs-db-service.js';
-export * from './identity-cache-db-service.js';
+export * from './destinations-db-service.js';
+export * from './log-events-db-service.js';
+export * from './purchased-contacts-db-service.js';
+export * from './tracking-events-db-service.js';
+export * from './shopify-products-cache-db-service.js';
+export * from './shopify-app-installs-db-service.js';
+export * from './identity-cache-db-service.js';
 //# sourceMappingURL=index.js.map

package/dist/esm/services/db/log-events-db-service.d.ts

@@ -1,11 +1,11 @@
-import { LogEvent, LogEventRecord } from '@adtrackify/at-tracking-event-types';
-export declare class LogEventsDbService {
-    TABLE_NAME: string;
-    constructor(tableName: string);
-    private processResult;
-    private processResults;
-    getLogEventsByDestinationId: (indexName: string, pixelId: string, destinationId: string, limit?: number, afterCollectedAt?: string) => Promise<LogEventRecord[]>;
-    getEventDebugLogs: (indexName: string, pixelId: string, logLevel: string, destinations?: string[], sources?: string[], eventNames?: string[]) => Promise<LogEventRecord[]>;
-    putLogEvent: (logEvent: LogEvent, logGroup: string, ttlInMinutes?: number) => Promise<import("@aws-sdk/lib-dynamodb").PutCommandOutput | null>;
-    private buildLogEventErrorMessage;
-}
+import { LogEvent, LogEventRecord } from '@adtrackify/at-tracking-event-types';
+export declare class LogEventsDbService {
+    TABLE_NAME: string;
+    constructor(tableName: string);
+    private processResult;
+    private processResults;
+    getLogEventsByDestinationId: (indexName: string, pixelId: string, destinationId: string, limit?: number, afterCollectedAt?: string) => Promise<LogEventRecord[]>;
+    getEventDebugLogs: (indexName: string, pixelId: string, logLevel: string, destinations?: string[], sources?: string[], eventNames?: string[]) => Promise<LogEventRecord[]>;
+    putLogEvent: (logEvent: LogEvent, logGroup: string, ttlInMinutes?: number) => Promise<import("@aws-sdk/lib-dynamodb").PutCommandOutput | null>;
+    private buildLogEventErrorMessage;
+}