getu-attribution-v2-sdk 0.1.0

package/dist/queue/index.d.ts

@@ -0,0 +1,51 @@
+import { QueueInterface, EventData, LoggerInterface } from "../types";
+export declare class EventQueueManager implements QueueInterface {
+    private queue;
+    private processing;
+    private batchTimer;
+    private logger;
+    private apiKey;
+    private apiEndpoint;
+    private batchSize;
+    private batchInterval;
+    private maxRetries;
+    private retryDelay;
+    private sendEvents;
+    constructor(logger: LoggerInterface, apiKey: string, apiEndpoint: string, batchSize: number | undefined, batchInterval: number | undefined, maxRetries: number | undefined, retryDelay: number | undefined, sendEvents: (events: EventData[]) => Promise<void>);
+    add(event: EventData): void;
+    process(): Promise<void>;
+    private processImmediate;
+    private scheduleBatchProcessing;
+    clear(): void;
+    size(): number;
+    getStats(): {
+        size: number;
+        processing: boolean;
+    };
+    flush(): Promise<void>;
+    private debouncedProcess;
+}
+export declare class EventHttpClient {
+    private logger;
+    private apiKey;
+    private apiEndpoint;
+    private maxRetries;
+    private retryDelay;
+    constructor(logger: LoggerInterface, apiKey: string, apiEndpoint: string, maxRetries?: number, retryDelay?: number);
+    sendEvents(events: EventData[]): Promise<void>;
+    sendSingleEvent(event: EventData): Promise<void>;
+    testConnection(): Promise<boolean>;
+}
+export declare class MemoryQueueManager implements QueueInterface {
+    private queue;
+    private maxSize;
+    private logger;
+    constructor(logger: LoggerInterface, maxSize?: number);
+    add(event: EventData): void;
+    process(): Promise<void>;
+    clear(): void;
+    size(): number;
+    getAllEvents(): EventData[];
+    removeEvents(eventIds: string[]): void;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/queue/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/queue/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,cAAc,EACd,SAAS,EAET,eAAe,EAEhB,MAAM,UAAU,CAAC;AAGlB,qBAAa,iBAAkB,YAAW,cAAc;IACtD,OAAO,CAAC,KAAK,CAAmB;IAChC,OAAO,CAAC,UAAU,CAAkB;IACpC,OAAO,CAAC,UAAU,CAA8C;IAChE,OAAO,CAAC,MAAM,CAAkB;IAChC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,SAAS,CAAS;IAC1B,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,UAAU,CAAyC;gBAGzD,MAAM,EAAE,eAAe,EACvB,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,SAAS,EAAE,MAAM,YAAM,EACvB,aAAa,EAAE,MAAM,YAAO,EAC5B,UAAU,EAAE,MAAM,YAAI,EACtB,UAAU,EAAE,MAAM,YAAO,EACzB,UAAU,EAAE,CAAC,MAAM,EAAE,SAAS,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC;IAepD,GAAG,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI;IAgBrB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;YA6ChB,gBAAgB;IAmB9B,OAAO,CAAC,uBAAuB;IAU/B,KAAK,IAAI,IAAI;IAUb,IAAI,IAAI,MAAM;IAKd,QAAQ,IAAI;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,OAAO,CAAA;KAAE;IAQ3C,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ5B,OAAO,CAAC,gBAAgB,CAAa;CACtC;AAGD,qBAAa,eAAe;IAC1B,OAAO,CAAC,MAAM,CAAkB;IAChC,OAAO,CAAC,MAAM,CAAS;IACvB,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,UAAU,CAAS;IAC3B,OAAO,CAAC,UAAU,CAAS;gBAGzB,MAAM,EAAE,eAAe,EACvB,MAAM,EAAE,MAAM,EACd,WAAW,EAAE,MAAM,EACnB,UAAU,GAAE,MAAU,EACtB,UAAU,GAAE,MAAa;IASrB,UAAU,CAAC,MAAM,EAAE,SAAS,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAmD9C,eAAe,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;IAKhD,cAAc,IAAI,OAAO,CAAC,OAAO,CAAC;CAezC;AAGD,qBAAa,kBAAmB,YAAW,cAAc;IACvD,OAAO,CAAC,KAAK,CAAmB;IAChC,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,MAAM,CAAkB;gBAEpB,MAAM,EAAE,eAAe,EAAE,OAAO,GAAE,MAAa;IAK3D,GAAG,CAAC,KAAK,EAAE,SAAS,GAAG,IAAI;IAUrB,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAM9B,KAAK,IAAI,IAAI;IAKb,IAAI,IAAI,MAAM;IAKd,YAAY,IAAI,SAAS,EAAE;IAK3B,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,IAAI;CAKvC"}

package/dist/queue/index.js

@@ -0,0 +1,215 @@
+import { IMMEDIATE_EVENTS, } from "../types";
+import { retry, debounce, getTimestamp } from "../utils";
+export class EventQueueManager {
+    constructor(logger, apiKey, apiEndpoint, batchSize = 100, batchInterval = 5000, maxRetries = 3, retryDelay = 1000, sendEvents) {
+        this.queue = [];
+        this.processing = false;
+        this.batchTimer = null;
+        this.logger = logger;
+        this.apiKey = apiKey;
+        this.apiEndpoint = apiEndpoint;
+        this.batchSize = batchSize;
+        this.batchInterval = batchInterval;
+        this.maxRetries = maxRetries;
+        this.retryDelay = retryDelay;
+        this.sendEvents = sendEvents;
+        // Debounced process function to avoid excessive calls
+        this.debouncedProcess = debounce(this.process.bind(this), 100);
+    }
+    add(event) {
+        this.queue.push(event);
+        this.logger.debug(`Event added to queue: ${event.event_type}`);
+        // Check if this is an immediate event
+        if (IMMEDIATE_EVENTS.includes(event.event_type)) {
+            this.logger.debug(`Immediate event detected: ${event.event_type}, processing immediately`);
+            this.processImmediate(event);
+        }
+        else {
+            // Schedule batch processing
+            this.scheduleBatchProcessing();
+        }
+    }
+    async process() {
+        if (this.processing || this.queue.length === 0) {
+            return;
+        }
+        this.processing = true;
+        try {
+            const eventsToProcess = this.queue.splice(0, this.batchSize);
+            this.logger.debug(`Processing ${eventsToProcess.length} events from queue`);
+            const result = await this.sendEvents(eventsToProcess);
+            this.logger.info(`Successfully processed ${eventsToProcess.length} events`);
+            // Events are automatically removed from queue when successfully sent
+            // No need to manually clean up as they were already spliced from the queue
+        }
+        catch (error) {
+            this.logger.error("Failed to process events:", error);
+            // Put events back in queue for retry
+            const failedEvents = this.queue.splice(0, this.batchSize);
+            this.queue.unshift(...failedEvents);
+            // Schedule retry
+            setTimeout(() => {
+                this.processing = false;
+                this.debouncedProcess();
+            }, this.retryDelay);
+            return;
+        }
+        this.processing = false;
+        // Process remaining events if any
+        if (this.queue.length > 0) {
+            this.debouncedProcess();
+        }
+    }
+    async processImmediate(event) {
+        try {
+            this.logger.debug(`Processing immediate event: ${event.event_type}`);
+            await this.sendEvents([event]);
+            this.logger.info(`Immediate event processed successfully: ${event.event_type}`);
+            // Event is automatically removed from queue when successfully sent
+        }
+        catch (error) {
+            this.logger.error(`Failed to process immediate event: ${event.event_type}`, error);
+            // Add to queue for retry
+            this.queue.unshift(event);
+        }
+    }
+    scheduleBatchProcessing() {
+        if (this.batchTimer) {
+            clearTimeout(this.batchTimer);
+        }
+        this.batchTimer = setTimeout(() => {
+            this.debouncedProcess();
+        }, this.batchInterval);
+    }
+    clear() {
+        this.queue = [];
+        if (this.batchTimer) {
+            clearTimeout(this.batchTimer);
+            this.batchTimer = null;
+        }
+        this.processing = false;
+        this.logger.info("Event queue cleared");
+    }
+    size() {
+        return this.queue.length;
+    }
+    // Get queue statistics
+    getStats() {
+        return {
+            size: this.queue.length,
+            processing: this.processing,
+        };
+    }
+    // Force process all events in queue
+    async flush() {
+        this.logger.info("Flushing event queue");
+        while (this.queue.length > 0) {
+            await this.process();
+        }
+    }
+}
+// HTTP client for sending events
+export class EventHttpClient {
+    constructor(logger, apiKey, apiEndpoint, maxRetries = 3, retryDelay = 1000) {
+        this.logger = logger;
+        this.apiKey = apiKey;
+        this.apiEndpoint = apiEndpoint;
+        this.maxRetries = maxRetries;
+        this.retryDelay = retryDelay;
+    }
+    async sendEvents(events) {
+        if (events.length === 0) {
+            return;
+        }
+        // Transform events to match server format
+        const transformedEvents = events.map((event) => ({
+            event_id: event.event_id,
+            event_type: event.event_type,
+            tracking_user_id: event.tracking_user_id,
+            utm_source: event.utm_source || null,
+            utm_medium: event.utm_medium || null,
+            utm_campaign: event.utm_campaign || null,
+            utm_term: event.utm_term || null,
+            utm_content: event.utm_content || null,
+            revenue: event.revenue || null,
+            currency: event.currency || null,
+            event_data: event.event_data || null,
+            context: event.context || null,
+            timestamp: event.timestamp || getTimestamp(), // Convert to seconds
+        }));
+        const batchRequest = { events: transformedEvents };
+        await retry(async () => {
+            const response = await fetch(`${this.apiEndpoint}/attribution/events`, {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${this.apiKey}`,
+                },
+                body: JSON.stringify(batchRequest),
+            });
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`HTTP ${response.status}: ${errorText}`);
+            }
+            const result = await response.json();
+            this.logger.debug("Events sent successfully:", result);
+            // Return the sent events for cleanup
+            return { result, sentEvents: events };
+        }, this.maxRetries, this.retryDelay);
+    }
+    async sendSingleEvent(event) {
+        await this.sendEvents([event]);
+    }
+    // Test connection
+    async testConnection() {
+        try {
+            const response = await fetch(`${this.apiEndpoint}/health`, {
+                method: "GET",
+                headers: {
+                    Authorization: `Bearer ${this.apiKey}`,
+                },
+            });
+            return response.ok;
+        }
+        catch (error) {
+            this.logger.error("Connection test failed:", error);
+            return false;
+        }
+    }
+}
+// Memory queue fallback
+export class MemoryQueueManager {
+    constructor(logger, maxSize = 1000) {
+        this.queue = [];
+        this.logger = logger;
+        this.maxSize = maxSize;
+    }
+    add(event) {
+        if (this.queue.length >= this.maxSize) {
+            this.logger.warn("Memory queue full, removing oldest event");
+            this.queue.shift();
+        }
+        this.queue.push(event);
+        this.logger.debug(`Event added to memory queue: ${event.event_type}`);
+    }
+    async process() {
+        // Memory queue doesn't process automatically
+        // Events are stored in memory only
+        this.logger.debug("Memory queue process called (no-op)");
+    }
+    clear() {
+        this.queue = [];
+        this.logger.info("Memory queue cleared");
+    }
+    size() {
+        return this.queue.length;
+    }
+    // Get all events from memory queue
+    getAllEvents() {
+        return [...this.queue];
+    }
+    // Remove events from memory queue
+    removeEvents(eventIds) {
+        this.queue = this.queue.filter((event) => !eventIds.includes(event.event_id));
+    }
+}

package/dist/storage/index.d.ts

@@ -0,0 +1,46 @@
+import { StorageInterface, AttributionData, EventData, LoggerInterface } from "../types";
+export declare class LocalStorageManager implements StorageInterface {
+    private logger;
+    constructor(logger: LoggerInterface);
+    get(key: string): any;
+    set(key: string, value: any): void;
+    remove(key: string): void;
+    clear(): void;
+    private handleQuotaExceeded;
+}
+export declare class IndexedDBManager {
+    private dbName;
+    private dbVersion;
+    private storeName;
+    private logger;
+    private db;
+    constructor(logger: LoggerInterface);
+    init(): Promise<void>;
+    addEvent(event: EventData): Promise<void>;
+    getUnsentEvents(limit?: number): Promise<EventData[]>;
+    markEventsAsSent(eventIds: string[]): Promise<void>;
+    cleanupOldEvents(maxAge?: number): Promise<void>;
+    getQueueSize(): Promise<number>;
+    clear(): Promise<void>;
+}
+export declare class AttributionStorageManager {
+    private localStorage;
+    private indexedDB;
+    private logger;
+    private readonly UTM_STORAGE_KEY;
+    private readonly SESSION_STORAGE_KEY;
+    constructor(logger: LoggerInterface);
+    init(): Promise<void>;
+    storeUTMData(utmData: Partial<AttributionData>): void;
+    getUTMData(): AttributionData | null;
+    storeSession(session: any): void;
+    getSession(): any;
+    queueEvent(event: EventData): Promise<void>;
+    getUnsentEvents(limit?: number): Promise<EventData[]>;
+    markEventsAsSent(eventIds: string[]): Promise<void>;
+    getQueueSize(): Promise<number>;
+    cleanupOldEvents(): Promise<void>;
+    clearQueue(): Promise<void>;
+    cleanupExpiredData(): void;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/storage/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/storage/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,eAAe,EACf,SAAS,EACT,eAAe,EAEhB,MAAM,UAAU,CAAC;AASlB,qBAAa,mBAAoB,YAAW,gBAAgB;IAC1D,OAAO,CAAC,MAAM,CAAkB;gBAEpB,MAAM,EAAE,eAAe;IAInC,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG;IAmBrB,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,GAAG,IAAI;IAelC,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAUzB,KAAK,IAAI,IAAI;IAUb,OAAO,CAAC,mBAAmB;CA4B5B;AAGD,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,MAAM,CAAgC;IAC9C,OAAO,CAAC,SAAS,CAAa;IAC9B,OAAO,CAAC,SAAS,CAAoB;IACrC,OAAO,CAAC,MAAM,CAAkB;IAChC,OAAO,CAAC,EAAE,CAA4B;gBAE1B,MAAM,EAAE,eAAe;IAI7B,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAoCrB,QAAQ,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;IA6BzC,eAAe,CAAC,KAAK,GAAE,MAAY,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;IA2B1D,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAuDnD,gBAAgB,CACpB,MAAM,GAAE,MAAgC,GACvC,OAAO,CAAC,IAAI,CAAC;IAgCV,YAAY,IAAI,OAAO,CAAC,MAAM,CAAC;IAqB/B,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;CAqB7B;AAGD,qBAAa,yBAAyB;IACpC,OAAO,CAAC,YAAY,CAAsB;IAC1C,OAAO,CAAC,SAAS,CAAmB;IACpC,OAAO,CAAC,MAAM,CAAkB;IAChC,OAAO,CAAC,QAAQ,CAAC,eAAe,CAA0B;IAC1D,OAAO,CAAC,QAAQ,CAAC,mBAAmB,CAAyB;gBAEjD,MAAM,EAAE,eAAe;IAM7B,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAK3B,YAAY,CAAC,OAAO,EAAE,OAAO,CAAC,eAAe,CAAC,GAAG,IAAI;IAkCrD,UAAU,IAAI,eAAe,GAAG,IAAI;IAepC,YAAY,CAAC,OAAO,EAAE,GAAG,GAAG,IAAI;IAIhC,UAAU,IAAI,GAAG;IAKX,UAAU,CAAC,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;IAS3C,eAAe,CAAC,KAAK,GAAE,MAAY,GAAG,OAAO,CAAC,SAAS,EAAE,CAAC;IAI1D,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAInD,YAAY,IAAI,OAAO,CAAC,MAAM,CAAC;IAI/B,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC;IAIjC,UAAU,IAAI,OAAO,CAAC,IAAI,CAAC;IAKjC,kBAAkB,IAAI,IAAI;CAG3B"}

package/dist/storage/index.js

@@ -0,0 +1,363 @@
+import { isLocalStorageSupported, isIndexedDBSupported, } from "../utils";
+// LocalStorage implementation
+export class LocalStorageManager {
+    constructor(logger) {
+        this.logger = logger;
+    }
+    get(key) {
+        try {
+            if (!isLocalStorageSupported()) {
+                this.logger.warn("LocalStorage not supported");
+                return null;
+            }
+            const item = localStorage.getItem(key);
+            if (item === null) {
+                return null;
+            }
+            return JSON.parse(item);
+        }
+        catch (error) {
+            this.logger.error("Error reading from localStorage:", error);
+            return null;
+        }
+    }
+    set(key, value) {
+        try {
+            if (!isLocalStorageSupported()) {
+                this.logger.warn("LocalStorage not supported");
+                return;
+            }
+            localStorage.setItem(key, JSON.stringify(value));
+        }
+        catch (error) {
+            this.logger.error("Error writing to localStorage:", error);
+            // Handle quota exceeded
+            this.handleQuotaExceeded();
+        }
+    }
+    remove(key) {
+        try {
+            if (isLocalStorageSupported()) {
+                localStorage.removeItem(key);
+            }
+        }
+        catch (error) {
+            this.logger.error("Error removing from localStorage:", error);
+        }
+    }
+    clear() {
+        try {
+            if (isLocalStorageSupported()) {
+                localStorage.clear();
+            }
+        }
+        catch (error) {
+            this.logger.error("Error clearing localStorage:", error);
+        }
+    }
+    handleQuotaExceeded() {
+        // Try to clean up old data
+        try {
+            const keys = Object.keys(localStorage);
+            const attributionKeys = keys.filter((key) => key.startsWith("attribution_"));
+            if (attributionKeys.length > 0) {
+                // Remove oldest data first
+                attributionKeys.sort((a, b) => {
+                    const aData = this.get(a);
+                    const bData = this.get(b);
+                    return (aData?.expiresAt || 0) - (bData?.expiresAt || 0);
+                });
+                // Remove oldest 20% of data
+                const toRemove = Math.ceil(attributionKeys.length * 0.2);
+                attributionKeys.slice(0, toRemove).forEach((key) => {
+                    this.remove(key);
+                });
+                this.logger.info(`Cleaned up ${toRemove} old attribution records`);
+            }
+        }
+        catch (error) {
+            this.logger.error("Error during quota cleanup:", error);
+        }
+    }
+}
+// IndexedDB implementation
+export class IndexedDBManager {
+    constructor(logger) {
+        this.dbName = "attribution_events";
+        this.dbVersion = 1;
+        this.storeName = "events";
+        this.db = null;
+        this.logger = logger;
+    }
+    async init() {
+        if (!isIndexedDBSupported()) {
+            this.logger.warn("IndexedDB not supported");
+            return;
+        }
+        return new Promise((resolve, reject) => {
+            const request = indexedDB.open(this.dbName, this.dbVersion);
+            request.onerror = () => {
+                this.logger.error("Failed to open IndexedDB:", request.error);
+                reject(request.error);
+            };
+            request.onsuccess = () => {
+                this.db = request.result;
+                this.logger.info("IndexedDB initialized successfully");
+                resolve();
+            };
+            request.onupgradeneeded = (event) => {
+                const db = event.target.result;
+                if (!db.objectStoreNames.contains(this.storeName)) {
+                    const store = db.createObjectStore(this.storeName, {
+                        keyPath: "id",
+                        autoIncrement: true,
+                    });
+                    store.createIndex("timestamp", "timestamp", { unique: false });
+                    store.createIndex("sent", "sent", { unique: false });
+                    store.createIndex("queued_at", "queued_at", { unique: false });
+                }
+            };
+        });
+    }
+    async addEvent(event) {
+        if (!this.db) {
+            throw new Error("IndexedDB not initialized");
+        }
+        return new Promise((resolve, reject) => {
+            const transaction = this.db.transaction([this.storeName], "readwrite");
+            const store = transaction.objectStore(this.storeName);
+            const eventRecord = {
+                ...event,
+                queued_at: Date.now(),
+                sent: false,
+            };
+            const request = store.add(eventRecord);
+            request.onsuccess = () => {
+                this.logger.debug("Event added to IndexedDB queue");
+                resolve();
+            };
+            request.onerror = () => {
+                this.logger.error("Failed to add event to IndexedDB:", request.error);
+                reject(request.error);
+            };
+        });
+    }
+    async getUnsentEvents(limit = 100) {
+        if (!this.db) {
+            return [];
+        }
+        return new Promise((resolve, reject) => {
+            const transaction = this.db.transaction([this.storeName], "readonly");
+            const store = transaction.objectStore(this.storeName);
+            const index = store.index("sent");
+            const request = index.getAll(IDBKeyRange.only(false), limit);
+            request.onsuccess = () => {
+                const events = request.result.map((record) => {
+                    const { queued_at, sent, ...event } = record;
+                    return event;
+                });
+                resolve(events);
+            };
+            request.onerror = () => {
+                this.logger.error("Failed to get unsent events:", request.error);
+                reject(request.error);
+            };
+        });
+    }
+    async markEventsAsSent(eventIds) {
+        if (!this.db || eventIds.length === 0) {
+            return;
+        }
+        return new Promise((resolve, reject) => {
+            const transaction = this.db.transaction([this.storeName], "readwrite");
+            const store = transaction.objectStore(this.storeName);
+            let completed = 0;
+            let hasError = false;
+            eventIds.forEach((eventId) => {
+                const getRequest = store.get(eventId);
+                getRequest.onsuccess = () => {
+                    if (getRequest.result) {
+                        const record = { ...getRequest.result, sent: true };
+                        const putRequest = store.put(record);
+                        putRequest.onsuccess = () => {
+                            completed++;
+                            if (completed === eventIds.length && !hasError) {
+                                resolve();
+                            }
+                        };
+                        putRequest.onerror = () => {
+                            hasError = true;
+                            this.logger.error("Failed to mark event as sent:", putRequest.error);
+                            reject(putRequest.error);
+                        };
+                    }
+                    else {
+                        completed++;
+                        if (completed === eventIds.length && !hasError) {
+                            resolve();
+                        }
+                    }
+                };
+                getRequest.onerror = () => {
+                    hasError = true;
+                    this.logger.error("Failed to get event for marking as sent:", getRequest.error);
+                    reject(getRequest.error);
+                };
+            });
+        });
+    }
+    async cleanupOldEvents(maxAge = 7 * 24 * 60 * 60 * 1000) {
+        if (!this.db) {
+            return;
+        }
+        const cutoffTime = Date.now() - maxAge;
+        return new Promise((resolve, reject) => {
+            const transaction = this.db.transaction([this.storeName], "readwrite");
+            const store = transaction.objectStore(this.storeName);
+            const index = store.index("queued_at");
+            const request = index.openCursor(IDBKeyRange.upperBound(cutoffTime));
+            request.onsuccess = () => {
+                const cursor = request.result;
+                if (cursor) {
+                    cursor.delete();
+                    cursor.continue();
+                }
+                else {
+                    this.logger.info("Old events cleanup completed");
+                    resolve();
+                }
+            };
+            request.onerror = () => {
+                this.logger.error("Failed to cleanup old events:", request.error);
+                reject(request.error);
+            };
+        });
+    }
+    async getQueueSize() {
+        if (!this.db) {
+            return 0;
+        }
+        return new Promise((resolve, reject) => {
+            const transaction = this.db.transaction([this.storeName], "readonly");
+            const store = transaction.objectStore(this.storeName);
+            const request = store.count();
+            request.onsuccess = () => {
+                resolve(request.result);
+            };
+            request.onerror = () => {
+                this.logger.error("Failed to get queue size:", request.error);
+                reject(request.error);
+            };
+        });
+    }
+    async clear() {
+        if (!this.db) {
+            return;
+        }
+        return new Promise((resolve, reject) => {
+            const transaction = this.db.transaction([this.storeName], "readwrite");
+            const store = transaction.objectStore(this.storeName);
+            const request = store.clear();
+            request.onsuccess = () => {
+                this.logger.info("IndexedDB queue cleared");
+                resolve();
+            };
+            request.onerror = () => {
+                this.logger.error("Failed to clear IndexedDB queue:", request.error);
+                reject(request.error);
+            };
+        });
+    }
+}
+// Attribution storage manager
+export class AttributionStorageManager {
+    constructor(logger) {
+        this.UTM_STORAGE_KEY = "attribution_utm_data";
+        this.SESSION_STORAGE_KEY = "attribution_session";
+        this.logger = logger;
+        this.localStorage = new LocalStorageManager(logger);
+        this.indexedDB = new IndexedDBManager(logger);
+    }
+    async init() {
+        await this.indexedDB.init();
+    }
+    // UTM data management
+    storeUTMData(utmData) {
+        try {
+            const existingData = this.getUTMData();
+            // Create default UTM data if none exists
+            const defaultUTMData = {
+                utm_source: "",
+                utm_medium: "",
+                utm_campaign: "",
+                utm_term: "",
+                utm_content: "",
+                timestamp: Date.now(),
+            };
+            const newData = {
+                firstTouch: existingData?.firstTouch || defaultUTMData,
+                lastTouch: existingData?.lastTouch || defaultUTMData,
+                touchpoints: existingData?.touchpoints || [],
+                ...utmData,
+                expiresAt: Date.now() + 30 * 24 * 60 * 60 * 1000, // 30 days
+            };
+            this.localStorage.set(this.UTM_STORAGE_KEY, newData);
+            this.logger.debug("UTM data stored successfully:", {
+                firstTouch: newData.firstTouch,
+                lastTouch: newData.lastTouch,
+                touchpointsCount: newData.touchpoints.length,
+                expiresAt: new Date(newData.expiresAt).toISOString(),
+            });
+        }
+        catch (error) {
+            this.logger.error("Failed to store UTM data:", error);
+        }
+    }
+    getUTMData() {
+        const data = this.localStorage.get(this.UTM_STORAGE_KEY);
+        if (data && data.expiresAt && data.expiresAt > Date.now()) {
+            return data;
+        }
+        // Clean up expired data
+        if (data) {
+            this.localStorage.remove(this.UTM_STORAGE_KEY);
+        }
+        return null;
+    }
+    // Session management
+    storeSession(session) {
+        this.localStorage.set(this.SESSION_STORAGE_KEY, session);
+    }
+    getSession() {
+        return this.localStorage.get(this.SESSION_STORAGE_KEY);
+    }
+    // Event queue management
+    async queueEvent(event) {
+        try {
+            await this.indexedDB.addEvent(event);
+        }
+        catch (error) {
+            this.logger.error("Failed to queue event:", error);
+            throw error;
+        }
+    }
+    async getUnsentEvents(limit = 100) {
+        return await this.indexedDB.getUnsentEvents(limit);
+    }
+    async markEventsAsSent(eventIds) {
+        await this.indexedDB.markEventsAsSent(eventIds);
+    }
+    async getQueueSize() {
+        return await this.indexedDB.getQueueSize();
+    }
+    async cleanupOldEvents() {
+        await this.indexedDB.cleanupOldEvents();
+    }
+    async clearQueue() {
+        await this.indexedDB.clear();
+    }
+    // Cleanup expired data
+    cleanupExpiredData() {
+        this.getUTMData(); // This will automatically clean up expired UTM data
+    }
+}