@adventurelabs/scout-core 2.0.3 → 2.0.4

package/dist/hooks/useScoutRefresh.js

@@ -15,19 +15,15 @@ function dispatchInTransition(dispatch, action) {
         dispatch(action);
     });
 }
-async function loadAuthenticatedUser(supabase, offline) {
+async function loadAuthenticatedUser(supabase) {
     const startTime = Date.now();
-    if (offline) {
-        const { data: { session }, } = await supabase.auth.getSession();
-        if (!session?.user) {
-            throw new Error("No authenticated user");
-        }
-        return { user: session.user, duration: Date.now() - startTime };
-    }
     let lastError = new Error("Unable to load authenticated user");
     for (let attempt = 0; attempt < 2; attempt++) {
         try {
-            const { data } = await supabase.auth.getUser();
+            const { data, error } = await supabase.auth.getUser();
+            if (error) {
+                throw error;
+            }
             if (!data.user) {
                 throw new Error("Invalid user response");
             }
@@ -59,16 +55,30 @@ async function recoverScoutCache(error, operation, userId, retry) {
  *
  * Automatic refreshes hydrate from cache before revalidating online.
  */
-export function useScoutRefresh(options = {}) {
-    const { supabase: supabaseOption, autoRefresh = true, onRefreshComplete, cacheFirst = true, cacheTtlMs = 24 * 60 * 60 * 1000, onlineRefetchMinIntervalMs = 15 * 1000, } = options;
+export function useScoutRefresh(options = {}, identityOptions = {}) {
+    const { supabase: supabaseOption, autoRefresh = true, onRefreshComplete, cacheFirst = true, cacheTtlMs = 24 * 60 * 60 * 1000, onlineRefetchMinIntervalMs = 15 * 1000, offlineUserId, } = options;
+    const { validatedUserId, onUserValidated } = identityOptions;
     const dispatch = useAppDispatch();
     const refreshIdRef = useRef(0);
     const activeUserIdRef = useRef(null);
+    const validatedUserIdRef = useRef(null);
+    const providedValidatedUserIdRef = useRef(validatedUserId);
+    providedValidatedUserIdRef.current = validatedUserId;
     const lastQueryAtRef = useRef(0);
     const onRefreshCompleteRef = useRef(onRefreshComplete);
+    const onUserValidatedRef = useRef(onUserValidated);
     useEffect(() => {
         onRefreshCompleteRef.current = onRefreshComplete;
-    }, [onRefreshComplete]);
+        onUserValidatedRef.current = onUserValidated;
+    }, [onRefreshComplete, onUserValidated]);
+    const notifyUserValidated = useCallback((userId) => {
+        try {
+            onUserValidatedRef.current?.(userId);
+        }
+        catch (error) {
+            console.error("[useScoutRefresh] User validation callback failed:", error);
+        }
+    }, []);
     const supabase = useMemo(() => {
         if (supabaseOption) {
             return supabaseOption;
@@ -79,12 +89,14 @@ export function useScoutRefresh(options = {}) {
         dispatch(resetScoutState());
         dispatch(scoutApi.util.resetApiState());
     }, [dispatch]);
+    const cacheIdentityRef = useRef({ supabase, offlineUserId });
     const handleRefresh = useCallback(async ({ force = true } = {}) => {
         const refreshId = ++refreshIdRef.current;
         const isCurrent = () => refreshIdRef.current === refreshId;
         const startTime = Date.now();
         const isOffline = typeof navigator === "undefined" || !navigator.onLine;
         let cachedHerdModules = null;
+        let cacheReady = false;
         const complete = (loadingState) => {
             if (!isCurrent())
                 return;
@@ -93,57 +105,84 @@ export function useScoutRefresh(options = {}) {
             dispatch(setStatus(EnumScoutStateStatus.DONE_LOADING));
             onRefreshCompleteRef.current?.();
         };
-        try {
-            dispatch(setStatus(EnumScoutStateStatus.LOADING));
-            dispatch(setHerdModulesLoadingState(EnumHerdModulesLoadingState.LOADING));
-            const { user, duration } = await loadAuthenticatedUser(supabase, isOffline);
-            if (!isCurrent())
-                return;
-            const userId = user.id;
+        const activateUser = (userId) => {
             if (activeUserIdRef.current &&
                 activeUserIdRef.current !== userId) {
                 resetClientState();
+                cachedHerdModules = null;
             }
             activeUserIdRef.current = userId;
-            dispatch(setUserApiDuration(duration));
-            dispatchInTransition(dispatch, setUser(user));
-            let cacheReady = false;
+        };
+        const hydrateCache = async (userId) => {
+            activateUser(userId);
+            cacheReady = false;
             try {
                 await scoutCache.setScope(userId);
                 cacheReady = true;
             }
             catch (cacheError) {
                 console.warn("[useScoutRefresh] Cache unavailable:", cacheError);
+                return;
             }
-            if (cacheFirst && cacheReady && (!force || isOffline)) {
-                const cacheStartTime = Date.now();
-                try {
-                    const cacheResult = await scoutCache.getHerdModules(userId);
-                    if (!isCurrent() || activeUserIdRef.current !== userId)
-                        return;
-                    const cacheLoadDuration = Date.now() - cacheStartTime;
-                    dispatch(setCacheLoadDuration(cacheLoadDuration));
-                    if (cacheResult.data !== null) {
-                        cachedHerdModules = cacheResult.data;
-                        dispatch(setDataSource(EnumDataSource.CACHE));
-                        dispatch(setDataSourceInfo({
-                            source: EnumDataSource.CACHE,
-                            timestamp: Date.now(),
-                            cacheAge: cacheResult.age,
-                            isStale: cacheResult.isStale,
-                        }));
-                        dispatchInTransition(dispatch, setHerdModules({
-                            modules: cachedHerdModules,
-                        }));
-                        dispatch(setHerdModulesLoadingState(EnumHerdModulesLoadingState.SUCCESSFULLY_LOADED));
-                    }
-                }
-                catch (cacheError) {
-                    console.warn("[useScoutRefresh] Cache load failed:", cacheError);
-                    await recoverScoutCache(cacheError, "cache load", userId);
+            if (!cacheFirst || (force && !isOffline)) {
+                return;
+            }
+            const cacheStartTime = Date.now();
+            try {
+                const cacheResult = await scoutCache.getHerdModules(userId);
+                if (!isCurrent() || activeUserIdRef.current !== userId)
+                    return;
+                dispatch(setCacheLoadDuration(Date.now() - cacheStartTime));
+                if (cacheResult.data === null) {
+                    return;
                 }
+                cachedHerdModules = cacheResult.data;
+                dispatch(setDataSource(EnumDataSource.CACHE));
+                dispatch(setDataSourceInfo({
+                    source: EnumDataSource.CACHE,
+                    timestamp: Date.now(),
+                    cacheAge: cacheResult.age,
+                    isStale: cacheResult.isStale,
+                }));
+                dispatchInTransition(dispatch, setHerdModules({ modules: cachedHerdModules }));
+                dispatch(setHerdModulesLoadingState(EnumHerdModulesLoadingState.SUCCESSFULLY_LOADED));
+            }
+            catch (cacheError) {
+                console.warn("[useScoutRefresh] Cache load failed:", cacheError);
+                await recoverScoutCache(cacheError, "cache load", userId);
+            }
+        };
+        try {
+            dispatch(setStatus(EnumScoutStateStatus.LOADING));
+            dispatch(setHerdModulesLoadingState(EnumHerdModulesLoadingState.LOADING));
+            const providedValidatedUserId = providedValidatedUserIdRef.current;
+            const hasProvidedValidation = providedValidatedUserId !== undefined;
+            let cacheUserId = hasProvidedValidation
+                ? providedValidatedUserId
+                : validatedUserIdRef.current ??
+                    offlineUserId ??
+                    activeUserIdRef.current;
+            let sessionUser = null;
+            let sessionDuration = 0;
+            if (!cacheUserId && !hasProvidedValidation) {
+                const sessionStart = Date.now();
+                const { data: { session }, } = await supabase.auth.getSession();
+                if (!isCurrent())
+                    return;
+                sessionDuration = Date.now() - sessionStart;
+                sessionUser = session?.user ?? null;
+                cacheUserId = sessionUser?.id ?? null;
+            }
+            if (cacheUserId) {
+                await hydrateCache(cacheUserId);
+                if (!isCurrent())
+                    return;
             }
             if (isOffline) {
+                if (sessionUser) {
+                    dispatch(setUserApiDuration(sessionDuration));
+                    dispatchInTransition(dispatch, setUser(sessionUser));
+                }
                 if (cachedHerdModules === null) {
                     dispatch(setDataSource(EnumDataSource.UNKNOWN));
                     dispatch(setDataSourceInfo({
@@ -156,6 +195,19 @@ export function useScoutRefresh(options = {}) {
                     : EnumHerdModulesLoadingState.UNSUCCESSFULLY_LOADED);
                 return;
             }
+            const { user, duration } = await loadAuthenticatedUser(supabase);
+            if (!isCurrent())
+                return;
+            const userId = user.id;
+            validatedUserIdRef.current = userId;
+            notifyUserValidated(userId);
+            if (cacheUserId !== userId || !cacheReady) {
+                await hydrateCache(userId);
+                if (!isCurrent())
+                    return;
+            }
+            dispatch(setUserApiDuration(duration));
+            dispatchInTransition(dispatch, setUser(user));
             const queryStart = Date.now();
             const herdModulesResponse = await load_herd_modules_query(supabase);
             if (!isCurrent() || activeUserIdRef.current !== userId)
@@ -225,8 +277,48 @@ export function useScoutRefresh(options = {}) {
         supabase,
         cacheFirst,
         cacheTtlMs,
+        offlineUserId,
+        notifyUserValidated,
         resetClientState,
     ]);
+    useEffect(() => {
+        const previousIdentity = cacheIdentityRef.current;
+        if (previousIdentity.supabase === supabase &&
+            previousIdentity.offlineUserId === offlineUserId) {
+            return;
+        }
+        cacheIdentityRef.current = { supabase, offlineUserId };
+        refreshIdRef.current++;
+        activeUserIdRef.current = null;
+        validatedUserIdRef.current = null;
+        resetClientState();
+    }, [supabase, offlineUserId, resetClientState]);
+    useEffect(() => {
+        if (validatedUserId === undefined) {
+            return;
+        }
+        validatedUserIdRef.current = validatedUserId;
+        if (validatedUserId === null) {
+            if (activeUserIdRef.current) {
+                refreshIdRef.current++;
+                activeUserIdRef.current = null;
+                resetClientState();
+            }
+            return;
+        }
+        if (validatedUserId === activeUserIdRef.current) {
+            return;
+        }
+        if (!autoRefresh) {
+            refreshIdRef.current++;
+            if (activeUserIdRef.current) {
+                resetClientState();
+            }
+            activeUserIdRef.current = validatedUserId;
+            return;
+        }
+        void handleRefresh({ force: false });
+    }, [autoRefresh, validatedUserId, handleRefresh, resetClientState]);
     useEffect(() => {
         if (autoRefresh) {
             void handleRefresh({ force: false });
@@ -238,6 +330,8 @@ export function useScoutRefresh(options = {}) {
                 const previousUserId = activeUserIdRef.current ?? scoutCache.getScopeUserId();
                 refreshIdRef.current++;
                 activeUserIdRef.current = null;
+                validatedUserIdRef.current = null;
+                notifyUserValidated(null);
                 resetClientState();
                 void clearScoutClientState(previousUserId ?? undefined).catch((error) => {
                     console.warn("[useScoutRefresh] Sign-out cache clear failed:", error);
@@ -245,16 +339,19 @@ export function useScoutRefresh(options = {}) {
                 return;
             }
             const nextUserId = session?.user?.id;
-            if (event === "SIGNED_IN" &&
-                nextUserId &&
-                nextUserId !== activeUserIdRef.current) {
+            if (event === "SIGNED_IN" && nextUserId) {
+                validatedUserIdRef.current = nextUserId;
+                notifyUserValidated(nextUserId);
+                if (nextUserId === activeUserIdRef.current) {
+                    return;
+                }
                 refreshIdRef.current++;
                 activeUserIdRef.current = nextUserId;
                 resetClientState();
                 void handleRefresh({ force: true });
             }
         });
-    }, [supabase, handleRefresh, resetClientState]);
+    }, [supabase, handleRefresh, notifyUserValidated, resetClientState]);
     useEffect(() => {
         if (!autoRefresh || typeof window === "undefined")
             return;