@korajs/auth 0.4.0 → 0.6.0

package/dist/react.cjs

@@ -23,6 +23,8 @@ __export(react_exports, {
   AuthContext: () => AuthContext,
   AuthProvider: () => AuthProvider,
   OrgContext: () => OrgContext,
+  OrgProvider: () => OrgProvider,
+  checkOrgPermission: () => checkOrgPermission,
   useAuth: () => useAuth,
   useAuthStatus: () => useAuthStatus,
   useCurrentUser: () => useCurrentUser,
@@ -35,41 +37,132 @@ module.exports = __toCommonJS(react_exports);
 // src/react/AuthProvider.tsx
 var import_react2 = require("react");
 
+// src/bindings/create-auth-session.ts
+function createAuthSession(client) {
+  let state = client.state;
+  let isLoading = true;
+  let initError = null;
+  let lastError = null;
+  const listeners = /* @__PURE__ */ new Set();
+  let snapshot = buildSnapshot2();
+  const refreshSnapshot = () => {
+    snapshot = buildSnapshot2();
+  };
+  const notify = () => {
+    refreshSnapshot();
+    for (const listener of listeners) {
+      listener();
+    }
+  };
+  function buildSnapshot2() {
+    return {
+      state,
+      user: client.currentUser,
+      isAuthenticated: state === "authenticated",
+      isLoading,
+      initError,
+      error: lastError
+    };
+  }
+  const captureError = (error) => {
+    lastError = error instanceof Error ? error.message : String(error);
+    notify();
+  };
+  const run = async (action) => {
+    lastError = null;
+    try {
+      await action();
+    } catch (error) {
+      captureError(error);
+    }
+  };
+  const runWithResult = async (action) => {
+    lastError = null;
+    try {
+      return await action();
+    } catch (error) {
+      captureError(error);
+      return null;
+    }
+  };
+  const unsubscribeAuth = client.onAuthChange((nextState) => {
+    state = nextState;
+    notify();
+  });
+  void client.initialize().then(() => {
+    state = client.state;
+    isLoading = false;
+    notify();
+  }).catch((error) => {
+    initError = error instanceof Error ? error : new Error(String(error));
+    isLoading = false;
+    notify();
+  });
+  return {
+    client,
+    getSnapshot: () => snapshot,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    signUp: (params) => run(async () => {
+      await client.signUp(params);
+    }),
+    signIn: (params) => run(async () => {
+      await client.signIn(params);
+    }),
+    signInWithOAuth: async (provider, options) => {
+      lastError = null;
+      try {
+        return await client.signInWithOAuth(provider, options);
+      } catch (error) {
+        captureError(error);
+        throw error instanceof Error ? error : new Error(String(error));
+      }
+    },
+    completeOAuthSignIn: (provider, params) => run(async () => {
+      await client.completeOAuthSignIn(provider, params);
+    }),
+    getOAuthAuthorizationUrl: async (provider, options) => {
+      lastError = null;
+      try {
+        return await client.getOAuthAuthorizationUrl(provider, options);
+      } catch (error) {
+        captureError(error);
+        throw error instanceof Error ? error : new Error(String(error));
+      }
+    },
+    linkOAuth: (provider, params) => runWithResult(async () => client.linkOAuth(provider, params)),
+    listLinkedAccounts: () => runWithResult(async () => client.listLinkedAccounts()).then((value) => value ?? []),
+    unlinkOAuth: (provider) => run(async () => {
+      await client.unlinkOAuth(provider);
+    }),
+    signOut: () => run(async () => {
+      await client.signOut();
+    }),
+    destroy() {
+      unsubscribeAuth();
+      listeners.clear();
+    }
+  };
+}
+
 // src/react/auth-context.ts
 var import_react = require("react");
 var AuthContext = (0, import_react.createContext)(null);
 
 // src/react/AuthProvider.tsx
 function AuthProvider({ client, children, fallback }) {
-  const [state, setState] = (0, import_react2.useState)(client.state);
-  const [isLoading, setIsLoading] = (0, import_react2.useState)(true);
-  const [initError, setInitError] = (0, import_react2.useState)(null);
-  (0, import_react2.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 = (0, import_react2.useMemo)(() => createAuthSession(client), [client]);
+  (0, import_react2.useEffect)(() => () => session.destroy(), [session]);
+  const snapshot = (0, import_react2.useSyncExternalStore)(
+    (onStoreChange) => session.subscribe(onStoreChange),
+    () => session.getSnapshot(),
+    () => session.getSnapshot()
+  );
+  if (snapshot.initError) {
     return (0, import_react2.createElement)(
       "div",
       {
@@ -77,16 +170,17 @@ function AuthProvider({ client, children, fallback }) {
         role: "alert"
       },
       (0, import_react2.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 (0, import_react2.createElement)(AuthContext.Provider, { value: contextValue }, children);
 }
@@ -102,102 +196,130 @@ function useAuthContext() {
   }
   return ctx;
 }
+function useAuthSessionSnapshot() {
+  const { session } = useAuthContext();
+  return (0, import_react3.useSyncExternalStore)(
+    (onStoreChange) => session.subscribe(onStoreChange),
+    () => session.getSnapshot(),
+    () => session.getSnapshot()
+  );
+}
 function useAuth() {
-  const { client, state, isLoading } = useAuthContext();
-  const [error, setError] = (0, import_react3.useState)(null);
-  const userSnapshotRef = (0, import_react3.useRef)(client.currentUser);
-  const stateSerializedRef = (0, import_react3.useRef)(JSON.stringify(client.currentUser));
-  const subscribe = (0, import_react3.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();
-        }
-      });
+  const { session } = useAuthContext();
+  const snapshot = useAuthSessionSnapshot();
+  return {
+    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() {
+  return useAuthSessionSnapshot().user;
+}
+function useAuthStatus() {
+  const snapshot = useAuthSessionSnapshot();
+  return {
+    state: snapshot.state,
+    isAuthenticated: snapshot.isAuthenticated,
+    isLoading: snapshot.isLoading
+  };
+}
+
+// src/react/OrgProvider.tsx
+var import_react5 = require("react");
+
+// src/bindings/create-org-session.ts
+var ROLE_LEVELS = {
+  viewer: 10,
+  billing: 15,
+  member: 20,
+  admin: 30,
+  owner: 40
+};
+function checkOrgPermission(currentRole, requiredRole) {
+  if (!currentRole) return false;
+  const currentLevel = ROLE_LEVELS[currentRole] ?? 0;
+  const requiredLevel = ROLE_LEVELS[requiredRole] ?? 0;
+  return currentLevel >= requiredLevel;
+}
+function createOrgSession(client) {
+  let snapshot = buildSnapshot(client);
+  const listeners = /* @__PURE__ */ new Set();
+  const notify = () => {
+    snapshot = buildSnapshot(client);
+    for (const listener of listeners) {
+      listener();
+    }
+  };
+  const unsubscribeOrgChange = client.onOrgChange(notify);
+  return {
+    client,
+    getSnapshot: () => snapshot,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
     },
-    [client]
-  );
-  const getSnapshot = (0, import_react3.useCallback)(() => {
-    return userSnapshotRef.current;
-  }, []);
-  const user = (0, import_react3.useSyncExternalStore)(subscribe, getSnapshot);
-  const signUp = (0, import_react3.useCallback)(
-    async (params) => {
-      setError(null);
+    checkPermission(requiredRole) {
+      return checkOrgPermission(snapshot.role, requiredRole);
+    },
+    destroy() {
+      unsubscribeOrgChange();
+      listeners.clear();
+    }
+  };
+}
+function buildSnapshot(client) {
+  return {
+    orgId: client.activeOrgId,
+    org: client.activeOrg,
+    role: client.activeRole
+  };
+}
+function createOrgMembersActions(client, orgId, onError) {
+  return {
+    async refresh() {
+      await client.listMembers(orgId);
+    },
+    async invite(email, role) {
       try {
-        await client.signUp(params);
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        setError(message);
+        return await client.inviteMember(orgId, { email, role });
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        onError(message);
+        throw error;
       }
     },
-    [client]
-  );
-  const signIn = (0, import_react3.useCallback)(
-    async (params) => {
-      setError(null);
+    async removeMember(userId) {
       try {
-        await client.signIn(params);
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err);
-        setError(message);
+        await client.removeMember(orgId, userId);
+      } catch (error) {
+        onError(error instanceof Error ? error.message : String(error));
       }
     },
-    [client]
-  );
-  const signOut = (0, import_react3.useCallback)(async () => {
-    setError(null);
-    try {
-      await client.signOut();
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      setError(message);
+    async updateRole(userId, role) {
+      try {
+        await client.updateMemberRole(orgId, userId, role);
+      } catch (error) {
+        onError(error instanceof Error ? error.message : String(error));
+      }
     }
-  }, [client]);
-  return {
-    user,
-    isAuthenticated: state === "authenticated",
-    isLoading,
-    signUp,
-    signIn,
-    signOut,
-    error
   };
 }
-function useCurrentUser() {
-  const { client } = useAuthContext();
-  const userSnapshotRef = (0, import_react3.useRef)(client.currentUser);
-  const stateSerializedRef = (0, import_react3.useRef)(JSON.stringify(client.currentUser));
-  const subscribe = (0, import_react3.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 = (0, import_react3.useCallback)(() => {
-    return userSnapshotRef.current;
-  }, []);
-  return (0, import_react3.useSyncExternalStore)(subscribe, getSnapshot);
-}
-function useAuthStatus() {
-  const { state, isLoading } = useAuthContext();
-  return {
-    state,
-    isAuthenticated: state === "authenticated",
-    isLoading
-  };
+async function loadOrgMembers(client, orgId) {
+  return client.listMembers(orgId);
 }
 
 // src/react/org-hooks.ts
@@ -212,29 +334,24 @@ function useOrgContext() {
   }
   return ctx;
 }
-function useOrg() {
-  const { client } = useOrgContext();
-  const [error, setError] = (0, import_react4.useState)(null);
-  const orgSnapshotRef = (0, import_react4.useRef)({
-    orgId: client.activeOrgId,
-    org: client.activeOrg,
-    role: client.activeRole
-  });
+function useOrgSnapshot(session) {
+  const snapshotRef = (0, import_react4.useRef)(session.getSnapshot());
   const subscribe = (0, import_react4.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 = (0, import_react4.useCallback)(() => orgSnapshotRef.current, []);
-  const { orgId, org, role } = (0, import_react4.useSyncExternalStore)(subscribe, getSnapshot);
+  const getSnapshot = (0, import_react4.useCallback)(() => snapshotRef.current, []);
+  return (0, import_react4.useSyncExternalStore)(subscribe, getSnapshot);
+}
+function useOrg() {
+  const { client, session } = useOrgContext();
+  const { orgId, org, role } = useOrgSnapshot(session);
+  const [error, setError] = (0, import_react4.useState)(null);
   const switchOrg = (0, import_react4.useCallback)(
     async (newOrgId) => {
       setError(null);
@@ -290,8 +407,7 @@ function useOrgMembers(orgId) {
     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 {
@@ -299,84 +415,82 @@ function useOrgMembers(orgId) {
     }
   }, [client, orgId]);
   (0, import_react4.useEffect)(() => {
-    refresh();
+    void refresh();
   }, [refresh]);
+  const actions = createOrgMembersActions(client, orgId, setError);
   const invite = (0, import_react4.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 = (0, import_react4.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 = (0, import_react4.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 = (0, import_react4.useRef)(checkPermission(client.activeRole, requiredRole));
+  const { session } = useOrgContext();
+  const snapshotRef = (0, import_react4.useRef)(session.checkPermission(requiredRole));
   const subscribe = (0, import_react4.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 = (0, import_react4.useCallback)(() => snapshotRef.current, []);
   return (0, import_react4.useSyncExternalStore)(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
+var import_jsx_runtime = require("react/jsx-runtime");
+function OrgProvider({ client, children }) {
+  const sessionRef = (0, import_react5.useRef)(null);
+  if (sessionRef.current === null || sessionRef.current.client !== client) {
+    sessionRef.current?.destroy();
+    sessionRef.current = createOrgSession(client);
+  }
+  (0, import_react5.useEffect)(() => {
+    return () => {
+      sessionRef.current?.destroy();
+      sessionRef.current = null;
+    };
+  }, []);
+  const value = (0, import_react5.useMemo)(
+    () => ({
+      client,
+      session: sessionRef.current
+    }),
+    [client]
+  );
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(OrgContext.Provider, { value, children });
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AuthContext,
   AuthProvider,
   OrgContext,
+  OrgProvider,
+  checkOrgPermission,
   useAuth,
   useAuthStatus,
   useCurrentUser,