@revealui/auth 0.0.0-canary-20260409021642

package/dist/react/usePasskey.js

@@ -0,0 +1,203 @@
+/**
+ * Passkey Hooks
+ *
+ * React hooks for WebAuthn passkey registration and authentication.
+ * Uses dynamic imports for @simplewebauthn/browser to avoid SSR issues.
+ */
+'use client';
+import { useEffect, useState } from 'react';
+/**
+ * Hook for passkey registration (sign-up and security settings).
+ *
+ * @returns Register function, loading state, error, and browser support flag
+ *
+ * @example
+ * ```tsx
+ * function AddPasskey() {
+ *   const { register, isLoading, error, supported } = usePasskeyRegister();
+ *
+ *   if (!supported) return <p>Passkeys are not supported in this browser.</p>;
+ *
+ *   const handleAdd = async () => {
+ *     const result = await register({ deviceName: 'My Laptop' });
+ *     if (result) {
+ *       // Passkey registered successfully
+ *     }
+ *   };
+ * }
+ * ```
+ */
+export function usePasskeyRegister() {
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const [supported, setSupported] = useState(false);
+    useEffect(() => {
+        setSupported(!!window.PublicKeyCredential);
+    }, []);
+    const register = async (options) => {
+        if (!supported) {
+            setError('Passkeys are not supported in this browser');
+            return null;
+        }
+        try {
+            setIsLoading(true);
+            setError(null);
+            // Step 1: Get registration options from the server
+            const optionsResponse = await fetch('/api/auth/passkey/register-options', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                credentials: 'include',
+                body: JSON.stringify({
+                    email: options?.email,
+                    name: options?.name,
+                }),
+            });
+            const optionsJson = await optionsResponse.json();
+            if (!optionsResponse.ok) {
+                const errorData = optionsJson;
+                setError(errorData.error ?? 'Failed to get registration options');
+                return null;
+            }
+            // Step 2: Start browser WebAuthn registration ceremony
+            // Server wraps options: { options: { challenge, ... } }
+            // @simplewebauthn/browser v13+ expects { optionsJSON: ... }
+            const { startRegistration } = await import('@simplewebauthn/browser');
+            const optionsData = optionsJson;
+            const attestationResponse = await startRegistration({ optionsJSON: optionsData.options });
+            // Step 3: Verify with the server
+            const verifyResponse = await fetch('/api/auth/passkey/register-verify', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                credentials: 'include',
+                body: JSON.stringify({
+                    attestationResponse,
+                    deviceName: options?.deviceName,
+                }),
+            });
+            const verifyJson = await verifyResponse.json();
+            if (!verifyResponse.ok) {
+                const errorData = verifyJson;
+                setError(errorData.error ?? 'Failed to verify passkey registration');
+                return null;
+            }
+            const result = verifyJson;
+            return result;
+        }
+        catch (err) {
+            // Handle user cancellation of the WebAuthn ceremony
+            if (err instanceof DOMException && err.name === 'NotAllowedError') {
+                setError('Passkey registration was cancelled');
+                return null;
+            }
+            const message = err instanceof Error ? err.message : String(err);
+            setError(message);
+            return null;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    };
+    return {
+        register,
+        isLoading,
+        error,
+        supported,
+    };
+}
+/**
+ * Hook for passkey authentication (login page).
+ *
+ * @returns Sign-in function, loading state, error, and browser support flag
+ *
+ * @example
+ * ```tsx
+ * function LoginPage() {
+ *   const { signIn, isLoading, error, supported } = usePasskeySignIn();
+ *
+ *   const handlePasskeyLogin = async () => {
+ *     const success = await signIn();
+ *     if (success) {
+ *       router.push('/admin');
+ *     }
+ *   };
+ *
+ *   return (
+ *     <>
+ *       {supported && (
+ *         <button onClick={handlePasskeyLogin} disabled={isLoading}>
+ *           Sign in with Passkey
+ *         </button>
+ *       )}
+ *       {error && <p>{error}</p>}
+ *     </>
+ *   );
+ * }
+ * ```
+ */
+export function usePasskeySignIn() {
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const [supported, setSupported] = useState(false);
+    useEffect(() => {
+        setSupported(!!window.PublicKeyCredential);
+    }, []);
+    const signIn = async () => {
+        if (!supported) {
+            setError('Passkeys are not supported in this browser');
+            return false;
+        }
+        try {
+            setIsLoading(true);
+            setError(null);
+            // Step 1: Get authentication options from the server
+            const optionsResponse = await fetch('/api/auth/passkey/authenticate-options', {
+                method: 'POST',
+                credentials: 'include',
+            });
+            const optionsJson = await optionsResponse.json();
+            if (!optionsResponse.ok) {
+                const errorData = optionsJson;
+                setError(errorData.error ?? 'Failed to get authentication options');
+                return false;
+            }
+            // Step 2: Start browser WebAuthn authentication ceremony
+            // @simplewebauthn/browser v13+ expects { optionsJSON: ... }
+            const { startAuthentication } = await import('@simplewebauthn/browser');
+            const authOptionsData = optionsJson;
+            const assertionResponse = await startAuthentication({ optionsJSON: authOptionsData.options });
+            // Step 3: Verify with the server
+            const verifyResponse = await fetch('/api/auth/passkey/authenticate-verify', {
+                method: 'POST',
+                headers: { 'Content-Type': 'application/json' },
+                credentials: 'include',
+                body: JSON.stringify({ authenticationResponse: assertionResponse }),
+            });
+            const verifyJson = await verifyResponse.json();
+            if (!verifyResponse.ok) {
+                const errorData = verifyJson;
+                setError(errorData.error ?? 'Passkey authentication failed');
+                return false;
+            }
+            return true;
+        }
+        catch (err) {
+            // Handle user cancellation of the WebAuthn ceremony
+            if (err instanceof DOMException && err.name === 'NotAllowedError') {
+                setError('Passkey authentication was cancelled');
+                return false;
+            }
+            const message = err instanceof Error ? err.message : String(err);
+            setError(message);
+            return false;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    };
+    return {
+        signIn,
+        isLoading,
+        error,
+        supported,
+    };
+}

package/dist/react/useSession.d.ts

@@ -0,0 +1,32 @@
+/**
+ * useSession Hook
+ *
+ * React hook for accessing the current session.
+ * Inspired by Better Auth and TanStack Start patterns.
+ */
+import type { AuthSession } from '../types.js';
+export interface UseSessionResult {
+    data: AuthSession | null;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+}
+/**
+ * Hook to get the current session
+ *
+ * @returns Session data, loading state, error, and refetch function
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { data: session, isLoading } = useSession()
+ *
+ *   if (isLoading) return <div>Loading...</div>
+ *   if (!session) return <div>Not signed in</div>
+ *
+ *   return <div>Hello, {session.user.name}</div>
+ * }
+ * ```
+ */
+export declare function useSession(): UseSessionResult;
+//# sourceMappingURL=useSession.d.ts.map

package/dist/react/useSession.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSession.d.ts","sourceRoot":"","sources":["../../src/react/useSession.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAMH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAiC/C,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,WAAW,GAAG,IAAI,CAAC;IACzB,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;IACpB,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9B;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,UAAU,IAAI,gBAAgB,CA2D7C"}

package/dist/react/useSession.js

@@ -0,0 +1,109 @@
+/**
+ * useSession Hook
+ *
+ * React hook for accessing the current session.
+ * Inspired by Better Auth and TanStack Start patterns.
+ */
+'use client';
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { z } from 'zod/v4';
+// Zod validates the required fields; .passthrough() preserves the rest.
+// The API returns JSON-serialized session/user objects (Dates as ISO strings).
+// z.infer output has an index signature incompatible with the concrete
+// AuthSession interface, so we convert via the helper below.
+const AuthSessionSchema = z.object({
+    session: z
+        .object({
+        id: z.string(),
+        expiresAt: z.string(),
+    })
+        .passthrough(),
+    user: z
+        .object({
+        id: z.string(),
+        email: z.string(),
+        name: z.string().nullable().optional(),
+    })
+        .passthrough(),
+});
+/**
+ * Narrow Zod-validated API response data to AuthSession.
+ *
+ * The cast is safe because: (1) Zod verified the required fields on both
+ * session and user, (2) .passthrough() preserves all other properties, and
+ * (3) the API serializes full Session + User rows (Dates become ISO strings).
+ */
+function toAuthSession(validated) {
+    return validated;
+}
+/**
+ * Hook to get the current session
+ *
+ * @returns Session data, loading state, error, and refetch function
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   const { data: session, isLoading } = useSession()
+ *
+ *   if (isLoading) return <div>Loading...</div>
+ *   if (!session) return <div>Not signed in</div>
+ *
+ *   return <div>Hello, {session.user.name}</div>
+ * }
+ * ```
+ */
+export function useSession() {
+    const [data, setData] = useState(null);
+    const [isLoading, setIsLoading] = useState(true);
+    const [error, setError] = useState(null);
+    const abortControllerRef = useRef(null);
+    const fetchSession = useCallback(async () => {
+        // Abort any in-flight request
+        abortControllerRef.current?.abort();
+        const controller = new AbortController();
+        abortControllerRef.current = controller;
+        try {
+            setIsLoading(true);
+            setError(null);
+            const response = await fetch('/api/auth/session', {
+                credentials: 'include',
+                signal: controller.signal,
+            });
+            if (!response.ok) {
+                if (response.status === 401) {
+                    setData(null);
+                    return;
+                }
+                throw new Error(`Failed to fetch session: ${response.statusText}`);
+            }
+            const json = await response.json();
+            const validated = AuthSessionSchema.parse(json);
+            setData(toAuthSession(validated));
+        }
+        catch (err) {
+            if (err instanceof DOMException && err.name === 'AbortError') {
+                return;
+            }
+            const error = err instanceof Error ? err : new Error(String(err));
+            setError(error);
+            setData(null);
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, []);
+    useEffect(() => {
+        void fetchSession();
+        return () => {
+            // Clean up: abort in-flight request on unmount
+            abortControllerRef.current?.abort();
+        };
+    }, [fetchSession]);
+    return {
+        data,
+        isLoading,
+        error,
+        refetch: fetchSession,
+    };
+}

package/dist/react/useSignIn.d.ts

@@ -0,0 +1,47 @@
+/**
+ * useSignIn Hook
+ *
+ * React hook for signing in a user.
+ */
+import type { User } from '../types.js';
+export interface SignInInput {
+    email: string;
+    password: string;
+}
+export interface UseSignInResult {
+    signIn: (input: SignInInput) => Promise<{
+        success: true;
+        user: User;
+    } | {
+        success: false;
+        error: string;
+    } | {
+        success: false;
+        requiresMfa: true;
+        mfaUserId: string;
+    }>;
+    isLoading: boolean;
+    error: Error | null;
+}
+/**
+ * Hook to sign in a user
+ *
+ * @returns Sign in function, loading state, and error
+ *
+ * @example
+ * ```tsx
+ * function SignInForm() {
+ *   const { signIn, isLoading } = useSignIn()
+ *
+ *   const handleSubmit = async (e: FormEvent) => {
+ *     e.preventDefault()
+ *     const result = await signIn({ email, password })
+ *     if (result.success) {
+ *       router.push('/dashboard')
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export declare function useSignIn(): UseSignInResult;
+//# sourceMappingURL=useSignIn.d.ts.map

package/dist/react/useSignIn.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSignIn.d.ts","sourceRoot":"","sources":["../../src/react/useSignIn.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAkCxC,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,CACN,KAAK,EAAE,WAAW,KACf,OAAO,CACR;QAAE,OAAO,EAAE,IAAI,CAAC;QAAC,IAAI,EAAE,IAAI,CAAA;KAAE,GAC7B;QAAE,OAAO,EAAE,KAAK,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAE,GACjC;QAAE,OAAO,EAAE,KAAK,CAAC;QAAC,WAAW,EAAE,IAAI,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAC3D,CAAC;IACF,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,SAAS,IAAI,eAAe,CAsE3C"}

package/dist/react/useSignIn.js

@@ -0,0 +1,121 @@
+/**
+ * useSignIn Hook
+ *
+ * React hook for signing in a user.
+ */
+'use client';
+import { useCallback, useRef, useState } from 'react';
+import { z } from 'zod/v4';
+// Zod validates the required fields; .passthrough() preserves the rest.
+// The API returns JSON-serialized User objects (Dates as ISO strings).
+// z.infer output has an index signature incompatible with the concrete User
+// interface, so we extract the validated user via the helper below.
+const SignInUserSchema = z
+    .object({
+    id: z.string(),
+    email: z.string(),
+    name: z.string().nullable().optional(),
+})
+    .passthrough();
+/**
+ * Narrow Zod-validated API response data to User.
+ *
+ * The cast is safe because: (1) Zod verified the required fields (id, email),
+ * (2) .passthrough() preserves all other properties from the API response,
+ * and (3) the API serializes a full User row (Dates become ISO strings in JSON).
+ */
+function toUser(validated) {
+    return validated;
+}
+// Validation schemas for sign-in response
+const SignInErrorResponseSchema = z.object({
+    error: z.string().optional(),
+});
+const SignInSuccessResponseSchema = z.object({
+    user: SignInUserSchema,
+});
+/**
+ * Hook to sign in a user
+ *
+ * @returns Sign in function, loading state, and error
+ *
+ * @example
+ * ```tsx
+ * function SignInForm() {
+ *   const { signIn, isLoading } = useSignIn()
+ *
+ *   const handleSubmit = async (e: FormEvent) => {
+ *     e.preventDefault()
+ *     const result = await signIn({ email, password })
+ *     if (result.success) {
+ *       router.push('/dashboard')
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export function useSignIn() {
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const abortControllerRef = useRef(null);
+    const signIn = useCallback(async (input) => {
+        // Abort any in-flight request
+        abortControllerRef.current?.abort();
+        const controller = new AbortController();
+        abortControllerRef.current = controller;
+        try {
+            setIsLoading(true);
+            setError(null);
+            const response = await fetch('/api/auth/sign-in', {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                credentials: 'include',
+                body: JSON.stringify(input),
+                signal: controller.signal,
+            });
+            const json = await response.json();
+            if (!response.ok) {
+                const errorData = SignInErrorResponseSchema.parse(json);
+                return {
+                    success: false,
+                    error: errorData.error || 'Failed to sign in',
+                };
+            }
+            // Check for MFA challenge before parsing as full success
+            const jsonObj = json;
+            if (jsonObj.requiresMfa === true && typeof jsonObj.mfaUserId === 'string') {
+                return {
+                    success: false,
+                    requiresMfa: true,
+                    mfaUserId: jsonObj.mfaUserId,
+                };
+            }
+            const successData = SignInSuccessResponseSchema.parse(json);
+            return {
+                success: true,
+                user: toUser(successData.user),
+            };
+        }
+        catch (err) {
+            if (err instanceof DOMException && err.name === 'AbortError') {
+                return { success: false, error: 'Request was cancelled' };
+            }
+            const error = err instanceof Error ? err : new Error(String(err));
+            setError(error);
+            return {
+                success: false,
+                error: error.message,
+            };
+        }
+        finally {
+            setIsLoading(false);
+        }
+    }, []);
+    return {
+        signIn,
+        isLoading,
+        error,
+    };
+}

package/dist/react/useSignOut.d.ts

@@ -0,0 +1,30 @@
+/**
+ * useSignOut Hook
+ *
+ * React hook for signing out a user.
+ */
+export interface UseSignOutResult {
+    signOut: () => Promise<void>;
+    isLoading: boolean;
+    error: Error | null;
+}
+/**
+ * Hook to sign out a user
+ *
+ * @returns Sign out function, loading state, and error
+ *
+ * @example
+ * ```tsx
+ * function SignOutButton() {
+ *   const { signOut, isLoading } = useSignOut()
+ *
+ *   return (
+ *     <button onClick={signOut} disabled={isLoading}>
+ *       {isLoading ? 'Signing out...' : 'Sign Out'}
+ *     </button>
+ *   )
+ * }
+ * ```
+ */
+export declare function useSignOut(): UseSignOutResult;
+//# sourceMappingURL=useSignOut.d.ts.map

package/dist/react/useSignOut.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSignOut.d.ts","sourceRoot":"","sources":["../../src/react/useSignOut.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;IAC7B,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,UAAU,IAAI,gBAAgB,CAkC7C"}

package/dist/react/useSignOut.js

@@ -0,0 +1,57 @@
+/**
+ * useSignOut Hook
+ *
+ * React hook for signing out a user.
+ */
+'use client';
+import { useState } from 'react';
+/**
+ * Hook to sign out a user
+ *
+ * @returns Sign out function, loading state, and error
+ *
+ * @example
+ * ```tsx
+ * function SignOutButton() {
+ *   const { signOut, isLoading } = useSignOut()
+ *
+ *   return (
+ *     <button onClick={signOut} disabled={isLoading}>
+ *       {isLoading ? 'Signing out...' : 'Sign Out'}
+ *     </button>
+ *   )
+ * }
+ * ```
+ */
+export function useSignOut() {
+    const [isLoading, setIsLoading] = useState(false);
+    const [error, setError] = useState(null);
+    const signOut = async () => {
+        try {
+            setIsLoading(true);
+            setError(null);
+            const response = await fetch('/api/auth/sign-out', {
+                method: 'POST',
+                credentials: 'include',
+            });
+            if (!response.ok) {
+                throw new Error('Failed to sign out');
+            }
+            // Clear session on client side
+            window.location.href = '/login';
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            setError(error);
+            throw error;
+        }
+        finally {
+            setIsLoading(false);
+        }
+    };
+    return {
+        signOut,
+        isLoading,
+        error,
+    };
+}

package/dist/react/useSignUp.d.ts

@@ -0,0 +1,43 @@
+/**
+ * useSignUp Hook
+ *
+ * React hook for signing up a new user.
+ */
+import type { User } from '../types.js';
+export interface SignUpInput {
+    email: string;
+    password: string;
+    name: string;
+    tosAccepted: true;
+}
+export interface UseSignUpResult {
+    signUp: (input: SignUpInput) => Promise<{
+        success: boolean;
+        user?: User;
+        error?: string;
+    }>;
+    isLoading: boolean;
+    error: Error | null;
+}
+/**
+ * Hook to sign up a new user
+ *
+ * @returns Sign up function, loading state, and error
+ *
+ * @example
+ * ```tsx
+ * function SignUpForm() {
+ *   const { signUp, isLoading } = useSignUp()
+ *
+ *   const handleSubmit = async (e: FormEvent) => {
+ *     e.preventDefault()
+ *     const result = await signUp({ email, password, name })
+ *     if (result.success) {
+ *       router.push('/dashboard')
+ *     }
+ *   }
+ * }
+ * ```
+ */
+export declare function useSignUp(): UseSignUpResult;
+//# sourceMappingURL=useSignUp.d.ts.map

package/dist/react/useSignUp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useSignUp.d.ts","sourceRoot":"","sources":["../../src/react/useSignUp.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAmCxC,MAAM,WAAW,WAAW;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,EAAE,IAAI,CAAC;CACnB;AAED,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,OAAO,CAAC;QAAE,OAAO,EAAE,OAAO,CAAC;QAAC,IAAI,CAAC,EAAE,IAAI,CAAC;QAAC,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAC3F,SAAS,EAAE,OAAO,CAAC;IACnB,KAAK,EAAE,KAAK,GAAG,IAAI,CAAC;CACrB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,SAAS,IAAI,eAAe,CAoD3C"}