@zaplier/sdk 1.6.3 → 1.6.5

package/dist/index.cjs

@@ -19773,31 +19773,12 @@ class PersistenceManager {
 PersistenceManager.memoryStore = new Map();
 /**
  * Advanced Visitor Identity Manager with Camouflaged Storage
+ * REFACTORED: No longer generates visitor IDs locally - only manages persistence
+ * Backend is the single source of truth for visitor IDs
  */
 class VisitorIdentityManager {
-    generateVisitorId() {
-        // Generate UUID v4 format instead of vis_ prefix
-        const bytes = crypto.getRandomValues(new Uint8Array(16));
-        // Set version 4
-        bytes[6] = (bytes[6] & 0x0f) | 0x40;
-        // Set variant
-        bytes[8] = (bytes[8] & 0x3f) | 0x80;
-        const hex = Array.from(bytes).map(b => b.toString(16).padStart(2, '0')).join('');
-        return `${hex.substr(0, 8)}-${hex.substr(8, 4)}-${hex.substr(12, 4)}-${hex.substr(16, 4)}-${hex.substr(20, 12)}`;
-    }
-    generateVisitorIdFromHash(hash) {
-        // Generate deterministic UUID v4 format from fingerprint hash
-        // This ensures same fingerprint = same visitor ID
-        const hashExtended = hash.length >= 32 ? hash : (hash + hash + hash + hash).substring(0, 32);
-        // Extract hex characters for UUID construction
-        const hex = hashExtended.substring(0, 32);
-        const chars = hex.split('');
-        // Set version 4 and variant bits according to RFC 4122
-        chars[12] = '4'; // Version 4
-        chars[16] = (parseInt(chars[16] || '0', 16) & 0x3 | 0x8).toString(16); // Variant 10
-        // Format as UUID: xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx
-        return `${chars.slice(0, 8).join('')}-${chars.slice(8, 12).join('')}-${chars.slice(12, 16).join('')}-${chars.slice(16, 20).join('')}-${chars.slice(20, 32).join('')}`;
-    }
+    // REMOVED: generateVisitorId() and generateVisitorIdFromHash() methods
+    // SDK no longer generates visitor IDs - only backend does
     generateSessionId() {
         return "ses_" + Array.from(crypto.getRandomValues(new Uint8Array(8)))
             .map(b => b.toString(16).padStart(2, '0'))
@@ -19837,14 +19818,18 @@ class VisitorIdentityManager {
         }
         return null;
     }
+    /**
+     * REFACTORED: Get existing visitor identity or prepare for backend response
+     * No longer generates visitor IDs - waits for backend to provide them
+     */
     async getOrCreateVisitorIdentity(params) {
         const { stableCoreHash } = params;
         // Try to recover existing identity from camouflaged storage
         const { value: storedData, method } = PersistenceManager.get(STORAGE_KEYS.prefs);
         if (storedData) {
             const existingIdentity = this.extractFromCamouflage(storedData);
-            if (existingIdentity && existingIdentity.stableCoreHash === stableCoreHash) {
-                // Update last seen time
+            if (existingIdentity && existingIdentity.stableCoreHash === stableCoreHash && existingIdentity.visitorId) {
+                // Update last seen time only if we have a valid visitor ID from backend
                 const updatedCamouflage = this.createCamouflageData(existingIdentity.visitorId, existingIdentity.sessionId, stableCoreHash);
                 PersistenceManager.set(STORAGE_KEYS.prefs, JSON.stringify(updatedCamouflage));
                 return {
@@ -19855,30 +19840,55 @@ class VisitorIdentityManager {
                 };
             }
         }
-        // Create new visitor identity (deterministic from fingerprint)
-        // Use stableCoreHash for deterministic visitor ID generation
-        // This ensures same fingerprint = same visitor ID across devices and sessions
-        const deterministicVisitorId = this.generateVisitorIdFromHash(params.stableCoreHash);
+        // CHANGED: Create identity without visitor ID - will be set by backend response
         const newSessionId = params.sessionId || this.generateSessionId();
         const newIdentity = {
-            visitorId: deterministicVisitorId,
+            // visitorId: undefined, // Will be set when backend responds
             sessionId: newSessionId,
             stableCoreHash,
             deviceFingerprint: params.deviceFingerprint,
-            persistenceMethod: "localStorage",
+            persistenceMethod: "memory", // Start with memory, upgrade after backend response
             confidence: 0.90,
             createdAt: Date.now(),
             lastSeen: Date.now(),
             reused: false,
+            pendingBackendResponse: true, // Flag to indicate waiting for backend
         };
-        // Store in camouflaged format
-        const camouflageData = this.createCamouflageData(deterministicVisitorId, newSessionId, stableCoreHash);
-        const { method: storageMethod } = PersistenceManager.set(STORAGE_KEYS.prefs, JSON.stringify(camouflageData));
-        newIdentity.persistenceMethod = storageMethod;
-        // Also store device fingerprint cache for faster lookups
-        PersistenceManager.set(STORAGE_KEYS.device, params.deviceFingerprint);
         return newIdentity;
     }
+    /**
+     * NEW: Update visitor identity with visitor ID received from backend
+     * This is called after backend responds with the definitive visitor ID
+     */
+    async updateVisitorIdFromBackend(visitorId, stableCoreHash, sessionId) {
+        try {
+            // Create or update camouflaged data with backend visitor ID
+            const currentSessionId = sessionId || this.getCurrentSessionId() || this.generateSessionId();
+            const camouflageData = this.createCamouflageData(visitorId, currentSessionId, stableCoreHash);
+            const { success, method } = PersistenceManager.set(STORAGE_KEYS.prefs, JSON.stringify(camouflageData));
+            if (success) {
+                // Also update device fingerprint cache
+                PersistenceManager.set(STORAGE_KEYS.device, stableCoreHash);
+                return true;
+            }
+            return false;
+        }
+        catch (error) {
+            console.error('[VisitorIdentityManager] Failed to update visitor ID from backend:', error);
+            return false;
+        }
+    }
+    /**
+     * Get current session ID from storage
+     */
+    getCurrentSessionId() {
+        const { value: storedData } = PersistenceManager.get(STORAGE_KEYS.prefs);
+        if (storedData) {
+            const identity = this.extractFromCamouflage(storedData);
+            return identity?.sessionId || null;
+        }
+        return null;
+    }
     // Get current visitor ID without creating new one
     getCurrentVisitorId() {
         const { value: storedData } = PersistenceManager.get(STORAGE_KEYS.prefs);
@@ -19938,7 +19948,7 @@ const DEFAULT_CONFIG = {
  */
 class ZaplierSDK {
     constructor(userConfig) {
-        this.version = "1.6.0";
+        this.version = "1.7.0";
         this.isInitialized = false;
         this.eventQueue = [];
         /**
@@ -20365,7 +20375,8 @@ class ZaplierSDK {
                         sdkVersion: this.version,
                     };
                 }
-                // Generate or retrieve visitor identity using persistent storage
+                // CHANGED: Check for existing visitor identity but don't set local visitor ID
+                // Only backend generates visitor IDs now
                 const visitorIdentity = await this.visitorIdentityManager.getOrCreateVisitorIdentity({
                     fingerprintHash: result.data.hash,
                     stableCoreHash: result.data.stableCoreHash,
@@ -20374,8 +20385,13 @@ class ZaplierSDK {
                     userAgent: navigator.userAgent,
                     ipAddress: undefined, // Will be determined server-side
                 });
-                // Set the persistent visitor ID
-                this.visitorId = visitorIdentity.visitorId;
+                // CHANGED: Only use visitor ID if it exists from previous backend response
+                // Do not generate any visitor IDs locally
+                if (visitorIdentity.visitorId && !visitorIdentity.pendingBackendResponse) {
+                    this.visitorId = visitorIdentity.visitorId;
+                    this.backendVisitorId = visitorIdentity.visitorId; // Ensure consistency
+                }
+                // If no visitor ID exists, leave both null - backend will provide it
                 if (this.config.debug) {
                     console.log("[Zaplier] Visitor identity resolved:", {
                         visitorId: this.visitorId,
@@ -20491,8 +20507,8 @@ class ZaplierSDK {
         try {
             const payload = {
                 // workspaceId moved to query parameter
-                // Visitor ID (persistido via localStorage camuflado)
-                visitorId: this.visitorId,
+                // CHANGED: Only send visitor ID if it came from backend (not locally generated)
+                visitorId: this.backendVisitorId || this.getVisitorId(),
                 // Session ID (gerado por sessão)
                 sessionId: this.sessionId,
                 fingerprintHash: this.fingerprint?.hash,
@@ -20544,11 +20560,25 @@ class ZaplierSDK {
                 gdprMode: this.config.gdprMode,
             };
             const response = await this.makeRequest(`/tracking/event?token=${encodeURIComponent(this.config.token)}`, payload);
-            // Store backend visitor ID and session ID from response
+            // ENHANCED: Store backend visitor ID in both memory and persistent storage
             if (response.visitorId) {
                 this.backendVisitorId = response.visitorId;
+                // Update persistent storage with backend visitor ID
+                if (this.visitorIdentityManager && this.fingerprint?.stableCoreHash) {
+                    try {
+                        await this.visitorIdentityManager.updateVisitorIdFromBackend(response.visitorId, this.fingerprint.stableCoreHash, this.sessionId);
+                        if (this.config.debug) {
+                            console.log("[Zaplier] Backend visitor ID saved to localStorage:", response.visitorId);
+                        }
+                    }
+                    catch (error) {
+                        if (this.config.debug) {
+                            console.error("[Zaplier] Failed to save backend visitor ID to storage:", error);
+                        }
+                    }
+                }
                 if (this.config.debug) {
-                    console.log("[Zaplier] Backend visitor ID received:", response.visitorId);
+                    console.log("[Zaplier] Backend visitor ID received and processed:", response.visitorId);
                 }
             }
             if (response.sessionId) {
@@ -20876,10 +20906,30 @@ class ZaplierSDK {
         return this.config.enhancedTracking === "true" && !this.config.gdprMode;
     }
     /**
-     * Get visitor ID (real UUID from backend, or fallback)
+     * Get visitor ID (prioritizes backend, then persistent storage)
+     * ENHANCED: Checks persistent storage if memory values are missing
      */
     getVisitorId() {
-        return this.backendVisitorId || this.visitorId || null;
+        // Priority 1: Backend visitor ID from memory (most recent)
+        if (this.backendVisitorId) {
+            return this.backendVisitorId;
+        }
+        // Priority 2: Local visitor ID from memory (deprecated but kept for compatibility)
+        if (this.visitorId) {
+            return this.visitorId;
+        }
+        // Priority 3: Check persistent storage for backend visitor ID
+        if (this.visitorIdentityManager) {
+            const storedVisitorId = this.visitorIdentityManager.getCurrentVisitorId();
+            if (storedVisitorId) {
+                // Update memory cache for future calls
+                this.backendVisitorId = storedVisitorId;
+                this.visitorId = storedVisitorId;
+                return storedVisitorId;
+            }
+        }
+        // No visitor ID available - will be set after first backend response
+        return null;
     }
     /**
      * Get visitor information from backend