@adventurelabs/scout-core 1.0.108 → 1.0.110

package/dist/hooks/useScoutRefresh.js

@@ -1,11 +1,12 @@
-import { useEffect, useCallback, useRef } from "react";
-import { useAppDispatch, useHerdModules, useUser } from "../store/hooks";
+import { useEffect, useCallback, useRef, useMemo } from "react";
+import { useAppDispatch } from "../store/hooks";
+import { useStore } from "react-redux";
 import { EnumScoutStateStatus, setHerdModules, setStatus, setHerdModulesLoadingState, setHerdModulesLoadedInMs, setHerdModulesApiDuration, setUserApiDuration, setDataProcessingDuration, setUser, setDataSource, setDataSourceInfo, } from "../store/scout";
 import { EnumHerdModulesLoadingState } from "../types/herd_module";
 import { server_load_herd_modules } from "../helpers/herds";
-import { server_get_user } from "../helpers/users";
 import { scoutCache } from "../helpers/cache";
 import { EnumDataSource } from "../types/data_source";
+import { createBrowserClient } from "@supabase/ssr";
 /**
  * Hook for refreshing scout data with detailed timing measurements and cache-first loading
  *
@@ -33,9 +34,12 @@ export function useScoutRefresh(options = {}) {
     const { autoRefresh = true, onRefreshComplete, cacheFirst = true, cacheTtlMs = 24 * 60 * 60 * 1000, // 24 hours default (1 day)
      } = options;
     const dispatch = useAppDispatch();
-    const currentHerdModules = useHerdModules();
-    const currentUser = useUser();
+    const store = useStore();
     const refreshInProgressRef = useRef(false);
+    // Create Supabase client directly to avoid circular dependency
+    const supabase = useMemo(() => {
+        return createBrowserClient(process.env.NEXT_PUBLIC_SUPABASE_URL || "", process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY || "");
+    }, []);
     // Refs to store timing measurements
     const timingRefs = useRef({
         startTime: 0,
@@ -46,7 +50,7 @@ export function useScoutRefresh(options = {}) {
         cacheSaveDuration: 0,
     });
     // Helper function for deep comparison of objects
-    const deepEqual = useCallback((obj1, obj2) => {
+    const deepEqual = useCallback((obj1, obj2, visited = new WeakMap()) => {
         if (obj1 === obj2)
             return true;
         if (obj1 == null || obj2 == null)
@@ -55,13 +59,22 @@ export function useScoutRefresh(options = {}) {
             return false;
         if (typeof obj1 !== "object")
             return obj1 === obj2;
+        // Handle circular references
+        if (visited.has(obj1)) {
+            return visited.get(obj1) === obj2;
+        }
+        visited.set(obj1, obj2);
+        // Handle Date objects
+        if (obj1 instanceof Date && obj2 instanceof Date) {
+            return obj1.getTime() === obj2.getTime();
+        }
         if (Array.isArray(obj1) !== Array.isArray(obj2))
             return false;
         if (Array.isArray(obj1)) {
             if (obj1.length !== obj2.length)
                 return false;
             for (let i = 0; i < obj1.length; i++) {
-                if (!deepEqual(obj1[i], obj2[i]))
+                if (!deepEqual(obj1[i], obj2[i], visited))
                     return false;
             }
             return true;
@@ -73,25 +86,44 @@ export function useScoutRefresh(options = {}) {
         for (const key of keys1) {
             if (!keys2.includes(key))
                 return false;
-            if (!deepEqual(obj1[key], obj2[key]))
+            if (!deepEqual(obj1[key], obj2[key], visited))
                 return false;
         }
         return true;
     }, []);
-    // Helper function to conditionally dispatch only if data has changed
-    const conditionalDispatch = useCallback((newData, currentData, actionCreator, dataType) => {
-        if (!deepEqual(newData, currentData)) {
-            console.log(`[useScoutRefresh] ${dataType} data changed, updating store`);
-            dispatch(actionCreator(newData));
+    // Helper function to normalize herd modules for comparison (excludes 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 metadata fields that don't represent business data changes
+            const { timestamp_last_refreshed, ...businessData } = hm;
+            return businessData;
+        });
+    }, []);
+    // Helper function to conditionally dispatch only if business data has changed
+    const conditionalDispatch = useCallback((newData, currentData, actionCreator, dataType, useNormalizedComparison = false) => {
+        let dataToCompare = newData;
+        let currentToCompare = currentData;
+        // For herd modules, use normalized comparison that ignores metadata
+        if (useNormalizedComparison && dataType.includes("Herd modules")) {
+            dataToCompare = normalizeHerdModulesForComparison(newData);
+            currentToCompare = normalizeHerdModulesForComparison(currentData);
+        }
+        if (!deepEqual(dataToCompare, currentToCompare)) {
+            console.log(`[useScoutRefresh] ${dataType} business data changed, updating store`);
+            dispatch(actionCreator(newData)); // Always dispatch the full data including timestamps
             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]);
-    // Helper function to handle IndexedDB errors
-    const handleIndexedDbError = async (error, operation, retryFn) => {
+    }, [dispatch, deepEqual, normalizeHerdModulesForComparison]);
+    // Helper function to handle IndexedDB errors - memoized for stability
+    const handleIndexedDbError = useCallback(async (error, operation, retryFn) => {
         if (error instanceof Error &&
             (error.message.includes("object store") ||
                 error.message.includes("NotFoundError"))) {
@@ -108,7 +140,7 @@ export function useScoutRefresh(options = {}) {
                 console.error(`[useScoutRefresh] Database reset and retry failed:`, resetError);
             }
         }
-    };
+    }, []);
     const handleRefresh = useCallback(async () => {
         // Prevent concurrent refresh calls
         if (refreshInProgressRef.current) {
@@ -142,20 +174,13 @@ export function useScoutRefresh(options = {}) {
                             cacheAge: cacheResult.age,
                             isStale: cacheResult.isStale,
                         }));
-                        // Conditionally update the store with cached data if different
-                        const herdModulesChanged = conditionalDispatch(cachedHerdModules, currentHerdModules, setHerdModules, "Herd modules (cache)");
+                        // Conditionally update the store with cached data if business data is different
+                        // Get current state at execution time to avoid dependency issues
+                        const currentHerdModules = store.getState().scout.herd_modules;
+                        const herdModulesChanged = conditionalDispatch(cachedHerdModules, currentHerdModules, setHerdModules, "Herd modules (cache)", true);
                         if (herdModulesChanged) {
                             dispatch(setHerdModulesLoadingState(EnumHerdModulesLoadingState.SUCCESSFULLY_LOADED));
                         }
-                        // Always load user data from API
-                        const userStartTime = Date.now();
-                        const res_new_user = await server_get_user();
-                        const userApiDuration = Date.now() - userStartTime;
-                        timingRefs.current.userApiDuration = userApiDuration;
-                        dispatch(setUserApiDuration(userApiDuration));
-                        if (res_new_user && res_new_user.data) {
-                            conditionalDispatch(res_new_user.data, currentUser, setUser, "User (initial)");
-                        }
                         // If cache is fresh, we still background fetch but don't wait
                         if (!cacheResult.isStale) {
                             console.log("[useScoutRefresh] Cache is fresh, background fetching fresh data...");
@@ -165,8 +190,22 @@ export function useScoutRefresh(options = {}) {
                                     console.log("[useScoutRefresh] Starting background fetch...");
                                     const backgroundStartTime = Date.now();
                                     const [backgroundHerdModulesResult, backgroundUserResult] = await Promise.all([
-                                        server_load_herd_modules(),
-                                        server_get_user(),
+                                        (async () => {
+                                            const start = Date.now();
+                                            const result = await server_load_herd_modules();
+                                            const duration = Date.now() - start;
+                                            timingRefs.current.herdModulesDuration = duration;
+                                            dispatch(setHerdModulesApiDuration(duration));
+                                            return result;
+                                        })(),
+                                        (async () => {
+                                            const start = Date.now();
+                                            const { data } = await supabase.auth.getUser();
+                                            const duration = Date.now() - start;
+                                            timingRefs.current.userApiDuration = duration;
+                                            dispatch(setUserApiDuration(duration));
+                                            return { data: data.user, status: "success" };
+                                        })(),
                                     ]);
                                     const backgroundDuration = Date.now() - backgroundStartTime;
                                     console.log(`[useScoutRefresh] Background fetch completed in ${backgroundDuration}ms`);
@@ -188,9 +227,13 @@ export function useScoutRefresh(options = {}) {
                                                 }
                                             });
                                         }
-                                        // Conditionally update store with fresh background data
-                                        conditionalDispatch(backgroundHerdModulesResult.data, currentHerdModules, setHerdModules, "Herd modules (background)");
-                                        conditionalDispatch(backgroundUserResult.data, currentUser, setUser, "User (background)");
+                                        // Conditionally update store with fresh background data using normalized comparison
+                                        const currentHerdModules = store.getState().scout.herd_modules;
+                                        const currentUser = store.getState().scout.user;
+                                        conditionalDispatch(backgroundHerdModulesResult.data, currentHerdModules, setHerdModules, "Herd modules (background)", true);
+                                        if (backgroundUserResult && backgroundUserResult.data) {
+                                            conditionalDispatch(backgroundUserResult.data, currentUser, setUser, "User (background)");
+                                        }
                                         // Update data source to DATABASE
                                         dispatch(setDataSource(EnumDataSource.DATABASE));
                                         dispatch(setDataSourceInfo({
@@ -240,10 +283,14 @@ export function useScoutRefresh(options = {}) {
                 (async () => {
                     const start = Date.now();
                     console.log(`[useScoutRefresh] Starting user request at ${new Date(start).toISOString()}`);
-                    const result = await server_get_user();
+                    const { data } = await supabase.auth.getUser();
                     const duration = Date.now() - start;
                     console.log(`[useScoutRefresh] User request completed in ${duration}ms`);
-                    return { result, duration, start };
+                    return {
+                        result: { data: data.user, status: "success" },
+                        duration,
+                        start,
+                    };
                 })(),
             ]);
             const parallelDuration = Date.now() - parallelStartTime;
@@ -292,9 +339,11 @@ export function useScoutRefresh(options = {}) {
                     await scoutCache.setHerdModules(compatible_new_herd_modules, cacheTtlMs);
                 });
             }
-            // Step 4: Conditionally update store with fresh data if different
+            // Step 4: Conditionally update store with fresh data using normalized comparison
             const dataProcessingStartTime = Date.now();
-            const herdModulesChanged = conditionalDispatch(compatible_new_herd_modules, currentHerdModules, setHerdModules, "Herd modules (fresh API)");
+            const currentHerdModules = store.getState().scout.herd_modules;
+            const currentUser = store.getState().scout.user;
+            const herdModulesChanged = conditionalDispatch(compatible_new_herd_modules, currentHerdModules, setHerdModules, "Herd modules (fresh API)", true);
             const userChanged = conditionalDispatch(res_new_user.data, currentUser, setUser, "User (fresh API)");
             if (herdModulesChanged) {
                 dispatch(setHerdModulesLoadingState(EnumHerdModulesLoadingState.SUCCESSFULLY_LOADED));
@@ -334,19 +383,21 @@ export function useScoutRefresh(options = {}) {
             console.log(`  - Total duration: ${loadingDuration}ms`);
             console.log(`  - Herd modules: ${timingRefs.current.herdModulesDuration}ms`);
             console.log(`  - User API: ${timingRefs.current.userApiDuration}ms`);
+            // Call completion callback even on error for consistency
+            onRefreshComplete?.();
         }
         finally {
             refreshInProgressRef.current = false;
         }
     }, [
         dispatch,
+        store,
+        supabase,
         onRefreshComplete,
         cacheFirst,
         cacheTtlMs,
-        handleIndexedDbError,
-        currentHerdModules,
-        currentUser,
         conditionalDispatch,
+        handleIndexedDbError,
     ]);
     useEffect(() => {
         if (autoRefresh) {

package/dist/store/hooks.d.ts

@@ -1,6 +1,4 @@
 export declare const useAppDispatch: import("react-redux").UseDispatch<import("redux").Dispatch<import("redux").UnknownAction>>;
-export declare const useHerdModules: () => import("../types/herd_module").IHerdModule[];
-export declare const useUser: () => import("@supabase/auth-js").User | null;
 export declare const useHerdModulesLoadingState: () => any;
 export declare const useIsHerdModulesLoading: () => boolean;
 export declare const useIsHerdModulesLoaded: () => boolean;

package/dist/store/hooks.js

@@ -2,14 +2,6 @@ import { useDispatch, useSelector } from "react-redux";
 import { EnumHerdModulesLoadingState } from "../types/herd_module";
 // Simple wrapper for useDispatch to maintain compatibility
 export const useAppDispatch = useDispatch;
-// Selector hook for current herd modules
-export const useHerdModules = () => {
-    return useSelector((state) => state.scout.herd_modules);
-};
-// Selector hook for current user
-export const useUser = () => {
-    return useSelector((state) => state.scout.user);
-};
 // Selector hook for herd modules loading state
 export const useHerdModulesLoadingState = () => {
     return useSelector((state) => state.scout.herd_modules_loading_state);

package/package.json

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