cryptique-sdk 1.2.20 → 1.2.21

package/lib/umd/index.js

@@ -96,8 +96,8 @@
 
       // Geolocation API
       GEOLOCATION: {
-        PRIMARY_URL: "https://ipinfo.io/json?token=8fc6409059aa39",
-        BACKUP_URL: "https://ipinfo.io/json?token=8fc6409059aa39&http=1.1",
+        PRIMARY_URL: "https://ipinfo.io/json?token=3a0c034aefbef8",
+        BACKUP_URL: "https://ipinfo.io/json?token=3a0c034aefbef8&http=1.1",
         TIMEOUT_MS: 5000                                  // 5 second timeout
       },
 
@@ -1143,7 +1143,6 @@
       isFirstPage: true,
       
       // JSONB fields
-      interactions: {},
       visited_pages: [],
       
       // Also stored in locationData object for structured access (backward compatibility)
@@ -2088,7 +2087,6 @@
         if (sessionData.utm_id === undefined) sessionData.utm_id = null;
         
         // JSONB fields
-        if (!sessionData.interactions) sessionData.interactions = {};
         if (!sessionData.visited_pages) sessionData.visited_pages = [];
         
         // Internal tracking
@@ -2153,8 +2151,7 @@
           // UTM fields (already snake_case, no mapping needed)
           
           // JSONB fields
-          'visited_pages': 'visited_pages',  // Already snake_case
-          'interactions': 'interactions'     // Already snake_case
+          'visited_pages': 'visited_pages'   // Already snake_case
         };
         
         return fieldMap[internalName] || this.toSnakeCase(internalName);
@@ -3198,333 +3195,24 @@
       }
     };
 
-    // ============================================================================
-    // SECTION 10: INTERACTION MANAGEMENT
-    // ============================================================================
-    // PURPOSE: Single source of truth for interaction tracking and management.
-    //          Handles all user interactions (clicks, forms, scroll, hover, etc.)
-    //
-    // KEY PRINCIPLES:
-    // 1. All interactions stored in categorized structure
-    // 2. Automatic timestamp addition
-    // 3. Total interactions count maintained
-    // 4. Chronological sorting for backend
-    // 5. Immediate session storage updates
-    // 6. Prevents duplicate interactions
-    //
-    // BENEFITS:
-    // - Centralized interaction tracking
-    // - Consistent data structure
-    // - Single place to fix interaction bugs
-    // - Prevents repeating interactions
-    // ============================================================================
+    // SECTION 10: INTERACTION MANAGEMENT — REMOVED
+    // Interactions JSONB tracking has been removed from sessions.
+    // Important signals (clicks, errors, etc.) are captured as individual
+    // queryable auto events in the events table instead.
 
-    /**
-     * InteractionManager - Interaction tracking and management
-     * 
-     * This object handles all user interaction tracking, storage, and management
-     */
+    // No-op stub — all methods removed with interactions feature.
     const InteractionManager = {
-      /**
-       * Interaction categories
-       * 
-       * All supported interaction categories
-       */
-      CATEGORIES: [
-        'clicks',
-        'formInteractions',
-        'mediaInteractions',
-        'scrollEvents',
-        'focusEvents',
-        'hoverEvents',
-        'formSubmissions',
-        'fieldChanges',
-        'validationErrors',
-        'keyboardEvents',
-        'copyPasteEvents',
-        'contextMenuEvents',
-        'dragDropEvents',
-        'touchEvents',
-        'windowEvents',
-        'performanceEvents',
-        'errorEvents',
-        'networkEvents',
-        'formAnalytics'
-      ],
-
-      /**
-       * Initialize interactions structure
-       * 
-       * Creates empty interactions object with all categories
-       */
-      initialize() {
-        if (!sessionData.interactions || Object.keys(sessionData.interactions).length === 0) {
-          sessionData.interactions = {
-            totalInteractions: 0,
-            clicks: [],
-            formInteractions: [],
-            mediaInteractions: [],
-            scrollEvents: [],
-            focusEvents: [],
-            hoverEvents: [],
-            formSubmissions: [],
-            fieldChanges: [],
-            validationErrors: [],
-            keyboardEvents: [],
-            copyPasteEvents: [],
-            contextMenuEvents: [],
-            dragDropEvents: [],
-            touchEvents: [],
-            windowEvents: [],
-            performanceEvents: [],
-            errorEvents: [],
-            networkEvents: [],
-            formAnalytics: []
-          };
-        }
-      },
-
-      /**
-       * Add interaction to appropriate category
-       * 
-       * Logic:
-       * 1. Ensures interactions are initialized
-       * 2. Adds timestamp if not provided
-       * 3. Adds to specific category array
-       * 4. Updates total interactions count
-       * 5. Updates session activity
-       * 6. Immediately updates session storage
-       * 
-       * Parameters:
-       * - category: Interaction category (e.g., 'clicks', 'formInteractions')
-       * - interactionData: Interaction data object
-       */
-      add(category, interactionData) {
-        // Ensure interactions are initialized
-        this.initialize();
-
-        // Validate category
-        if (!this.CATEGORIES.includes(category)) {
-          return;
-        }
-
-        // Add timestamp if not provided
-        if (!interactionData.timestamp) {
-          interactionData.timestamp = nowIso();
-        }
-
-        // Add to specific category
-        if (sessionData.interactions[category]) {
-          sessionData.interactions[category].push(interactionData);
-        }
-
-        // Update total interactions count
-        this.updateTotalCount();
-
-        // Update last activity
-        sessionData.lastActivity = Date.now();
-
-        // Immediately update session storage
-        this.updateSessionStorage();
-      },
-
-      /**
-       * Update total interactions count
-       * 
-       * Calculates total from all category arrays
-       */
-      updateTotalCount() {
-        if (!sessionData.interactions) return;
-
-        let total = 0;
-        for (const category of this.CATEGORIES) {
-          if (sessionData.interactions[category] && Array.isArray(sessionData.interactions[category])) {
-            total += sessionData.interactions[category].length;
-          }
-        }
-
-        sessionData.interactions.totalInteractions = total;
-      },
-
-      /**
-       * Update session storage with interactions
-       * 
-       * Immediately syncs interactions to session storage
-       */
-      updateSessionStorage() {
-        try {
-          const storedSession = StorageManager.loadSession();
-          if (storedSession && storedSession.sessionData) {
-            storedSession.sessionData.interactions = sessionData.interactions;
-            StorageManager.saveSession(storedSession);
-          }
-        } catch (error) {
-          }
-      },
-
-      /**
-       * Get all interactions sorted chronologically
-       * 
-       * Collects all interactions from all categories, adds category identifiers,
-       * and sorts by timestamp
-       * 
-       * Returns: Array of interactions sorted by timestamp
-       */
-      getChronological() {
-        if (!sessionData.interactions) {
-          return [];
-        }
-
-        const allInteractions = [];
-
-        // Map of category to category identifier
-        const categoryMap = {
-          'clicks': { category: 'click', originalCategory: 'clicks' },
-          'formInteractions': { category: 'formInteraction', originalCategory: 'formInteractions' },
-          'mediaInteractions': { category: 'mediaInteraction', originalCategory: 'mediaInteractions' },
-          'scrollEvents': { category: 'scrollEvent', originalCategory: 'scrollEvents' },
-          'focusEvents': { category: 'focusEvent', originalCategory: 'focusEvents' },
-          'hoverEvents': { category: 'hoverEvent', originalCategory: 'hoverEvents' },
-          'formSubmissions': { category: 'formSubmission', originalCategory: 'formSubmissions' },
-          'fieldChanges': { category: 'fieldChange', originalCategory: 'fieldChanges' },
-          'validationErrors': { category: 'validationError', originalCategory: 'validationErrors' },
-          'keyboardEvents': { category: 'keyboardEvent', originalCategory: 'keyboardEvents' },
-          'copyPasteEvents': { category: 'copyPasteEvent', originalCategory: 'copyPasteEvents' },
-          'contextMenuEvents': { category: 'contextMenuEvent', originalCategory: 'contextMenuEvents' },
-          'dragDropEvents': { category: 'dragDropEvent', originalCategory: 'dragDropEvents' },
-          'touchEvents': { category: 'touchEvent', originalCategory: 'touchEvents' },
-          'windowEvents': { category: 'windowEvent', originalCategory: 'windowEvents' },
-          'performanceEvents': { category: 'performanceEvent', originalCategory: 'performanceEvents' },
-          'errorEvents': { category: 'errorEvent', originalCategory: 'errorEvents' },
-          'networkEvents': { category: 'networkEvent', originalCategory: 'networkEvents' },
-          'formAnalytics': { category: 'formAnalytic', originalCategory: 'formAnalytics' }
-        };
-
-        // Collect all interactions from all categories
-        for (const category of this.CATEGORIES) {
-          if (sessionData.interactions[category] && Array.isArray(sessionData.interactions[category])) {
-            const categoryInfo = categoryMap[category];
-            sessionData.interactions[category].forEach(interaction => {
-              allInteractions.push({
-                ...interaction,
-                category: categoryInfo.category,
-                originalCategory: categoryInfo.originalCategory
-              });
-            });
-          }
-        }
-
-        // Sort by timestamp (chronological order)
-        allInteractions.sort((a, b) => {
-          const timestampA = new Date(a.timestamp || 0);
-          const timestampB = new Date(b.timestamp || 0);
-          return timestampA - timestampB;
-        });
-
-        return allInteractions;
-      },
-
-      /**
-       * Get chronological interactions for backend
-       * 
-       * Returns both chronological array and categorized structure
-       * 
-       * Returns: Object with chronological and categorized interactions
-       */
-      getChronologicalForBackend() {
-        const chronological = this.getChronological();
-
-        return {
-          chronological: chronological,
-          categorized: sessionData.interactions
-        };
-      },
-
-      /**
-       * Deduplicate interactions
-       * 
-       * Removes duplicate interactions based on timestamp, category, and key fields
-       * 
-       * Logic:
-       * - Compares interactions by timestamp, category, and element identifier
-       * - Keeps first occurrence of duplicates
-       * - Updates total count after deduplication
-       */
-      deduplicate() {
-        if (!sessionData.interactions) return;
-
-        const seen = new Set();
-
-        for (const category of this.CATEGORIES) {
-          if (sessionData.interactions[category] && Array.isArray(sessionData.interactions[category])) {
-            sessionData.interactions[category] = sessionData.interactions[category].filter(interaction => {
-              // Create unique key from timestamp, category, and element identifier
-              const elementId = interaction.elementId || interaction.target || interaction.selector || '';
-              const key = `${interaction.timestamp}_${category}_${elementId}`;
-
-              if (seen.has(key)) {
-                return false; // Duplicate, remove
-              }
-
-              seen.add(key);
-              return true; // Keep
-            });
-          }
-        }
-
-        // Update total count after deduplication
-        this.updateTotalCount();
-
-        // Update session storage
-        this.updateSessionStorage();
-      },
-
-      /**
-       * Get interactions by category
-       * 
-       * Returns all interactions for a specific category
-       * 
-       * Parameters: category - Interaction category name
-       * Returns: Array of interactions for that category
-       */
-      getByCategory(category) {
-        if (!sessionData.interactions) {
-          return [];
-        }
-
-        if (!this.CATEGORIES.includes(category)) {
-          return [];
-        }
-
-        return sessionData.interactions[category] || [];
-      },
-
-      /**
-       * Get total interactions count
-       * 
-       * Returns total number of interactions across all categories
-       */
-      getTotalCount() {
-        if (!sessionData.interactions) {
-          return 0;
-        }
-
-        return sessionData.interactions.totalInteractions || 0;
-      },
-
-      /**
-       * Clear all interactions
-       * 
-       * Resets interactions object to empty state
-       */
-      clear() {
-        this.initialize();
-        for (const category of this.CATEGORIES) {
-          sessionData.interactions[category] = [];
-        }
-        sessionData.interactions.totalInteractions = 0;
-        this.updateSessionStorage();
-      }
+      CATEGORIES: [],
+      initialize() {},
+      add() {},
+      updateTotalCount() {},
+      updateSessionStorage() {},
+      getChronological() { return []; },
+      getChronologicalForBackend() { return { chronological: [], categorized: {} }; },
+      deduplicate() {},
+      getByCategory() { return []; },
+      getTotalCount() { return 0; },
+      clear() {}
     };
 
     // ============================================================================
@@ -3992,7 +3680,6 @@
         // Ensure arrays exist
         s.pageVisits = s.pageVisits || [];
         s.visited_pages = s.visited_pages || [];
-        s.interactions = s.interactions || { totalInteractions: 0 };
         
         // Normalize timestamps to ISO strings
         if (s.startTime && !(typeof s.startTime === 'string')) {
@@ -4047,171 +3734,8 @@
         // First normalize the shape
         sourceData = this.normalizeShape(sourceData);
         
-        // Get chronological interactions
-        const chronologicalInteractions = InteractionManager.getChronologicalForBackend();
-        
-        // Get page visits and session-level interactions
+        // Get page visits
         const pageVisits = sourceData.visited_pages || sourceData.pageVisits || sourceData.visitedPages || [];
-        const sessionInteractions = sourceData.interactions || {};
-        
-        // CRITICAL FIX: Distribute session-level interactions to appropriate pages based on path
-        const interactionTypes = [
-          'clicks', 'mediaInteractions', 'contextMenuEvents', 'windowEvents',
-          'formInteractions', 'scrollEvents', 'focusEvents', 'hoverEvents',
-          'formSubmissions', 'fieldChanges',
-          'keyboardEvents', 'copyPasteEvents', 'dragDropEvents',
-          'touchEvents', 'formAnalytics'
-          // Note: validationErrors, performanceEvents, errorEvents, networkEvents are no longer
-          // stored in session interactions — they are emitted as individual queryable auto events
-          // (form_validation_error, page_performance, js_error, network_error)
-        ];
-        
-        // Helper to normalize path for matching
-        const normalizePathForMatching = (path) => {
-          if (!path) return '/';
-          // Remove query params and hash
-          const cleanPath = path.split('?')[0].split('#')[0];
-          return cleanPath || '/';
-        };
-        
-        // Get session start time in milliseconds for alignment
-        const sessionStartTime = sourceData.start_time || sourceData.startTime;
-        const sessionStartMs = sessionStartTime 
-          ? (typeof sessionStartTime === 'string' ? new Date(sessionStartTime).getTime() : sessionStartTime)
-          : Date.now();
-        
-        // Distribute interactions to pages and fix mount/unmount times
-        // CRITICAL: Create copies to avoid mutating original objects
-        const pagesWithInteractions = pageVisits.map((pageVisit, index) => {
-          // Create a copy of the page visit to avoid mutating the original
-          const pageVisitCopy = { ...pageVisit };
-          const pagePath = normalizePathForMatching(pageVisitCopy.path || pageVisitCopy.url);
-          const isFirstPage = index === 0 || pageVisitCopy.isEntry === true;
-          
-          // CRITICAL FIX: If unmountTime is null, set it to next page's mountTime
-          if (!pageVisitCopy.unmountTime && index < pageVisits.length - 1) {
-            const nextPage = pageVisits[index + 1];
-            if (nextPage && nextPage.mountTime) {
-              pageVisitCopy.unmountTime = typeof nextPage.mountTime === 'number' 
-                ? nextPage.mountTime 
-                : new Date(nextPage.mountTime).getTime();
-              // Recalculate duration
-              if (pageVisitCopy.mountTime) {
-                const mountMs = typeof pageVisitCopy.mountTime === 'number'
-                  ? pageVisitCopy.mountTime
-                  : new Date(pageVisitCopy.mountTime).getTime();
-                pageVisitCopy.duration = Math.floor((pageVisitCopy.unmountTime - mountMs) / 1000);
-              }
-            }
-          }
-          
-          // If still no unmountTime and this is the last page, set to session endTime
-          if (!pageVisitCopy.unmountTime && index === pageVisits.length - 1) {
-            const endTime = sourceData.end_time || sourceData.endTime;
-            if (endTime) {
-              pageVisitCopy.unmountTime = typeof endTime === 'number'
-                ? endTime
-                : new Date(endTime).getTime();
-              // Recalculate duration
-              if (pageVisitCopy.mountTime) {
-                const mountMs = typeof pageVisitCopy.mountTime === 'number'
-                  ? pageVisitCopy.mountTime
-                  : new Date(pageVisitCopy.mountTime).getTime();
-                pageVisitCopy.duration = Math.floor((pageVisitCopy.unmountTime - mountMs) / 1000);
-              }
-            }
-          }
-          
-          // FIX: Align first page mountTime with session start_time (only in copy, not original)
-          if (isFirstPage && pageVisitCopy.mountTime) {
-            const mountTimeMs = typeof pageVisitCopy.mountTime === 'number' 
-              ? pageVisitCopy.mountTime 
-              : new Date(pageVisitCopy.mountTime).getTime();
-            
-            // If mountTime is more than 5 minutes off from session start, align it
-            const timeDiff = Math.abs(mountTimeMs - sessionStartMs);
-            if (timeDiff > 5 * 60 * 1000) { // More than 5 minutes difference
-              pageVisitCopy.mountTime = sessionStartMs;
-              // Recalculate duration if unmountTime exists
-              if (pageVisitCopy.unmountTime) {
-                const unmountTimeMs = typeof pageVisitCopy.unmountTime === 'number'
-                  ? pageVisitCopy.unmountTime
-                  : new Date(pageVisitCopy.unmountTime).getTime();
-                pageVisitCopy.duration = Math.floor((unmountTimeMs - sessionStartMs) / 1000);
-              }
-            }
-          }
-          
-          // Ensure mountTime and unmountTime are numbers (milliseconds) for consistency (in copy only)
-          if (pageVisitCopy.mountTime && typeof pageVisitCopy.mountTime !== 'number') {
-            pageVisitCopy.mountTime = new Date(pageVisitCopy.mountTime).getTime();
-          }
-          if (pageVisitCopy.unmountTime && typeof pageVisitCopy.unmountTime !== 'number') {
-            pageVisitCopy.unmountTime = new Date(pageVisitCopy.unmountTime).getTime();
-          }
-          
-          // Initialize interactions object for this page if it doesn't exist (in copy)
-          if (!pageVisitCopy.interactions) {
-            pageVisitCopy.interactions = {
-              totalInteractions: 0,
-              clicks: [],
-              mediaInteractions: [],
-              contextMenuEvents: [],
-              windowEvents: [],
-              formInteractions: [],
-              scrollEvents: [],
-              focusEvents: [],
-              hoverEvents: [],
-              formSubmissions: [],
-              fieldChanges: [],
-              validationErrors: [],
-              keyboardEvents: [],
-              copyPasteEvents: [],
-              dragDropEvents: [],
-              touchEvents: [],
-              performanceEvents: [],
-              errorEvents: [],
-              networkEvents: [],
-              formAnalytics: []
-            };
-          }
-          
-          // Distribute interactions from session-level to this page based on path matching (in copy)
-          interactionTypes.forEach(type => {
-            if (Array.isArray(sessionInteractions[type])) {
-              sessionInteractions[type].forEach(interaction => {
-                const interactionPath = normalizePathForMatching(interaction.path);
-                if (interactionPath === pagePath) {
-                  // Add interaction to this page (avoid duplicates)
-                  const exists = pageVisitCopy.interactions[type].some(existing => {
-                    // Check for duplicates based on timestamp and key properties
-                    if (existing.timestamp && interaction.timestamp) {
-                      return existing.timestamp === interaction.timestamp;
-                    }
-                    // For clicks, check element properties
-                    if (type === 'clicks' && existing.element && interaction.element) {
-                      return existing.element.id === interaction.element.id &&
-                             existing.element.tagName === interaction.element.tagName;
-                    }
-                    return false;
-                  });
-                  
-                  if (!exists) {
-                    pageVisitCopy.interactions[type].push(interaction);
-                  }
-                }
-              });
-            }
-          });
-          
-          // Calculate totalInteractions for this page (in copy)
-          const total = interactionTypes.reduce((sum, type) => {
-            return sum + (pageVisitCopy.interactions[type]?.length || 0);
-          }, 0);
-          pageVisitCopy.interactions.totalInteractions = total;
-          
-          return pageVisitCopy;
-        });
         
         // Create transformed object - PostgreSQL snake_case format only
         const transformed = {
@@ -4276,12 +3800,8 @@
           utm_content: sourceData.utm_content || sourceData.utmData?.content || null,
           utm_id: sourceData.utm_id || sourceData.utmData?.utm_id || null,
           
-          // JSONB fields - NOW WITH INTERACTIONS DISTRIBUTED TO PAGES
-          visited_pages: pagesWithInteractions,
-          interactions: {
-            ...sessionInteractions,
-            chronological: chronologicalInteractions.chronological || []
-          },
+          // JSONB fields
+          visited_pages: pageVisits,
 
           // Active tab time in ms (tab foreground time only, for active_time_seconds in DB)
           active_time_ms: sourceData.active_time_ms || null
@@ -4949,12 +4469,6 @@
               if (hoveredElements.has(elementId)) {
                 hoveredElements.delete(elementId);
                 
-                // Update hover duration in the interaction
-                const interactions = InteractionManager.getByCategory('hoverEvents');
-                const hoverEvent = interactions.find(h => h.elementId === elementId);
-                if (hoverEvent) {
-                  hoverEvent.hoverDuration = Date.now() - new Date(hoverEvent.timestamp).getTime();
-                }
               }
             }
           });
@@ -6273,9 +5787,6 @@
           // Initialize session data structure
           SessionDataManager.initialize(sessionId, userId);
           
-          // Initialize interactions
-          InteractionManager.initialize();
-          
           // Initialize page visits
           PageVisitManager.initialize();
         } catch (error) {
@@ -6418,15 +5929,6 @@
                   sessionData.pagesViewed = sessionData.visited_pages.length;
                 }
 
-                // Sync interactions
-                if (storedSession.sessionData.interactions) {
-                  const storedInteractions = storedSession.sessionData.interactions;
-                  if (storedInteractions.totalInteractions > 
-                      (sessionData.interactions?.totalInteractions || 0)) {
-                    // Update interactions from storage
-                    sessionData.interactions = storedInteractions;
-                  }
-                }
               }
 
               // Update endTime
@@ -6489,9 +5991,6 @@
                   }));
                   sessionData.pagesViewed = sessionData.visited_pages.length;
                 }
-                if (storedSession.sessionData.interactions) {
-                  sessionData.interactions = storedSession.sessionData.interactions;
-                }
               }
 
               // Track browser close (last page unmount)
@@ -8674,10 +8173,6 @@
         return sessionData;
       },
       
-      // Interaction Functions
-      getChronologicalInteractions: InteractionManager.getChronological.bind(InteractionManager),
-      sortInteractionsChronologically: InteractionManager.getChronological.bind(InteractionManager),
-      
       // Auto Events Configuration
       enableAutoEvents: function() {
         CONFIG.AUTO_EVENTS.enabled = true;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cryptique-sdk",
-  "version": "1.2.20",
+  "version": "1.2.21",
   "type": "module",
   "description": "Cryptique Analytics SDK - Comprehensive web analytics and user tracking for modern web applications",
   "main": "lib/cjs/index.js",