@jmruthers/pace-core 0.5.43 → 0.5.45

package/dist/{chunk-P27KH7XF.js → chunk-OQ6DTLZ6.js}

@@ -49,262 +49,174 @@ function AuthProvider({ children, supabaseClient }) {
     };
   }, []);
   useEffect(() => {
-    if (!supabaseClient) return;
-    const loadInitialUser = async (retryCount = 0) => {
+    if (!supabaseClient) {
+      setAuthLoading(false);
+      return;
+    }
+    let isMounted = true;
+    const initializeAuth = async () => {
       try {
-        DebugLogger.log("AuthProvider", `Loading initial user (attempt ${retryCount + 1})...`);
-        const response = await supabaseClient.auth.getUser();
-        const { data: { user: initialUser }, error } = response || { data: { user: null }, error: null };
-        if (error) {
-          console.warn("Failed to get initial user:", error);
-          if (retryCount === 0 && (error.message?.includes("network") || error.message?.includes("timeout"))) {
-            console.log("AuthProvider: Retrying initial user load due to network error...");
-            setTimeout(() => loadInitialUser(1), 1e3);
-            return;
+        DebugLogger.log("AuthProvider", "Initializing authentication...");
+        const { data: { session: currentSession }, error: sessionError } = await supabaseClient.auth.getSession();
+        if (sessionError) {
+          console.warn("[AuthProvider] Error getting current session:", sessionError);
+        }
+        if (currentSession && isMounted) {
+          DebugLogger.log("AuthProvider", "Session restored from storage:", currentSession.user?.email);
+          setSession(currentSession);
+          setUser(currentSession.user);
+          setAuthError(null);
+        } else if (isMounted) {
+          DebugLogger.log("AuthProvider", "No session found in storage");
+          const { data: { user: currentUser }, error: userError } = await supabaseClient.auth.getUser();
+          if (userError) {
+            DebugLogger.log("AuthProvider", "No user found:", userError.message);
+          } else if (currentUser && isMounted) {
+            DebugLogger.log("AuthProvider", "User found without session:", currentUser.email);
+            setUser(currentUser);
           }
-          setAuthLoading(false);
-          return;
         }
-        if (initialUser) {
-          DebugLogger.log("AuthProvider", "Initial user loaded successfully:", initialUser.email);
-          setUser(initialUser);
-        } else {
-          DebugLogger.log("AuthProvider", "No initial user found");
+        if (isMounted) {
+          setAuthLoading(false);
         }
-        setAuthLoading(false);
       } catch (error) {
-        console.error("Error loading initial user:", error);
-        if (retryCount === 0 && (error instanceof Error && (error.message.includes("network") || error.message.includes("timeout")))) {
-          console.log("AuthProvider: Retrying initial user load due to network error...");
-          setTimeout(() => loadInitialUser(1), 1e3);
-          return;
+        console.error("[AuthProvider] Error during auth initialization:", error);
+        if (isMounted) {
+          setAuthLoading(false);
         }
-        setAuthLoading(false);
       }
     };
-    const timeoutId = setTimeout(() => {
-      if (authLoading && !user && !session) {
-        loadInitialUser();
-      }
-    }, 100);
-    return () => clearTimeout(timeoutId);
-  }, [supabaseClient, authLoading, user, session]);
-  useEffect(() => {
-    if (!supabaseClient) {
-      setAuthLoading(false);
-      return;
-    }
-    const timeoutId = setTimeout(() => {
-      if (authLoading) {
-        console.warn("AuthProvider: Auth loading timeout reached - this may indicate a network issue or slow auth response");
-        setAuthLoading(false);
-        setAuthError(new AuthError("Authentication timeout - please try refreshing the page"));
-      }
-    }, 1e4);
-    try {
-      DebugLogger.log("AuthProvider", "Setting up auth state change listener...");
-      const authStateChange = supabaseClient.auth.onAuthStateChange(
-        (event, session2) => {
-          try {
-            DebugLogger.log("AuthProvider", "Auth state changed:", event, session2?.user?.email);
-            clearTimeout(timeoutId);
-            if (event === "SIGNED_OUT") {
-              DebugLogger.log("AuthProvider", "User signed out, clearing all state");
-              setSession(null);
-              setUser(null);
-              setAuthLoading(false);
+    const { data: { subscription } } = supabaseClient.auth.onAuthStateChange(
+      (event, session2) => {
+        if (!isMounted) return;
+        try {
+          DebugLogger.log("AuthProvider", "Auth state changed:", event, session2?.user?.email);
+          if (event === "SIGNED_OUT") {
+            DebugLogger.log("AuthProvider", "User signed out, clearing all state");
+            setSession(null);
+            setUser(null);
+            setAuthError(null);
+          } else if (event === "SIGNED_IN" || event === "TOKEN_REFRESHED") {
+            DebugLogger.log("AuthProvider", "User signed in or token refreshed");
+            setSession(session2);
+            setUser(session2?.user ?? null);
+            if (session2) {
               setAuthError(null);
-            } else if (event === "SIGNED_IN" || event === "TOKEN_REFRESHED") {
-              DebugLogger.log("AuthProvider", "User signed in or token refreshed");
+            }
+          } else if (event === "INITIAL_SESSION") {
+            DebugLogger.log("AuthProvider", "Initial session event");
+            if (session2) {
               setSession(session2);
-              setUser(session2?.user ?? null);
-              setAuthLoading(false);
-              if (session2) {
-                setAuthError(null);
-              }
-            } else {
-              if (session2) {
-                setSession(session2);
-                setUser(session2.user ?? null);
-                setAuthLoading(false);
-                if (session2) {
-                  setAuthError(null);
-                }
-              }
+              setUser(session2.user ?? null);
+              setAuthError(null);
             }
-          } catch (error) {
-            console.warn("[AuthProvider] Error in auth state change handler:", error);
+          }
+          setAuthLoading(false);
+        } catch (error) {
+          console.warn("[AuthProvider] Error in auth state change handler:", error);
+          if (isMounted) {
             setAuthLoading(false);
           }
         }
-      );
-      const subscription = authStateChange?.data?.subscription || authStateChange;
-      return () => {
-        clearTimeout(timeoutId);
-        if (subscription && typeof subscription.unsubscribe === "function") {
-          DebugLogger.log("AuthProvider", "Cleaning up auth state listener");
-          subscription.unsubscribe();
-        }
-      };
-    } catch (error) {
-      console.error("AuthProvider: Error setting up auth state change listener:", error);
-      if (error instanceof Error && !error.message.includes("No API key found") && !error.message.includes("AuthSessionMissingError") && !error.message.includes("Auth session missing")) {
-        setAuthError(error);
       }
-      setAuthLoading(false);
-      clearTimeout(timeoutId);
-      return () => {
-      };
-    }
+    );
+    initializeAuth();
+    return () => {
+      isMounted = false;
+      subscription?.unsubscribe();
+    };
   }, [supabaseClient]);
   const signIn = useCallback(async (email, password) => {
     if (!supabaseClient) {
-      const error = new Error("No Supabase client provided");
-      setAuthError(error);
-      return { error };
+      return { error: new AuthError("Supabase client not available") };
     }
-    setAuthLoading(true);
-    setAuthError(null);
     try {
-      const { error } = await supabaseClient.auth.signInWithPassword({ email, password: password || "" });
-      if (error) {
-        setAuthError(error);
-      }
+      const { error } = await supabaseClient.auth.signInWithPassword({
+        email,
+        password: password || ""
+      });
+      return { error };
+    } catch (error) {
       return { error };
-    } catch (err) {
-      const authError2 = err;
-      setAuthError(authError2);
-      return { error: authError2 };
-    } finally {
-      setAuthLoading(false);
     }
   }, [supabaseClient]);
   const signUp = useCallback(async (email, password) => {
     if (!supabaseClient) {
-      const error = new Error("No Supabase client provided");
-      setAuthError(error);
-      return { error };
+      return { error: new AuthError("Supabase client not available") };
     }
-    setAuthError(null);
     try {
-      const { error } = await supabaseClient.auth.signUp({ email, password });
-      if (error) {
-        setAuthError(error);
-      }
+      const { error } = await supabaseClient.auth.signUp({
+        email,
+        password
+      });
+      return { error };
+    } catch (error) {
       return { error };
-    } catch (err) {
-      const authError2 = err;
-      setAuthError(authError2);
-      return { error: authError2 };
     }
   }, [supabaseClient]);
   const signOut = useCallback(async () => {
-    DebugLogger.log("AuthProvider", "signOut called");
-    setAuthLoading(false);
     if (!supabaseClient) {
-      DebugLogger.log("AuthProvider", "No supabase client, clearing state manually");
-      setUser(null);
-      setSession(null);
-      setAuthError(null);
-      return { error: null };
+      return { error: new AuthError("Supabase client not available") };
     }
-    DebugLogger.log("AuthProvider", "Pre-clearing state before signOut call");
-    setUser(null);
-    setSession(null);
-    setAuthError(null);
     try {
-      DebugLogger.log("AuthProvider", "Calling supabase signOut");
-      const signOutPromise = supabaseClient.auth.signOut();
-      const timeoutPromise = new Promise(
-        (_, reject) => setTimeout(() => reject(new Error("SignOut timeout")), 3e3)
-      );
-      const { error } = await Promise.race([signOutPromise, timeoutPromise]);
-      if (error && !error.message?.includes("SignOut timeout")) {
-        console.error("[AuthProvider] signOut error:", error);
-      }
-      DebugLogger.log("AuthProvider", "signOut process completed");
-      return { error: null };
-    } catch (err) {
-      console.warn("[AuthProvider] signOut exception (ignored):", err);
-      return { error: null };
+      const { error } = await supabaseClient.auth.signOut();
+      return { error };
+    } catch (error) {
+      return { error };
     }
   }, [supabaseClient]);
   const resetPassword = useCallback(async (email) => {
     if (!supabaseClient) {
-      const error = new Error("No Supabase client provided");
-      setAuthError(error);
-      return { error };
+      return { error: new AuthError("Supabase client not available") };
     }
-    setAuthError(null);
     try {
       const { error } = await supabaseClient.auth.resetPasswordForEmail(email);
-      if (error) {
-        setAuthError(error);
-      }
       return { error };
-    } catch (err) {
-      const authError2 = err;
-      setAuthError(authError2);
-      return { error: authError2 };
+    } catch (error) {
+      return { error };
     }
   }, [supabaseClient]);
   const updatePassword = useCallback(async (password) => {
-    if (!supabaseClient) return { error: new AuthError("Supabase client not available.", 500) };
-    const { error } = await supabaseClient.auth.updateUser({ password });
-    if (error) {
-      setAuthError(error);
+    if (!supabaseClient) {
+      return { error: new AuthError("Supabase client not available") };
+    }
+    try {
+      const { error } = await supabaseClient.auth.updateUser({
+        password
+      });
+      return { error };
+    } catch (error) {
+      return { error };
     }
-    return { error };
   }, [supabaseClient]);
   const refreshSession = useCallback(async () => {
     if (!supabaseClient) {
-      const error = new Error("No Supabase client provided");
-      setAuthError(error);
-      return { error };
+      return { error: new AuthError("Supabase client not available") };
     }
-    setAuthError(null);
     try {
       const { error } = await supabaseClient.auth.refreshSession();
-      if (error) {
-        setAuthError(error);
-      }
       return { error };
-    } catch (err) {
-      const authError2 = err;
-      setAuthError(authError2);
-      return { error: authError2 };
+    } catch (error) {
+      return { error };
     }
   }, [supabaseClient]);
-  const isAuthenticated = !!user;
   const contextValue = useMemo(() => ({
     user,
     session,
-    isAuthenticated,
+    isAuthenticated: !!user && !!session,
     authLoading,
     authError,
     error: authError,
     // Alias for backward compatibility
     supabase: supabaseClient || null,
+    // Ensure null instead of undefined
     signIn,
     signUp,
     signOut,
     resetPassword,
     updatePassword,
     refreshSession
-  }), [
-    user,
-    session,
-    isAuthenticated,
-    authLoading,
-    authError,
-    supabaseClient,
-    signIn,
-    signUp,
-    signOut,
-    resetPassword,
-    updatePassword,
-    refreshSession
-  ]);
+  }), [user, session, authLoading, authError, supabaseClient, signIn, signUp, signOut, resetPassword, updatePassword, refreshSession]);
   return /* @__PURE__ */ jsx(AuthContext.Provider, { value: contextValue, children });
 }
 var AuthContext, useAuth;
@@ -7430,6 +7342,10 @@ function OrganisationProvider({ children }) {
       setError(null);
       return;
     }
+    if (isLoading) {
+      DebugLogger.log("OrganisationProvider", "Already loading, skipping duplicate load");
+      return;
+    }
     setIsLoading(true);
     setError(null);
     try {
@@ -7463,10 +7379,32 @@ function OrganisationProvider({ children }) {
       if (!memberships || memberships.length === 0) {
         throw new Error("User has no active organisation memberships");
       }
-      const organisationIds = memberships.map((m) => m.organisation_id).filter((id) => id && id.trim() !== "" && /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(id));
+      memberships.forEach((membership, index) => {
+        if (!membership.organisation_id || membership.organisation_id.trim() === "") {
+          console.warn(`[OrganisationProvider] Membership ${index} has invalid organisation_id:`, membership);
+        }
+      });
+      const organisationIds = memberships.map((m) => m.organisation_id).filter((id) => {
+        if (!id || typeof id !== "string") {
+          console.warn("[OrganisationProvider] Invalid organisation ID (not string):", id);
+          return false;
+        }
+        const trimmedId = id.trim();
+        if (trimmedId === "") {
+          console.warn("[OrganisationProvider] Empty organisation ID found");
+          return false;
+        }
+        const isValidUuid = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(trimmedId);
+        if (!isValidUuid) {
+          console.warn("[OrganisationProvider] Invalid UUID format:", trimmedId);
+        }
+        return isValidUuid;
+      });
       if (organisationIds.length === 0) {
+        console.warn("[OrganisationProvider] No valid organisation IDs found in memberships:", memberships);
         throw new Error("No valid organisation IDs found in memberships");
       }
+      DebugLogger.log("OrganisationProvider", "Valid organisation IDs:", organisationIds);
       const { data: organisations2, error: orgError } = await supabase.from("organisations").select("id, name, display_name, subscription_tier, settings, is_active, parent_id, created_at, updated_at").in("id", organisationIds);
       if (orgError) {
         console.error("[OrganisationProvider] Error loading organisations:", orgError);
@@ -7490,14 +7428,23 @@ function OrganisationProvider({ children }) {
         const persistedOrgString = localStorage.getItem(STORAGE_KEYS2.SELECTED_ORGANISATION);
         if (persistedOrgString) {
           const persistedOrg = JSON.parse(persistedOrgString);
-          const validPersistedOrg = activeOrgs.find((org) => org.id === persistedOrg.id);
-          if (validPersistedOrg) {
-            initialOrg = validPersistedOrg;
-            DebugLogger.log("OrganisationProvider", "Restored persisted organisation:", initialOrg.display_name);
+          if (persistedOrg.id && typeof persistedOrg.id === "string" && persistedOrg.id.trim() !== "") {
+            const validPersistedOrg = activeOrgs.find((org) => org.id === persistedOrg.id);
+            if (validPersistedOrg) {
+              initialOrg = validPersistedOrg;
+              DebugLogger.log("OrganisationProvider", "Restored persisted organisation:", initialOrg.display_name);
+            } else {
+              console.warn("[OrganisationProvider] Persisted organisation not found in active orgs, clearing cache");
+              localStorage.removeItem(STORAGE_KEYS2.SELECTED_ORGANISATION);
+            }
+          } else {
+            console.warn("[OrganisationProvider] Invalid persisted organisation ID, clearing cache");
+            localStorage.removeItem(STORAGE_KEYS2.SELECTED_ORGANISATION);
           }
         }
       } catch (storageError) {
         console.warn("[OrganisationProvider] Failed to restore persisted organisation:", storageError);
+        localStorage.removeItem(STORAGE_KEYS2.SELECTED_ORGANISATION);
       }
       if (!initialOrg) {
         const adminMembership = memberships.find((m) => m.role === "org_admin");
@@ -7535,8 +7482,21 @@ function OrganisationProvider({ children }) {
     }
   }, [user, session, supabase]);
   useEffect7(() => {
-    loadUserOrganisations();
-  }, [loadUserOrganisations]);
+    if (user && session && supabase && !isLoading) {
+      DebugLogger.log("OrganisationProvider", "Authentication stable, loading organizations...");
+      loadUserOrganisations();
+    } else if (!user && !session) {
+      DebugLogger.log("OrganisationProvider", "No authentication, clearing organization state");
+      setSelectedOrganisation(null);
+      setOrganisations([]);
+      setUserMemberships([]);
+      setRoleMapState(/* @__PURE__ */ new Map());
+      setIsLoading(false);
+      setError(null);
+      localStorage.removeItem(STORAGE_KEYS2.SELECTED_ORGANISATION);
+      localStorage.removeItem(STORAGE_KEYS2.ORGANISATION_CONTEXT);
+    }
+  }, [user, session, supabase, isLoading, loadUserOrganisations]);
   const handleLogoutAndRedirect = useCallback7(async () => {
     try {
       await signOut();
@@ -7730,8 +7690,8 @@ var init_OrganisationProvider = __esm({
 });
 
 export {
-  useAuth,
   AuthProvider,
+  useAuth,
   init_AuthProvider,
   useRBAC,
   RBACProvider,
@@ -7785,4 +7745,4 @@ lodash/lodash.js:
    * Copyright Jeremy Ashkenas, DocumentCloud and Investigative Reporters & Editors
    *)
 */
-//# sourceMappingURL=chunk-P27KH7XF.js.map
+//# sourceMappingURL=chunk-OQ6DTLZ6.js.map