@korajs/auth 0.5.0 → 1.0.0-beta.0

package/dist/react.js

@@ -1,5 +1,13 @@
+import {
+  checkOrgPermission,
+  createAuthSession,
+  createOrgMembersActions,
+  createOrgSession,
+  loadOrgMembers
+} from "./chunk-MPMXJ62R.js";
+
 // src/react/AuthProvider.tsx
-import { createElement, useEffect, useState } from "react";
+import { createElement, useEffect, useMemo, useSyncExternalStore } from "react";
 
 // src/react/auth-context.ts
 import { createContext } from "react";
@@ -7,35 +15,14 @@ var AuthContext = createContext(null);
 
 // src/react/AuthProvider.tsx
 function AuthProvider({ client, children, fallback }) {
-  const [state, setState] = useState(client.state);
-  const [isLoading, setIsLoading] = useState(true);
-  const [initError, setInitError] = useState(null);
-  useEffect(() => {
-    let cancelled = false;
-    const unsubscribe = client.onAuthChange((newState) => {
-      if (!cancelled) {
-        setState(newState);
-      }
-    });
-    client.initialize().then(() => {
-      if (!cancelled) {
-        setState(client.state);
-        setIsLoading(false);
-      }
-    }).catch((error) => {
-      if (!cancelled) {
-        const err = error instanceof Error ? error : new Error(String(error));
-        console.error("[Kora Auth] Initialization failed:", err);
-        setInitError(err);
-        setIsLoading(false);
-      }
-    });
-    return () => {
-      cancelled = true;
-      unsubscribe();
-    };
-  }, [client]);
-  if (initError) {
+  const session = useMemo(() => createAuthSession(client), [client]);
+  useEffect(() => () => session.destroy(), [session]);
+  const snapshot = useSyncExternalStore(
+    (onStoreChange) => session.subscribe(onStoreChange),
+    () => session.getSnapshot(),
+    () => session.getSnapshot()
+  );
+  if (snapshot.initError) {
     return createElement(
       "div",
       {
@@ -43,22 +30,23 @@ function AuthProvider({ client, children, fallback }) {
         role: "alert"
       },
       createElement("strong", null, "Kora Auth initialization error: "),
-      initError.message
+      snapshot.initError.message
     );
   }
-  if (isLoading && fallback !== void 0) {
+  if (snapshot.isLoading && fallback !== void 0) {
     return fallback;
   }
   const contextValue = {
     client,
-    state,
-    isLoading
+    session,
+    state: snapshot.state,
+    isLoading: snapshot.isLoading
   };
   return createElement(AuthContext.Provider, { value: contextValue }, children);
 }
 
 // src/react/hooks.ts
-import { useCallback, useContext, useRef, useState as useState2, useSyncExternalStore } from "react";
+import { useContext, useSyncExternalStore as useSyncExternalStore2 } from "react";
 function useAuthContext() {
   const ctx = useContext(AuthContext);
   if (ctx === null) {
@@ -68,192 +56,58 @@ function useAuthContext() {
   }
   return ctx;
 }
-function useAuth() {
-  const { client, state, isLoading } = useAuthContext();
-  const [error, setError] = useState2(null);
-  const userSnapshotRef = useRef(client.currentUser);
-  const stateSerializedRef = useRef(JSON.stringify(client.currentUser));
-  const subscribe = useCallback(
-    (onStoreChange) => {
-      return client.onAuthChange(() => {
-        const newUser = client.currentUser;
-        const newSerialized = JSON.stringify(newUser);
-        if (newSerialized !== stateSerializedRef.current) {
-          userSnapshotRef.current = newUser;
-          stateSerializedRef.current = newSerialized;
-          onStoreChange();
-        }
-      });
-    },
-    [client]
-  );
-  const getSnapshot = useCallback(() => {
-    return userSnapshotRef.current;
-  }, []);
-  const user = useSyncExternalStore(subscribe, getSnapshot);
-  const signUp = useCallback(
-    async (params) => {
-      setError(null);
-      try {
-        await client.signUp(params);
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        setError(message);
-      }
-    },
-    [client]
-  );
-  const signIn = useCallback(
-    async (params) => {
-      setError(null);
-      try {
-        await client.signIn(params);
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        setError(message);
-      }
-    },
-    [client]
-  );
-  const signInWithOAuth = useCallback(
-    async (provider, options) => {
-      setError(null);
-      try {
-        return await client.signInWithOAuth(provider, options);
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        setError(message);
-        throw err;
-      }
-    },
-    [client]
-  );
-  const completeOAuthSignIn = useCallback(
-    async (provider, params) => {
-      setError(null);
-      try {
-        await client.completeOAuthSignIn(provider, params);
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        setError(message);
-      }
-    },
-    [client]
-  );
-  const getOAuthAuthorizationUrl = useCallback(
-    async (provider, options) => {
-      setError(null);
-      try {
-        return await client.getOAuthAuthorizationUrl(provider, options);
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        setError(message);
-        throw err;
-      }
-    },
-    [client]
-  );
-  const linkOAuth = useCallback(
-    async (provider, params) => {
-      setError(null);
-      try {
-        return await client.linkOAuth(provider, params);
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        setError(message);
-        return null;
-      }
-    },
-    [client]
+function useAuthSessionSnapshot() {
+  const { session } = useAuthContext();
+  return useSyncExternalStore2(
+    (onStoreChange) => session.subscribe(onStoreChange),
+    () => session.getSnapshot(),
+    () => session.getSnapshot()
   );
-  const listLinkedAccounts = useCallback(async () => {
-    setError(null);
-    try {
-      return await client.listLinkedAccounts();
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      setError(message);
-      return [];
-    }
-  }, [client]);
-  const unlinkOAuth = useCallback(
-    async (provider) => {
-      setError(null);
-      try {
-        await client.unlinkOAuth(provider);
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        setError(message);
-      }
-    },
-    [client]
-  );
-  const signOut = useCallback(async () => {
-    setError(null);
-    try {
-      await client.signOut();
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      setError(message);
-    }
-  }, [client]);
+}
+function useAuth() {
+  const { session } = useAuthContext();
+  const snapshot = useAuthSessionSnapshot();
   return {
-    user,
-    isAuthenticated: state === "authenticated",
-    isLoading,
-    signUp,
-    signIn,
-    signInWithOAuth,
-    completeOAuthSignIn,
-    getOAuthAuthorizationUrl,
-    linkOAuth,
-    listLinkedAccounts,
-    unlinkOAuth,
-    signOut,
-    error
+    user: snapshot.user,
+    isAuthenticated: snapshot.isAuthenticated,
+    isLoading: snapshot.isLoading,
+    error: snapshot.error,
+    initError: snapshot.initError,
+    signUp: (params) => session.signUp(params),
+    signIn: (params) => session.signIn(params),
+    signInWithOAuth: (provider, options) => session.signInWithOAuth(provider, options),
+    completeOAuthSignIn: (provider, params) => session.completeOAuthSignIn(provider, params),
+    getOAuthAuthorizationUrl: (provider, options) => session.getOAuthAuthorizationUrl(provider, options),
+    linkOAuth: (provider, params) => session.linkOAuth(provider, params),
+    listLinkedAccounts: () => session.listLinkedAccounts(),
+    unlinkOAuth: (provider) => session.unlinkOAuth(provider),
+    signOut: () => session.signOut()
   };
 }
 function useCurrentUser() {
-  const { client } = useAuthContext();
-  const userSnapshotRef = useRef(client.currentUser);
-  const stateSerializedRef = useRef(JSON.stringify(client.currentUser));
-  const subscribe = useCallback(
-    (onStoreChange) => {
-      return client.onAuthChange(() => {
-        const newUser = client.currentUser;
-        const newSerialized = JSON.stringify(newUser);
-        if (newSerialized !== stateSerializedRef.current) {
-          userSnapshotRef.current = newUser;
-          stateSerializedRef.current = newSerialized;
-          onStoreChange();
-        }
-      });
-    },
-    [client]
-  );
-  const getSnapshot = useCallback(() => {
-    return userSnapshotRef.current;
-  }, []);
-  return useSyncExternalStore(subscribe, getSnapshot);
+  return useAuthSessionSnapshot().user;
 }
 function useAuthStatus() {
-  const { state, isLoading } = useAuthContext();
+  const snapshot = useAuthSessionSnapshot();
   return {
-    state,
-    isAuthenticated: state === "authenticated",
-    isLoading
+    state: snapshot.state,
+    isAuthenticated: snapshot.isAuthenticated,
+    isLoading: snapshot.isLoading
   };
 }
 
+// src/react/OrgProvider.tsx
+import { useEffect as useEffect3, useMemo as useMemo2, useRef as useRef2 } from "react";
+
 // src/react/org-hooks.ts
 import {
   createContext as createContext2,
-  useCallback as useCallback2,
+  useCallback,
   useContext as useContext2,
-  useEffect as useEffect3,
-  useRef as useRef2,
-  useState as useState3,
-  useSyncExternalStore as useSyncExternalStore2
+  useEffect as useEffect2,
+  useRef,
+  useState,
+  useSyncExternalStore as useSyncExternalStore3
 } from "react";
 var OrgContext = createContext2(null);
 function useOrgContext() {
@@ -265,30 +119,25 @@ function useOrgContext() {
   }
   return ctx;
 }
-function useOrg() {
-  const { client } = useOrgContext();
-  const [error, setError] = useState3(null);
-  const orgSnapshotRef = useRef2({
-    orgId: client.activeOrgId,
-    org: client.activeOrg,
-    role: client.activeRole
-  });
-  const subscribe = useCallback2(
+function useOrgSnapshot(session) {
+  const snapshotRef = useRef(session.getSnapshot());
+  const subscribe = useCallback(
     (onStoreChange) => {
-      return client.onOrgChange(() => {
-        orgSnapshotRef.current = {
-          orgId: client.activeOrgId,
-          org: client.activeOrg,
-          role: client.activeRole
-        };
+      return session.subscribe(() => {
+        snapshotRef.current = session.getSnapshot();
         onStoreChange();
       });
     },
-    [client]
+    [session]
   );
-  const getSnapshot = useCallback2(() => orgSnapshotRef.current, []);
-  const { orgId, org, role } = useSyncExternalStore2(subscribe, getSnapshot);
-  const switchOrg = useCallback2(
+  const getSnapshot = useCallback(() => snapshotRef.current, []);
+  return useSyncExternalStore3(subscribe, getSnapshot);
+}
+function useOrg() {
+  const { client, session } = useOrgContext();
+  const { orgId, org, role } = useOrgSnapshot(session);
+  const [error, setError] = useState(null);
+  const switchOrg = useCallback(
     async (newOrgId) => {
       setError(null);
       try {
@@ -299,7 +148,7 @@ function useOrg() {
     },
     [client]
   );
-  const createOrg = useCallback2(
+  const createOrg = useCallback(
     async (params) => {
       setError(null);
       try {
@@ -312,7 +161,7 @@ function useOrg() {
     },
     [client]
   );
-  const leaveOrg = useCallback2(async () => {
+  const leaveOrg = useCallback(async () => {
     if (!orgId) return;
     setError(null);
     try {
@@ -321,10 +170,10 @@ function useOrg() {
       setError(err instanceof Error ? err.message : String(err));
     }
   }, [client, orgId]);
-  const clearOrg = useCallback2(() => {
+  const clearOrg = useCallback(() => {
     client.clearActiveOrg();
   }, [client]);
-  const listOrgs = useCallback2(async () => {
+  const listOrgs = useCallback(async () => {
     try {
       return await client.listOrgs();
     } catch (err) {
@@ -336,99 +185,97 @@ function useOrg() {
 }
 function useOrgMembers(orgId) {
   const { client } = useOrgContext();
-  const [members, setMembers] = useState3([]);
-  const [isLoading, setIsLoading] = useState3(true);
-  const [error, setError] = useState3(null);
-  const refresh = useCallback2(async () => {
+  const [members, setMembers] = useState([]);
+  const [isLoading, setIsLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const refresh = useCallback(async () => {
     setIsLoading(true);
     setError(null);
     try {
-      const result = await client.listMembers(orgId);
-      setMembers(result);
+      setMembers(await loadOrgMembers(client, orgId));
     } catch (err) {
       setError(err instanceof Error ? err.message : String(err));
     } finally {
       setIsLoading(false);
     }
   }, [client, orgId]);
-  useEffect3(() => {
-    refresh();
+  useEffect2(() => {
+    void refresh();
   }, [refresh]);
-  const invite = useCallback2(
+  const actions = createOrgMembersActions(client, orgId, setError);
+  const invite = useCallback(
     async (email, role) => {
-      setError(null);
-      try {
-        const result = await client.inviteMember(orgId, { email, role });
-        return result;
-      } catch (err) {
-        const msg = err instanceof Error ? err.message : String(err);
-        setError(msg);
-        throw err;
-      }
+      const result = await actions.invite(email, role);
+      await refresh();
+      return result;
     },
-    [client, orgId]
+    [actions, refresh]
   );
-  const removeMember = useCallback2(
+  const removeMember = useCallback(
     async (userId) => {
-      setError(null);
-      try {
-        await client.removeMember(orgId, userId);
-        await refresh();
-      } catch (err) {
-        setError(err instanceof Error ? err.message : String(err));
-      }
+      await actions.removeMember(userId);
+      await refresh();
     },
-    [client, orgId, refresh]
+    [actions, refresh]
   );
-  const updateRole = useCallback2(
+  const updateRole = useCallback(
     async (userId, role) => {
-      setError(null);
-      try {
-        await client.updateMemberRole(orgId, userId, role);
-        await refresh();
-      } catch (err) {
-        setError(err instanceof Error ? err.message : String(err));
-      }
+      await actions.updateRole(userId, role);
+      await refresh();
     },
-    [client, orgId, refresh]
+    [actions, refresh]
   );
   return { members, isLoading, refresh, invite, removeMember, updateRole, error };
 }
 function usePermission(requiredRole) {
-  const { client } = useOrgContext();
-  const snapshotRef = useRef2(checkPermission(client.activeRole, requiredRole));
-  const subscribe = useCallback2(
+  const { session } = useOrgContext();
+  const snapshotRef = useRef(session.checkPermission(requiredRole));
+  const subscribe = useCallback(
     (onStoreChange) => {
-      return client.onOrgChange(() => {
-        const newValue = checkPermission(client.activeRole, requiredRole);
-        if (newValue !== snapshotRef.current) {
-          snapshotRef.current = newValue;
+      return session.subscribe(() => {
+        const next = session.checkPermission(requiredRole);
+        if (next !== snapshotRef.current) {
+          snapshotRef.current = next;
           onStoreChange();
         }
       });
     },
-    [client, requiredRole]
+    [session, requiredRole]
   );
-  const getSnapshot = useCallback2(() => snapshotRef.current, []);
-  return useSyncExternalStore2(subscribe, getSnapshot);
+  const getSnapshot = useCallback(() => snapshotRef.current, []);
+  return useSyncExternalStore3(subscribe, getSnapshot);
 }
-var ROLE_LEVELS = {
-  viewer: 10,
-  billing: 15,
-  member: 20,
-  admin: 30,
-  owner: 40
-};
-function checkPermission(currentRole, requiredRole) {
-  if (!currentRole) return false;
-  const currentLevel = ROLE_LEVELS[currentRole] ?? 0;
-  const requiredLevel = ROLE_LEVELS[requiredRole] ?? 0;
-  return currentLevel >= requiredLevel;
+
+// src/react/OrgProvider.tsx
+import { jsx } from "react/jsx-runtime";
+function OrgProvider({ client, children }) {
+  const sessionRef = useRef2(null);
+  if (sessionRef.current === null || sessionRef.current.client !== client) {
+    sessionRef.current?.destroy();
+    sessionRef.current = createOrgSession(client);
+  }
+  useEffect3(() => {
+    return () => {
+      sessionRef.current?.destroy();
+      sessionRef.current = null;
+    };
+  }, []);
+  const session = sessionRef.current;
+  const value = useMemo2(
+    () => ({
+      client,
+      session
+    }),
+    [client, session]
+  );
+  return /* @__PURE__ */ jsx(OrgContext.Provider, { value, children });
 }
 export {
   AuthContext,
   AuthProvider,
   OrgContext,
+  OrgProvider,
+  checkOrgPermission,
   useAuth,
   useAuthStatus,
   useCurrentUser,