@rebasepro/auth 0.2.3 → 0.2.5

package/dist/index.umd.js

@@ -217,11 +217,7 @@
       authConfigInflight = null;
     }
   }
-  function clearAuthConfigCache() {
-    authConfigCached = null;
-    authConfigInflight = null;
-  }
-  const STORAGE_KEY = "rebase_auth";
+  const STORAGE_KEY = "rebase_react_auth";
   const TOKEN_REFRESH_BUFFER_MS = 2 * 60 * 1e3;
   function convertToUser(userInfo) {
     return {
@@ -279,12 +275,11 @@
     const refreshPromiseRef = react.useRef(null);
     const isMountedRef = react.useRef(true);
     react.useEffect(() => {
-      if (client) {
-        setApiUrl(client.baseUrl);
-      } else if (apiUrl) {
-        setApiUrl(apiUrl);
+      const url = client?.baseUrl || apiUrl;
+      if (url) {
+        setApiUrl(url);
       }
-    }, [client, apiUrl]);
+    }, [client, client?.baseUrl, apiUrl]);
     const clearError = react.useCallback(() => {
       setAuthProviderError(null);
     }, []);
@@ -400,7 +395,7 @@
     }, [initialLoading, refreshAccessToken$1, clearSessionAndSignOut]);
     react.useEffect(() => {
       if (client) {
-        client.setAuthTokenGetter(async () => {
+        client.setAuthTokenGetter?.(async () => {
           try {
             return await getAuthToken();
           } catch {
@@ -433,7 +428,7 @@
       if (defineRolesFor) {
         const customRoles = await defineRolesFor(convertedUser);
         if (customRoles) {
-          convertedUser = { ...convertedUser, roles: customRoles.map((r) => r.id) };
+          convertedUser = { ...convertedUser, roles: customRoles };
         }
       }
       saveAuthToStorage(tokens, userInfo);
@@ -564,7 +559,7 @@
           if (customRoles) {
             convertedUser = {
               ...convertedUser,
-              roles: customRoles.map((r) => r.id)
+              roles: customRoles
             };
           }
         }
@@ -638,7 +633,7 @@
             if (customRoles) {
               userToSet = {
                 ...userToSet,
-                roles: customRoles.map((r) => r.id)
+                roles: customRoles
               };
             }
           }
@@ -670,12 +665,16 @@
               if (customRoles) {
                 userToSet = {
                   ...userToSet,
-                  roles: customRoles.map((r) => r.id)
+                  roles: customRoles
                 };
               }
             }
           } catch (meError) {
             if (!isMountedRef.current) return;
+            if (meError instanceof AuthApiError && (meError.code === "NOT_FOUND" || meError.code === "UNAUTHORIZED")) {
+              clearSessionAndSignOut();
+              return;
+            }
             userToSet = convertToUser(stored.user);
           }
           if (!isMountedRef.current) return;
@@ -775,10 +774,10 @@
         emailPasswordLogin: true,
         googleLogin: !!props.googleClientId,
         registration: authConfig?.registrationEnabled ?? false,
-        passwordReset: true,
+        passwordReset: authConfig?.passwordReset ?? false,
         sessionManagement: true,
         profileUpdate: true,
-        emailVerification: false,
+        emailVerification: authConfig?.emailVerification ?? false,
         enabledProviders: authConfig?.enabledProviders ?? []
       }
     };
@@ -795,22 +794,29 @@
       createdAt: apiUser.createdAt ? new Date(apiUser.createdAt) : null
     };
   }
-  function convertRole(apiRole) {
-    return {
-      id: apiRole.id,
-      name: apiRole.name,
-      isAdmin: apiRole.isAdmin ?? false,
-      config: apiRole.config ?? void 0
-    };
-  }
   function useBackendUserManagement(config) {
     const { client, apiUrl, getAuthToken, currentUser } = config;
-    const [users, setUsers] = react.useState([]);
-    const [roles, setRoles] = react.useState([]);
-    const [loading, setLoading] = react.useState(true);
+    const [userCache, setUserCache] = react.useState(/* @__PURE__ */ new Map());
+    const [hasAdminUsers, setHasAdminUsers] = react.useState(false);
+    const userRoles = currentUser?.roles ?? [];
+    const isUserAdmin = userRoles.some((r) => r === "admin" || r === "schema-admin");
+    const [loading, setLoading] = react.useState(() => {
+      if (!currentUser) return false;
+      if (!isUserAdmin) return false;
+      return true;
+    });
     const [usersError, setUsersError] = react.useState();
-    const [rolesError, setRolesError] = react.useState();
     const lastLoadedUidRef = react.useRef(null);
+    const effectiveLoading = loading || !!(currentUser && isUserAdmin && lastLoadedUidRef.current !== currentUser.uid);
+    const mergeIntoCache = react.useCallback((incoming) => {
+      setUserCache((prev) => {
+        const next = new Map(prev);
+        for (const u of incoming) {
+          next.set(u.uid, u);
+        }
+        return next;
+      });
+    }, []);
     const apiRequestRef = react.useRef(null);
     const apiRequest = react.useCallback(async (endpoint, method = "GET", body, retryCount = 6, signal) => {
       let lastError = null;
@@ -821,7 +827,7 @@
           throw error;
         }
         try {
-          const token = getAuthToken ? await getAuthToken() : client ? await client.resolveToken() : null;
+          const token = getAuthToken ? await getAuthToken() : client?.resolveToken ? await client.resolveToken() : null;
           const baseUrl = apiUrl || (client?.baseUrl ? client.baseUrl : "");
           const response = await fetch(`${baseUrl}/api/admin${endpoint}`, {
             method,
@@ -880,37 +886,29 @@
       throw lastError;
     }, [apiUrl, getAuthToken]);
     apiRequestRef.current = apiRequest;
-    react.useCallback(async (signal) => {
+    const checkAdminExists = react.useCallback(async (signal) => {
       try {
-        const data = await apiRequest("/roles", "GET", void 0, 6, signal);
-        setRoles(data.roles.map(convertRole));
-        setRolesError(void 0);
-      } catch (error) {
-        if (error instanceof Error && error.name === "AbortError") return;
-        console.error("Failed to load roles:", error);
-        setRolesError(error instanceof Error ? error : new Error(String(error)));
-      }
-    }, [apiRequest]);
-    const loadUsers = react.useCallback(async (signal) => {
-      try {
-        const data = await apiRequest("/users", "GET", void 0, 6, signal);
-        const allUsers = data.users.map((u) => convertUser(u));
-        setUsers(allUsers);
+        const data = await apiRequest("/users?role=admin&limit=1", "GET", void 0, 6, signal);
+        const adminUsers = data.users.map((u) => convertUser(u));
+        setHasAdminUsers(adminUsers.length > 0);
+        if (adminUsers.length > 0) {
+          mergeIntoCache(adminUsers);
+        }
         setUsersError(void 0);
       } catch (error) {
         if (error instanceof Error && error.name === "AbortError") return;
-        console.error("Failed to load users:", error);
+        console.error("Failed to check admin users:", error);
         setUsersError(error instanceof Error ? error : new Error(String(error)));
       }
-    }, [apiRequest]);
+    }, [apiRequest, mergeIntoCache]);
     react.useEffect(() => {
       if (!currentUser) {
         setLoading(false);
         return;
       }
-      const userRoles = currentUser.roles ?? [];
-      const isUserAdmin = userRoles.some((r) => r === "admin" || r === "schema-admin");
-      if (!isUserAdmin) {
+      const userRoles2 = currentUser.roles ?? [];
+      const isUserAdmin2 = userRoles2.some((r) => r === "admin" || r === "schema-admin");
+      if (!isUserAdmin2) {
         setLoading(false);
         return;
       }
@@ -922,30 +920,18 @@
       const load = async () => {
         setLoading(true);
         const request = apiRequestRef.current;
-        try {
-          const data = await request("/roles", "GET", void 0, 6, abortController.signal);
-          setRoles(data.roles.map(convertRole));
-          setRolesError(void 0);
-        } catch (error) {
-          if (error instanceof Error && error.name === "AbortError") return;
-          console.error("Failed to load roles:", error);
-          setRolesError(error instanceof Error ? error : new Error(String(error)));
-          const status = error.status;
-          if (status === 403 || status === 401) {
-            setUsersError(error instanceof Error ? error : new Error(String(error)));
-            setLoading(false);
-            return;
-          }
-        }
         if (!abortController.signal.aborted) {
           try {
-            const data = await request("/users", "GET", void 0, 6, abortController.signal);
-            const allUsers = data.users.map((u) => convertUser(u));
-            setUsers(allUsers);
+            const data = await request("/users?role=admin&limit=1", "GET", void 0, 6, abortController.signal);
+            const adminUsers = data.users.map((u) => convertUser(u));
+            setHasAdminUsers(adminUsers.length > 0);
+            if (adminUsers.length > 0) {
+              mergeIntoCache(adminUsers);
+            }
             setUsersError(void 0);
           } catch (error) {
             if (error instanceof Error && error.name === "AbortError") return;
-            console.error("Failed to load users:", error);
+            console.error("Failed to check admin users:", error);
             setUsersError(error instanceof Error ? error : new Error(String(error)));
           }
         }
@@ -969,34 +955,24 @@
       if (options.roleId) params.set("role", options.roleId);
       const qs = params.toString();
       const data = await apiRequest("/users" + (qs ? "?" + qs : ""), "GET");
+      const converted = data.users.map((u) => convertUser(u));
+      mergeIntoCache(converted);
       return {
-        users: data.users.map((u) => convertUser(u)),
+        users: converted,
         total: data.total
       };
-    }, [apiRequest]);
+    }, [apiRequest, mergeIntoCache]);
     const saveUser = react.useCallback(async (user) => {
       const roleIds = user.roles ?? [];
-      const existingUser = users.find((u) => u.uid === user.uid);
-      if (existingUser) {
-        const data = await apiRequest(`/users/${user.uid}`, "PUT", {
-          email: user.email,
-          displayName: user.displayName,
-          roles: roleIds
-        });
-        const updated = convertUser(data.user);
-        setUsers((prev) => prev.map((u) => u.uid === updated.uid ? updated : u));
-        return updated;
-      } else {
-        const data = await apiRequest("/users", "POST", {
-          email: user.email,
-          displayName: user.displayName,
-          roles: roleIds
-        });
-        const created = convertUser(data.user);
-        setUsers((prev) => [...prev, created]);
-        return created;
-      }
-    }, [apiRequest, users, roles]);
+      const data = await apiRequest(`/users/${user.uid}`, "PUT", {
+        email: user.email,
+        displayName: user.displayName,
+        roles: roleIds
+      });
+      const updated = convertUser(data.user);
+      mergeIntoCache([updated]);
+      return updated;
+    }, [apiRequest, mergeIntoCache]);
     const createUser = react.useCallback(async (user) => {
       const roleIds = user.roles ?? [];
       const data = await apiRequest("/users", "POST", {
@@ -1005,97 +981,77 @@
         roles: roleIds
       });
       const created = convertUser(data.user);
-      setUsers((prev) => [...prev, created]);
+      mergeIntoCache([created]);
       return {
         user: created,
         invitationSent: data.invitationSent ?? false,
         temporaryPassword: data.temporaryPassword
       };
-    }, [apiRequest, roles]);
+    }, [apiRequest, mergeIntoCache]);
     const resetPassword2 = react.useCallback(async (user) => {
       const data = await apiRequest(`/users/${user.uid}/reset-password`, "POST");
       const updatedUser = convertUser(data.user);
-      setUsers((prev) => prev.map((u) => u.uid === updatedUser.uid ? updatedUser : u));
+      mergeIntoCache([updatedUser]);
       return {
         user: updatedUser,
         invitationSent: data.invitationSent ?? false,
         temporaryPassword: data.temporaryPassword
       };
-    }, [apiRequest]);
+    }, [apiRequest, mergeIntoCache]);
     const deleteUser = react.useCallback(async (user) => {
       await apiRequest(`/users/${user.uid}`, "DELETE");
-      setUsers((prev) => prev.filter((u) => u.uid !== user.uid));
-    }, [apiRequest]);
-    const saveRole = react.useCallback(async (role) => {
-      const existingRole = roles.find((r) => r.id === role.id);
-      if (existingRole) {
-        const data = await apiRequest(`/roles/${role.id}`, "PUT", {
-          name: role.name,
-          isAdmin: role.isAdmin,
-          config: role.config
-        });
-        const updated = convertRole(data.role);
-        setRoles((prev) => prev.map((r) => r.id === updated.id ? updated : r));
-      } else {
-        const data = await apiRequest("/roles", "POST", {
-          id: role.id,
-          name: role.name,
-          isAdmin: role.isAdmin ?? false,
-          config: role.config
-        });
-        const created = convertRole(data.role);
-        setRoles((prev) => [...prev, created]);
-      }
-    }, [apiRequest, roles]);
-    const deleteRole = react.useCallback(async (role) => {
-      await apiRequest(`/roles/${role.id}`, "DELETE");
-      setRoles((prev) => prev.filter((r) => r.id !== role.id));
+      setUserCache((prev) => {
+        const next = new Map(prev);
+        next.delete(user.uid);
+        return next;
+      });
     }, [apiRequest]);
     const getUser = react.useCallback((uid) => {
-      return users.find((u) => u.uid === uid) ?? null;
-    }, [users]);
+      return userCache.get(uid) ?? null;
+    }, [userCache]);
     const defineRolesFor = react.useCallback(async (user) => {
-      const existingUser = users.find((u) => u.uid === user.uid || u.email === user.email);
-      if (!existingUser) return void 0;
+      let existingUser = userCache.get(user.uid) ?? Array.from(userCache.values()).find((u) => u.email === user.email);
+      if (!existingUser) {
+        try {
+          const data = await apiRequest(`/users/${user.uid}`, "GET");
+          existingUser = convertUser(data.user);
+          mergeIntoCache([existingUser]);
+        } catch {
+          return void 0;
+        }
+      }
       const userRoleIds = existingUser.roles ?? [];
-      return roles.filter((r) => userRoleIds.includes(r.id));
-    }, [users, roles]);
+      return userRoleIds;
+    }, [userCache, apiRequest, mergeIntoCache]);
     const isAdmin = currentUser?.roles?.includes("admin") ?? false;
     const bootstrapAdmin = react.useCallback(async () => {
       try {
         await apiRequest("/bootstrap", "POST");
-        const data = await apiRequest("/roles");
-        const loadedRoles = data.roles.map(convertRole);
-        setRoles(loadedRoles);
-        await loadUsers();
+        await checkAdminExists();
       } catch (error) {
         console.error("Failed to bootstrap admin:", error);
         throw error;
       }
-    }, [apiRequest, loadUsers]);
+    }, [apiRequest, checkAdminExists]);
+    const users = Array.from(userCache.values());
     return {
-      loading,
+      loading: effectiveLoading,
       users,
+      hasAdminUsers,
       saveUser,
       createUser,
       resetPassword: resetPassword2,
       deleteUser,
-      roles,
-      saveRole,
-      deleteRole,
       isAdmin,
       allowDefaultRolesCreation: isAdmin,
-      includeCollectionConfigPermissions: true,
       defineRolesFor,
       getUser,
       searchUsers,
       usersError,
-      rolesError,
       bootstrapAdmin
     };
   }
   exports2.AuthApiError = AuthApiError;
-  exports2.clearAuthConfigCache = clearAuthConfigCache;
   exports2.fetchAuthConfig = fetchAuthConfig;
   exports2.getApiUrl = getApiUrl;
   exports2.setApiUrl = setApiUrl;