@openfort/react-native 0.0.3 → 0.1.1

package/dist/hooks/auth/index.js

@@ -0,0 +1,14 @@
+/**
+ * Authentication hooks index
+ *
+ * This module re-exports all authentication-related hooks for convenient importing.
+ */
+// Email authentication
+export { useEmailAuth } from './useEmailAuth';
+// OAuth authentication
+export { useOAuth } from './useOAuth';
+// Wallet-based authentication (SIWE)
+export { useWalletAuth } from './useWalletAuth';
+// Guest accounts
+export { useGuestAuth } from './useGuestAuth';
+export { useSignOut } from './useSignOut';

package/dist/hooks/auth/useAuthCallback.js

@@ -0,0 +1 @@
+"use strict";

package/dist/hooks/auth/useCreateWalletPostAuth.js

@@ -0,0 +1,22 @@
+import { useCallback } from "react";
+// this hook is used to create a wallet after the user has authenticated
+export const useCreateWalletPostAuth = () => {
+    // This would connect to the wallet and set it as active
+    // eslint-disable-next-line no-empty-pattern
+    const tryUseWallet = useCallback(async ({}) => {
+        // if (!walletConfig || walletConfig.recoveryMethod !== RecoveryMethod.AUTOMATIC || !automaticRecovery) {
+        //   return {};
+        // }
+        // const wallet = await setActiveWallet({
+        //   connector: embeddedWalletId,
+        // });
+        // if (wallet.error && signOutOnError) {
+        //   // If there was an error and we should log out, we can call the logout function
+        //   await signOut();
+        // }
+        return { wallet: undefined };
+    }, [ /* walletConfig, setActiveWallet, signOut */]);
+    return {
+        tryUseWallet,
+    };
+};

package/dist/hooks/auth/useEmailAuth.js

@@ -0,0 +1,176 @@
+import { useCallback } from 'react';
+import { useOpenfortContext } from '../../core/context';
+import { onError, onSuccess } from '../../lib/hookConsistency';
+import { OpenfortError, OpenfortErrorType } from '../../types/openfortError';
+const mapStatus = (status) => {
+    return {
+        isLoading: status.status === 'submitting-code' || status.status === 'sending-verification-code',
+        isError: status.status === 'error',
+        isSuccess: status.status === 'done',
+        requiresEmailVerification: status.status === 'awaiting-code-input',
+        error: "error" in status ? status.error : null,
+    };
+};
+export const useEmailAuth = (hookOptions = {}) => {
+    const { client, setPasswordState, _internal, passwordState } = useOpenfortContext();
+    const signInEmail = useCallback(async (options) => {
+        try {
+            setPasswordState({ status: 'sending-verification-code' });
+            // Login with email and password
+            const result = await client.auth.logInWithEmailPassword({
+                email: options.email,
+                password: options.password,
+            });
+            // Check if action is required (email verification)
+            if ('action' in result) {
+                setPasswordState({
+                    status: 'awaiting-code-input',
+                });
+                // Return undefined as email verification is required
+                return onSuccess({
+                    hookOptions,
+                    options,
+                    data: { requiresEmailVerification: true },
+                });
+            }
+            else {
+                // Login successful
+                setPasswordState({ status: 'done' });
+                const user = result.player;
+                // Refresh user state in provider
+                await _internal.refreshUserState(user);
+                return onSuccess({
+                    hookOptions,
+                    options,
+                    data: { user },
+                });
+            }
+        }
+        catch (e) {
+            const error = new OpenfortError('Failed to login with email and password', OpenfortErrorType.AUTHENTICATION_ERROR, { error: e });
+            setPasswordState({
+                status: 'error',
+                error
+            });
+            return onError({
+                hookOptions,
+                options,
+                error
+            });
+        }
+    }, [client, setPasswordState, _internal, hookOptions]);
+    const signUpEmail = useCallback(async (options) => {
+        try {
+            setPasswordState({ status: 'sending-verification-code' });
+            // Sign up with email and password
+            const result = await client.auth.signUpWithEmailPassword({
+                email: options.email,
+                password: options.password,
+                ...(options.name && { name: options.name }),
+            });
+            // Check if action is required (email verification)
+            if ('action' in result) {
+                setPasswordState({
+                    status: 'awaiting-code-input',
+                });
+                // Return undefined as email verification is required
+                return onSuccess({
+                    hookOptions,
+                    options,
+                    data: { requiresEmailVerification: true },
+                });
+            }
+            else {
+                // Signup successful
+                setPasswordState({ status: 'done' });
+                const user = result.player;
+                // Refresh user state in provider
+                await _internal.refreshUserState(user);
+                return onSuccess({
+                    hookOptions,
+                    options,
+                    data: { user },
+                });
+            }
+        }
+        catch (e) {
+            const error = new OpenfortError('Failed to signup with email and password', OpenfortErrorType.AUTHENTICATION_ERROR, { error: e });
+            setPasswordState({
+                status: 'error',
+                error
+            });
+            return onError({
+                hookOptions,
+                options,
+                error
+            });
+        }
+    }, [client, setPasswordState, _internal, hookOptions]);
+    const linkEmail = useCallback(async (options) => {
+        try {
+            setPasswordState({ status: 'sending-verification-code' });
+            // Get current user access token
+            const accessToken = await client.getAccessToken();
+            if (!accessToken) {
+                throw new Error('User must be authenticated to link email');
+            }
+            // Link email account
+            const result = await client.auth.linkEmailPassword({
+                email: options.email,
+                password: options.password,
+                authToken: accessToken,
+            });
+            // Check if action is required (email verification)
+            if ('action' in result) {
+                setPasswordState({
+                    status: 'awaiting-code-input',
+                });
+                // Return undefined as email verification is required
+                return onSuccess({
+                    hookOptions,
+                    options,
+                    data: { requiresEmailVerification: true },
+                });
+            }
+            else {
+                // Link successful
+                setPasswordState({ status: 'done' });
+                // Refresh user state to reflect email linking
+                await _internal.refreshUserState();
+                return onSuccess({
+                    hookOptions,
+                    options,
+                    data: { user: result },
+                });
+            }
+        }
+        catch (e) {
+            const error = new OpenfortError('Failed to link email and password', OpenfortErrorType.AUTHENTICATION_ERROR, { error: e });
+            setPasswordState({
+                status: 'error',
+                error
+            });
+            return onError({
+                hookOptions,
+                options,
+                error
+            });
+        }
+    }, [client, setPasswordState, _internal, hookOptions]);
+    const verifyEmail = () => { }; // TODO
+    const resetPassword = () => { }; // TODO
+    const requestResetPassword = () => { }; // TODO
+    const reset = () => {
+        setPasswordState({ status: 'initial' });
+    };
+    return {
+        signInEmail,
+        signUpEmail,
+        verifyEmail,
+        linkEmail,
+        requestResetPassword,
+        resetPassword,
+        reset,
+        ...mapStatus(passwordState),
+    };
+};

package/dist/hooks/auth/useGuestAuth.js

@@ -0,0 +1,52 @@
+import { useCallback, useState } from 'react';
+import { useOpenfortContext } from '../../core/context';
+import { onError, onSuccess } from '../../lib/hookConsistency';
+import { mapStatus } from '../../types/baseFlowState';
+import { OpenfortError, OpenfortErrorType } from '../../types/openfortError';
+export const useGuestAuth = (hookOptions = {}) => {
+    const { client, _internal } = useOpenfortContext();
+    const { refreshUserState: updateUser } = _internal;
+    const [status, setStatus] = useState({
+        status: "idle",
+    });
+    // const { tryUseWallet } = useCreateWalletPostAuth();
+    const signUpGuest = useCallback(async (options = {}) => {
+        try {
+            setStatus({
+                status: 'loading',
+            });
+            const result = await client.auth.signUpGuest();
+            const user = result.player;
+            await updateUser(user);
+            // const { wallet } = await tryUseWallet({
+            //   logoutOnError: options.logoutOnError || hookOptions.logoutOnError,
+            //   automaticRecovery: options.automaticRecovery || hookOptions.automaticRecovery,
+            // });
+            setStatus({
+                status: 'success',
+            });
+            onSuccess({
+                hookOptions,
+                options,
+                data: { user },
+            });
+            return { user, /* wallet */ };
+        }
+        catch (error) {
+            const openfortError = new OpenfortError("Failed to signup guest", OpenfortErrorType.AUTHENTICATION_ERROR, { error });
+            setStatus({
+                status: 'error',
+                error: openfortError,
+            });
+            return onError({
+                hookOptions,
+                options,
+                error: openfortError,
+            });
+        }
+    }, [client, setStatus, updateUser, hookOptions]);
+    return {
+        signUpGuest,
+        ...mapStatus(status),
+    };
+};

package/dist/hooks/auth/useOAuth.js

@@ -0,0 +1,292 @@
+/**
+ * Hook for OAuth-based login functionality
+ */
+import { OAuthProvider } from '@openfort/openfort-js';
+import { useCallback } from 'react';
+import { useOpenfortContext } from '../../core/context';
+import { authenticateWithApple, createOAuthRedirectUri, isAppleSignInAvailable, OAuthUtils, openOAuthSession, parseOAuthUrl, } from '../../native';
+import { mapOAuthStatus } from "../../types/oauth";
+import { OpenfortError, OpenfortErrorType } from '../../types/openfortError';
+import { onError, onSuccess } from '../../lib/hookConsistency';
+/**
+ * Hook for OAuth-based authentication with supported providers
+ *
+ * This hook provides OAuth authentication flow for various providers (Google, Apple, Discord, etc.).
+ * It opens the provider's web authentication page and handles the OAuth flow automatically.
+ *
+ * @param opts - Configuration options including success/error callbacks
+ * @returns Object with login function and current OAuth flow state
+ *
+ * @example
+ * ```tsx
+ * const { login, state } = useLoginWithOAuth({
+ *   onSuccess: (user) => console.log('OAuth login successful:', user),
+ *   onError: (error) => console.error('OAuth login failed:', error),
+ * });
+ *
+ * // Login with Google
+ * const user = await login({ provider: 'google' });
+ *
+ * // Login with Apple (using legacy web flow on iOS if needed)
+ * const user = await login({
+ *   provider: 'apple',
+ *   isLegacyAppleIosBehaviorEnabled: true
+ * });
+ *
+ * // Other supported providers
+ * await login({ provider: 'discord' });
+ * await login({ provider: 'twitter' });
+ * ```
+ */
+export const useOAuth = (hookOptions = {}) => {
+    const { client, oAuthState, setOAuthState, _internal } = useOpenfortContext();
+    const initOAuth = useCallback(async (options) => {
+        try {
+            setOAuthState({ status: 'loading' });
+            // Initialize OAuth flow
+            const redirectUri = options.redirectTo || createOAuthRedirectUri('/oauth/callback');
+            const result = await client.auth.initOAuth({
+                provider: options.provider,
+                options: {
+                    skipBrowserRedirect: true,
+                    redirectTo: redirectUri,
+                }
+            });
+            // Handle OAuth flow using native utilities
+            setOAuthState({ status: 'awaiting-redirect' });
+            // Check if we should use native Apple authentication
+            if (options.provider === 'apple' && !options.isLegacyAppleIosBehaviorEnabled) {
+                const isAppleAvailable = await isAppleSignInAvailable();
+                if (isAppleAvailable) {
+                    try {
+                        const appleResult = await authenticateWithApple({
+                            state: result.key || '',
+                            isLogin: true,
+                        });
+                        // Complete OAuth flow with Apple credentials
+                        const authResult = await client.auth.loginWithIdToken({
+                            provider: OAuthProvider.APPLE,
+                            token: appleResult.identityToken,
+                        });
+                        setOAuthState({ status: 'done' });
+                        const user = authResult.player;
+                        // Refresh user state in provider
+                        await _internal.refreshUserState(user);
+                        return onSuccess({
+                            options,
+                            hookOptions,
+                            data: { user },
+                        });
+                    }
+                    catch (e) {
+                        const error = new OpenfortError('Apple authentication failed', OpenfortErrorType.AUTHENTICATION_ERROR, { error: e });
+                        setOAuthState({
+                            status: 'error',
+                            error,
+                        });
+                        return onError({
+                            options,
+                            hookOptions,
+                            error,
+                        });
+                    }
+                }
+            }
+            // For other providers, use web-based OAuth
+            const providerUrl = OAuthUtils.getProviderUrl(options.provider, result.url);
+            const oauthResult = await OAuthUtils.withTimeout(openOAuthSession({
+                url: providerUrl,
+                redirectUri,
+            }), 120000 // 2 minute timeout
+            );
+            if (oauthResult.type === 'success' && oauthResult.url) {
+                // Parse OAuth response from redirect URL
+                const { access_token, refresh_token, player_id, error, errorDescription } = parseOAuthUrl(oauthResult.url);
+                if (error) {
+                    throw new Error(errorDescription || error);
+                }
+                await client.auth.storeCredentials({
+                    player: player_id,
+                    accessToken: access_token,
+                    refreshToken: refresh_token,
+                });
+                setOAuthState({ status: 'done' });
+                const user = await client.user.get();
+                // Refresh user state in provider
+                await _internal.refreshUserState(user);
+                return onSuccess({
+                    options,
+                    hookOptions,
+                    data: { user },
+                });
+            }
+            else if (oauthResult.type === 'cancel') {
+                const error = new OpenfortError('OAuth authentication was cancelled by user', OpenfortErrorType.AUTHENTICATION_ERROR);
+                setOAuthState({
+                    status: 'error',
+                    error,
+                });
+                return onError({
+                    options,
+                    hookOptions,
+                    error,
+                });
+            }
+            else {
+                const error = new OpenfortError(oauthResult.error || 'OAuth authentication failed', OpenfortErrorType.AUTHENTICATION_ERROR);
+                setOAuthState({
+                    status: 'error',
+                    error,
+                });
+                return onError({
+                    options,
+                    hookOptions,
+                    error,
+                });
+            }
+        }
+        catch (e) {
+            const error = new OpenfortError('OAuth initialization failed', OpenfortErrorType.AUTHENTICATION_ERROR, { error: e });
+            setOAuthState({
+                status: 'error',
+                error
+            });
+            return onError({
+                options,
+                hookOptions,
+                error,
+            });
+        }
+    }, [client, setOAuthState, _internal]);
+    const linkOauth = useCallback(async (options) => {
+        try {
+            setOAuthState({ status: 'loading' });
+            // Get current user access token for linking
+            const accessToken = await client.getAccessToken();
+            if (!accessToken) {
+                throw new Error('User must be authenticated to link OAuth account');
+            }
+            // Initialize OAuth linking flow
+            const redirectUri = options.redirectTo || createOAuthRedirectUri('/oauth/callback');
+            const result = await client.auth.initLinkOAuth({
+                provider: options.provider,
+                authToken: accessToken,
+                options: {
+                    skipBrowserRedirect: true,
+                    redirectTo: redirectUri,
+                }
+            });
+            // Handle OAuth linking flow using native utilities
+            setOAuthState({ status: 'awaiting-redirect' });
+            // Check if we should use native Apple authentication for linking
+            if (options.provider === 'apple' && !options.isLegacyAppleIosBehaviorEnabled) {
+                const isAppleAvailable = await isAppleSignInAvailable();
+                if (isAppleAvailable) {
+                    try {
+                        const appleResult = await authenticateWithApple({
+                            state: result.key || '',
+                            isLogin: false, // This is a linking operation
+                        });
+                        // Complete OAuth linking flow with Apple credentials
+                        const linkResult = await client.auth.loginWithIdToken({
+                            provider: OAuthProvider.APPLE,
+                            token: appleResult.identityToken
+                        });
+                        setOAuthState({ status: 'done' });
+                        const user = linkResult.player;
+                        // Refresh user state to reflect OAuth linking
+                        await _internal.refreshUserState();
+                        return onSuccess({
+                            options,
+                            hookOptions,
+                            data: { user },
+                        });
+                    }
+                    catch (e) {
+                        const error = new OpenfortError('Apple linking failed', OpenfortErrorType.AUTHENTICATION_ERROR, { error: e });
+                        setOAuthState({
+                            status: 'error',
+                            error,
+                        });
+                        return onError({
+                            options,
+                            hookOptions,
+                            error,
+                        });
+                    }
+                }
+            }
+            // For other providers, use web-based OAuth
+            const providerUrl = OAuthUtils.getProviderUrl(options.provider, result.url);
+            const oauthResult = await OAuthUtils.withTimeout(openOAuthSession({
+                url: providerUrl,
+                redirectUri,
+            }), 120000 // 2 minute timeout
+            );
+            if (oauthResult.type === 'success' && oauthResult.url) {
+                // Parse OAuth response from redirect URL
+                const { access_token, refresh_token, player_id, error, errorDescription } = parseOAuthUrl(oauthResult.url);
+                if (error) {
+                    throw new Error(errorDescription || error);
+                }
+                await client.auth.storeCredentials({
+                    player: player_id,
+                    accessToken: access_token,
+                    refreshToken: refresh_token,
+                });
+                setOAuthState({ status: 'done' });
+                const user = await client.user.get();
+                // Refresh user state in provider
+                await _internal.refreshUserState(user);
+                return onSuccess({
+                    options,
+                    hookOptions,
+                    data: { user },
+                });
+            }
+            else if (oauthResult.type === 'cancel') {
+                const error = new OpenfortError('OAuth linking was cancelled by user', OpenfortErrorType.AUTHENTICATION_ERROR);
+                setOAuthState({
+                    status: 'error',
+                    error,
+                });
+                return onError({
+                    options,
+                    hookOptions,
+                    error,
+                });
+            }
+            else {
+                const error = new OpenfortError(oauthResult.error || 'OAuth linking failed', OpenfortErrorType.AUTHENTICATION_ERROR);
+                setOAuthState({
+                    status: 'error',
+                    error,
+                });
+                return onError({
+                    options,
+                    hookOptions,
+                    error,
+                });
+            }
+        }
+        catch (e) {
+            const error = new OpenfortError('OAuth linking failed', OpenfortErrorType.AUTHENTICATION_ERROR, { error: e });
+            setOAuthState({
+                status: 'error',
+                error
+            });
+            return onError({
+                options,
+                hookOptions,
+                error
+            });
+        }
+    }, [client, setOAuthState, _internal]);
+    const storeCredentials = () => { }; // TODO
+    return {
+        initOAuth,
+        linkOauth,
+        storeCredentials,
+        ...mapOAuthStatus(oAuthState),
+    };
+};

package/dist/hooks/auth/useSignOut.js

@@ -0,0 +1,48 @@
+import { useCallback, useState } from "react";
+import { useOpenfortContext } from "../../core";
+import { onError, onSuccess } from "../../lib/hookConsistency";
+import { mapStatus } from "../../types/baseFlowState";
+import { OpenfortError, OpenfortErrorType } from "../../types/openfortError";
+import { useOpenfortClient } from "../core";
+export function useSignOut(hookOptions = {}) {
+    const client = useOpenfortClient();
+    const { _internal, user } = useOpenfortContext();
+    const [status, setStatus] = useState({
+        status: "idle",
+    });
+    const signOut = useCallback(async (options = {}) => {
+        if (!user)
+            return;
+        setStatus({
+            status: 'loading',
+        });
+        try {
+            await client.auth.logout();
+            _internal.refreshUserState();
+            setStatus({
+                status: 'success',
+            });
+            return onSuccess({
+                hookOptions,
+                options,
+                data: {},
+            });
+        }
+        catch (e) {
+            const error = new OpenfortError('Failed to sign out', OpenfortErrorType.AUTHENTICATION_ERROR, { error: e });
+            setStatus({
+                status: 'error',
+                error,
+            });
+            return onError({
+                hookOptions,
+                options,
+                error,
+            });
+        }
+    }, [client, user, _internal.refreshUserState, setStatus, hookOptions]);
+    return {
+        ...mapStatus(status),
+        signOut,
+    };
+}