@adventurelabs/scout-core 1.0.112 → 1.0.114

package/dist/hooks/useScoutRefresh.js

@@ -101,47 +101,48 @@ export function useScoutRefresh(options = {}) {
             return aId - bId;
         });
     }, []);
-    // Helper function to find differences between herd modules for debugging
-    const findHerdModulesDifferences = useCallback((newData, currentData) => {
+    // Helper function to normalize herd modules for comparison (excludes timestamp metadata)
+    const normalizeHerdModulesForComparison = useCallback((herdModules) => {
+        if (!Array.isArray(herdModules))
+            return herdModules;
+        return herdModules.map((hm) => {
+            if (!hm || typeof hm !== "object")
+                return hm;
+            // Create a copy without timestamp metadata that doesn't represent business data changes
+            const { timestamp_last_refreshed, ...businessData } = hm;
+            return businessData;
+        });
+    }, []);
+    // Helper function to find what specifically changed for debugging
+    const findBusinessDataChanges = useCallback((newData, currentData) => {
         if (!Array.isArray(newData) || !Array.isArray(currentData)) {
             return `Array type mismatch: new=${Array.isArray(newData)}, current=${Array.isArray(currentData)}`;
         }
         if (newData.length !== currentData.length) {
-            return `Array length mismatch: new=${newData.length}, current=${currentData.length}`;
+            return `Array length: ${currentData.length} → ${newData.length}`;
         }
-        // Sort both arrays by herd ID for consistent comparison
-        const sortedNew = sortHerdModulesById(newData);
-        const sortedCurrent = sortHerdModulesById(currentData);
-        const differences = [];
+        // Sort and normalize both for consistent comparison
+        const sortedNew = normalizeHerdModulesForComparison(sortHerdModulesById(newData));
+        const sortedCurrent = normalizeHerdModulesForComparison(sortHerdModulesById(currentData));
+        const changes = [];
         for (let i = 0; i < sortedNew.length; i++) {
             const newHerd = sortedNew[i];
             const currentHerd = sortedCurrent[i];
-            if (!newHerd || !currentHerd) {
-                differences.push(`Herd ${i}: null/undefined mismatch`);
+            if (!newHerd || !currentHerd)
                 continue;
-            }
-            // Get herd identifiers for better debugging
-            const newHerdId = newHerd.herd?.id || "unknown";
-            const currentHerdId = currentHerd.herd?.id || "unknown";
-            const newHerdName = newHerd.herd?.name || "unknown";
-            const currentHerdName = currentHerd.herd?.name || "unknown";
-            // Check if herd IDs match (data shuffling detection)
-            if (newHerdId !== currentHerdId) {
-                differences.push(`Herd ${i}: ID mismatch - expected ${currentHerdId}(${currentHerdName}) got ${newHerdId}(${newHerdName})`);
-            }
-            // Check top-level fields
-            const fieldsToCheck = [
-                "timestamp_last_refreshed",
+            const herdName = newHerd.herd?.name || newHerd.name || `herd-${newHerd.herd?.id || i}`;
+            // Check key business fields
+            const businessFields = [
                 "total_events",
                 "total_events_with_filters",
                 "events_page_index",
             ];
-            fieldsToCheck.forEach((field) => {
+            businessFields.forEach((field) => {
                 if (newHerd[field] !== currentHerd[field]) {
-                    differences.push(`Herd ${i}(${newHerdName}).${field}: ${currentHerd[field]} → ${newHerd[field]}`);
+                    changes.push(`${herdName}.${field}: ${currentHerd[field]} → ${newHerd[field]}`);
                 }
             });
-            // Check array lengths for nested data
+            // Check array lengths
             const arrayFields = [
                 "devices",
                 "events",
@@ -156,39 +157,51 @@ export function useScoutRefresh(options = {}) {
                 const currentArray = currentHerd[field];
                 if (Array.isArray(newArray) && Array.isArray(currentArray)) {
                     if (newArray.length !== currentArray.length) {
-                        differences.push(`Herd ${i}(${newHerdName}).${field}[]: length ${currentArray.length} → ${newArray.length}`);
+                        changes.push(`${herdName}.${field}[]: ${currentArray.length} → ${newArray.length}`);
                     }
                 }
             });
         }
-        return differences.length > 0
-            ? differences.join(", ")
-            : "No significant differences found";
-    }, []);
-    // Helper function to conditionally dispatch only if data has changed
-    const conditionalDispatch = useCallback((newData, currentData, actionCreator, dataType, enableDebugging = false) => {
+        return changes.length > 0
+            ? changes.join(", ")
+            : "No specific changes identified";
+    }, [normalizeHerdModulesForComparison, sortHerdModulesById]);
+    // Helper function to conditionally dispatch only if business data has changed
+    const conditionalDispatch = useCallback((newData, currentData, actionCreator, dataType, skipTimestampOnlyUpdates = false) => {
         // For herd modules, sort both datasets by ID before comparison
         let dataToCompare = newData;
         let currentToCompare = currentData;
         if (dataType.includes("Herd modules")) {
             dataToCompare = sortHerdModulesById(newData);
             currentToCompare = sortHerdModulesById(currentData);
+            // If we want to skip timestamp-only updates, normalize the data for comparison
+            if (skipTimestampOnlyUpdates) {
+                dataToCompare = normalizeHerdModulesForComparison(dataToCompare);
+                currentToCompare =
+                    normalizeHerdModulesForComparison(currentToCompare);
+            }
         }
         if (!deepEqual(dataToCompare, currentToCompare)) {
-            console.log(`[useScoutRefresh] ${dataType} data changed, updating store`);
-            // Add debugging for herd modules to see what actually changed
-            if (enableDebugging && dataType.includes("Herd modules")) {
-                const differences = findHerdModulesDifferences(newData, currentData);
-                console.log(`[useScoutRefresh] ${dataType} differences: ${differences}`);
+            console.log(`[useScoutRefresh] ${dataType} business data changed, updating store`);
+            // Add debugging for unexpected business changes
+            if (skipTimestampOnlyUpdates && dataType.includes("Herd modules")) {
+                const changes = findBusinessDataChanges(newData, currentData);
+                console.log(`[useScoutRefresh] ${dataType} changes: ${changes}`);
             }
             dispatch(actionCreator(newData)); // Always dispatch original unsorted data
             return true;
         }
         else {
-            console.log(`[useScoutRefresh] ${dataType} data unchanged, skipping store update`);
+            console.log(`[useScoutRefresh] ${dataType} business data unchanged, skipping store update`);
             return false;
         }
-    }, [dispatch, deepEqual, findHerdModulesDifferences, sortHerdModulesById]);
+    }, [
+        dispatch,
+        deepEqual,
+        sortHerdModulesById,
+        normalizeHerdModulesForComparison,
+        findBusinessDataChanges,
+    ]);
     // Helper function to handle IndexedDB errors - memoized for stability
     const handleIndexedDbError = useCallback(async (error, operation, retryFn) => {
         if (error instanceof Error &&
@@ -295,7 +308,7 @@ export function useScoutRefresh(options = {}) {
                                                 }
                                             });
                                         }
-                                        // Conditionally update store with fresh background data using normalized comparison
+                                        // Conditionally update store with fresh background data, skip timestamp-only changes
                                         const currentHerdModules = store.getState().scout.herd_modules;
                                         const currentUser = store.getState().scout.user;
                                         conditionalDispatch(backgroundHerdModulesResult.data, currentHerdModules, setHerdModules, "Herd modules (background)", true);
@@ -407,7 +420,7 @@ export function useScoutRefresh(options = {}) {
                     await scoutCache.setHerdModules(compatible_new_herd_modules, cacheTtlMs);
                 });
             }
-            // Step 4: Conditionally update store with fresh data using normalized comparison
+            // Step 4: Conditionally update store with fresh data, skip timestamp-only changes
             const dataProcessingStartTime = Date.now();
             const currentHerdModules = store.getState().scout.herd_modules;
             const currentUser = store.getState().scout.user;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adventurelabs/scout-core",
-  "version": "1.0.112",
+  "version": "1.0.114",
   "description": "Core utilities and helpers for Adventure Labs Scout applications",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",