@adventurelabs/scout-core 1.0.109 → 1.0.110

package/dist/hooks/useScoutRefresh.js

@@ -1,12 +1,12 @@
-import { useEffect, useCallback, useRef } from "react";
+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
  *
@@ -36,6 +36,10 @@ export function useScoutRefresh(options = {}) {
     const dispatch = useAppDispatch();
     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,
@@ -87,18 +91,37 @@ export function useScoutRefresh(options = {}) {
         }
         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]);
+    }, [dispatch, deepEqual, normalizeHerdModulesForComparison]);
     // Helper function to handle IndexedDB errors - memoized for stability
     const handleIndexedDbError = useCallback(async (error, operation, retryFn) => {
         if (error instanceof Error &&
@@ -151,23 +174,13 @@ export function useScoutRefresh(options = {}) {
                             cacheAge: cacheResult.age,
                             isStale: cacheResult.isStale,
                         }));
-                        // Conditionally update the store with cached data if different
+                        // 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)");
+                        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) {
-                            const currentUser = store.getState().scout.user;
-                            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...");
@@ -177,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`);
@@ -200,11 +227,13 @@ export function useScoutRefresh(options = {}) {
                                                 }
                                             });
                                         }
-                                        // Conditionally update store with fresh background data
+                                        // 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)");
-                                        conditionalDispatch(backgroundUserResult.data, currentUser, setUser, "User (background)");
+                                        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({
@@ -254,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;
@@ -306,11 +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 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)");
+            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));
@@ -359,6 +392,7 @@ export function useScoutRefresh(options = {}) {
     }, [
         dispatch,
         store,
+        supabase,
         onRefreshComplete,
         cacheFirst,
         cacheTtlMs,

package/package.json

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