talizen 0.2.14 → 0.2.16

package/README.md

@@ -115,9 +115,7 @@ When a `File` object appears in the payload, `submitForm()` will:
 import {
   currentUser,
   listAuthProviders,
-  login,
   loginWithOAuth,
-  logout,
   register,
   updateProfile,
   useAuth,
@@ -129,13 +127,11 @@ await register({
   name: "Alice",
   email: "hi@talizen.com",
 });
-await login({ account: "alice", password: "secret" });
 
 const user = await currentUser();
 await updateProfile({
   address: "No. 1 Example Road",
 });
-await logout();
 
 const providers = await listAuthProviders();
 console.log(providers.map((provider) => provider.key));
@@ -143,9 +139,9 @@ console.log(providers.map((provider) => provider.key));
 await loginWithOAuth("github", { redirectUrl: "/account" });
 
 function AccountBadge() {
-  const { user, loading, logout } = useAuth();
+  const { user, loading, login, logout } = useAuth();
   if (loading) return <span>Loading...</span>;
-  if (!user) return <a href="/login">Sign in</a>;
+  if (!user) return <button onClick={() => login("alice", "secret")}>Sign in</button>;
   return <button onClick={() => logout()}>{user.name ?? user.account ?? "Logout"}</button>;
 }
 ```
@@ -231,7 +227,7 @@ Func HTTP responses use the HTTP status code rather than a top-level `ok` field.
 ## Package Layout
 
 - `talizen/core`: shared runtime config, request helpers, and base data types.
-- `talizen/auth`: project user register, login, logout, and current user helpers.
+- `talizen/auth`: project user register, current user helpers, and the React `useAuth()` state hook for login/logout flows.
 - `talizen/cms`: CMS content types and content query APIs.
 - `talizen/form`: form submission helpers and related types.
 - `talizen/func`: custom function invocation helpers such as `invoke`.

package/auth.d.ts

@@ -49,18 +49,22 @@ export interface AuthProviderListResponse {
 export interface AuthOAuthLoginURLOptions extends TalizenRequestOptions {
     redirectUrl?: string;
 }
+export type User = AuthUser;
 export declare class TalizenAuthError extends Error {
     constructor(message: string);
 }
 export declare function register(input: AuthRegisterInput, options?: TalizenRequestOptions): Promise<AuthUser>;
-export declare function login(input: AuthPasswordInput, options?: TalizenRequestOptions): Promise<AuthUser>;
 export interface UseAuthResult {
     user: AuthUser | null;
     loading: boolean;
     error: unknown;
+    isAuthenticated: boolean;
+    isInitialized: boolean;
     refresh(): Promise<AuthUser | null>;
     login(input: AuthPasswordInput): Promise<AuthUser>;
+    login(account: string, password: string): Promise<AuthUser>;
     register(input: AuthRegisterInput): Promise<AuthUser>;
+    register(account: string, password: string, name?: string): Promise<AuthUser>;
     logout(): Promise<void>;
     updateProfile(profile: AuthProfile): Promise<AuthUser>;
 }
@@ -71,7 +75,6 @@ export interface UseAuthResult {
  * config, which lets preview auth headers update the page without remounting.
  */
 export declare function useAuth(options?: TalizenRequestOptions): UseAuthResult;
-export declare function logout(options?: TalizenRequestOptions): Promise<void>;
 export declare function currentUser(options?: TalizenRequestOptions): Promise<AuthUser | null>;
 export declare function updateProfile(profile: AuthProfile, options?: TalizenRequestOptions): Promise<AuthUser>;
 export declare function requireUser(options?: TalizenRequestOptions): Promise<AuthUser>;

package/auth.js

@@ -1,5 +1,5 @@
 import * as React from "react";
-import { getTalizenConfig, requestJson, subscribeTalizenConfig, } from "./core.js";
+import { getTalizenConfig, requestJson, subscribeTalizenConfig, TalizenHttpError, } from "./core.js";
 export class TalizenAuthError extends Error {
     constructor(message) {
         super(message);
@@ -12,14 +12,108 @@ export async function register(input, options) {
         body: JSON.stringify(input),
     }, options);
 }
-export async function login(input, options) {
+async function loginRequest(input, options) {
     return requestJson("/auth/login", {
         method: "POST",
         body: JSON.stringify(input),
     }, options);
 }
-function readAuthConfigSnapshot() {
-    return getTalizenConfig();
+const authListeners = new Set();
+let currentUserState = null;
+let authErrorState = null;
+let isAuthInitialized = false;
+let isAuthLoading = false;
+let authSnapshot = readAuthSnapshot();
+let authRequestId = 0;
+let isAuthConfigSubscriptionStarted = false;
+function readAuthSnapshot() {
+    return {
+        user: currentUserState,
+        loading: isAuthLoading,
+        error: authErrorState,
+        isAuthenticated: !!currentUserState,
+        isInitialized: isAuthInitialized,
+    };
+}
+function emitAuthChange() {
+    authSnapshot = readAuthSnapshot();
+    authListeners.forEach(listener => listener());
+}
+function subscribeAuth(listener) {
+    authListeners.add(listener);
+    return () => {
+        authListeners.delete(listener);
+    };
+}
+function ensureAuthConfigSubscription() {
+    if (isAuthConfigSubscriptionStarted)
+        return;
+    isAuthConfigSubscriptionStarted = true;
+    subscribeTalizenConfig(() => {
+        void refreshAuthState().catch(() => { });
+    });
+}
+function normalizeLoginInput(input, password) {
+    if (typeof input === "string") {
+        return {
+            account: input,
+            password: password ?? "",
+        };
+    }
+    return input;
+}
+function normalizeRegisterInput(input, password, name) {
+    if (typeof input === "string") {
+        return {
+            account: input,
+            email: input,
+            password: password ?? "",
+            name,
+        };
+    }
+    return input;
+}
+function isUnauthenticatedError(error) {
+    return error instanceof TalizenHttpError && error.status === 401;
+}
+async function refreshAuthState(options) {
+    const requestId = authRequestId + 1;
+    authRequestId = requestId;
+    isAuthLoading = true;
+    authErrorState = null;
+    emitAuthChange();
+    try {
+        const user = await currentUser(options);
+        if (authRequestId === requestId) {
+            currentUserState = user;
+            authErrorState = null;
+            isAuthInitialized = true;
+            isAuthLoading = false;
+            emitAuthChange();
+        }
+        return user;
+    }
+    catch (error) {
+        if (authRequestId === requestId) {
+            currentUserState = null;
+            authErrorState = isUnauthenticatedError(error) ? null : error;
+            isAuthInitialized = true;
+            isAuthLoading = false;
+            emitAuthChange();
+        }
+        if (isUnauthenticatedError(error)) {
+            return null;
+        }
+        throw error;
+    }
+}
+function setAuthUser(user) {
+    authRequestId += 1;
+    currentUserState = user;
+    authErrorState = null;
+    isAuthInitialized = true;
+    isAuthLoading = false;
+    emitAuthChange();
 }
 /**
  * Subscribe to the current auth user.
@@ -28,63 +122,39 @@ function readAuthConfigSnapshot() {
  * config, which lets preview auth headers update the page without remounting.
  */
 export function useAuth(options) {
-    const configSnapshot = React.useSyncExternalStore(subscribeTalizenConfig, readAuthConfigSnapshot, readAuthConfigSnapshot);
+    const snapshot = React.useSyncExternalStore(subscribeAuth, () => authSnapshot, () => authSnapshot);
     const optionsRef = React.useRef(options);
-    const requestIdRef = React.useRef(0);
-    const [state, setState] = React.useState({
-        user: null,
-        loading: true,
-        error: null,
-    });
     React.useEffect(() => {
         optionsRef.current = options;
     }, [options]);
     const refresh = React.useCallback(async () => {
-        const requestId = requestIdRef.current + 1;
-        requestIdRef.current = requestId;
-        setState(current => ({ ...current, loading: true, error: null }));
-        try {
-            const nextUser = await currentUser(optionsRef.current);
-            if (requestIdRef.current === requestId) {
-                setState({ user: nextUser, loading: false, error: null });
-            }
-            return nextUser;
-        }
-        catch (error) {
-            if (requestIdRef.current === requestId) {
-                setState(current => ({ ...current, loading: false, error }));
-            }
-            throw error;
-        }
+        return refreshAuthState(optionsRef.current);
     }, []);
     React.useEffect(() => {
+        ensureAuthConfigSubscription();
         void refresh().catch(() => { });
-    }, [configSnapshot, refresh]);
-    const loginAndRefresh = React.useCallback(async (input) => {
-        const nextUser = await login(input, optionsRef.current);
-        requestIdRef.current += 1;
-        setState({ user: nextUser, loading: false, error: null });
+    }, [refresh]);
+    const loginAndRefresh = React.useCallback(async (input, password) => {
+        const nextUser = await loginRequest(normalizeLoginInput(input, password), optionsRef.current);
+        setAuthUser(nextUser);
         return nextUser;
     }, []);
-    const registerAndRefresh = React.useCallback(async (input) => {
-        const nextUser = await register(input, optionsRef.current);
-        requestIdRef.current += 1;
-        setState({ user: nextUser, loading: false, error: null });
+    const registerAndRefresh = React.useCallback(async (input, password, name) => {
+        const nextUser = await register(normalizeRegisterInput(input, password, name), optionsRef.current);
+        setAuthUser(nextUser);
         return nextUser;
     }, []);
     const logoutAndRefresh = React.useCallback(async () => {
-        await logout(optionsRef.current);
-        requestIdRef.current += 1;
-        setState({ user: null, loading: false, error: null });
+        await logoutRequest(optionsRef.current);
+        setAuthUser(null);
     }, []);
     const updateProfileAndRefresh = React.useCallback(async (profile) => {
         const nextUser = await updateProfile(profile, optionsRef.current);
-        requestIdRef.current += 1;
-        setState({ user: nextUser, loading: false, error: null });
+        setAuthUser(nextUser);
         return nextUser;
     }, []);
     return {
-        ...state,
+        ...snapshot,
         refresh,
         login: loginAndRefresh,
         register: registerAndRefresh,
@@ -92,7 +162,7 @@ export function useAuth(options) {
         updateProfile: updateProfileAndRefresh,
     };
 }
-export async function logout(options) {
+async function logoutRequest(options) {
     await requestJson("/auth/logout", {
         method: "POST",
         body: JSON.stringify({}),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "talizen",
-  "version": "0.2.14",
+  "version": "0.2.16",
   "description": "Talizen frontend SDK types for cms, form and core.",
   "type": "module",
   "license": "MIT",