rn-swiftauth-sdk 1.0.2 → 1.0.4

package/src/components/LoginForm.tsx

@@ -6,7 +6,8 @@ import {
   TouchableOpacity,
   StyleSheet,
   ActivityIndicator,
-  Platform
+  Platform,
+  Alert
 } from 'react-native';
 import { useAuth } from '../hooks/useAuth';
 import { AuthScreenStyles } from '../types';
@@ -22,24 +23,49 @@ export const LoginForm = ({ styles: userStyles }: LoginFormProps) => {
     signInWithEmail,
     signInWithGoogle,
     signInWithApple,
+    sendPasswordReset,
     isLoading,
     error,
-    config
+    config,
+    clearError
   } = useAuth();
 
   const [email, setEmail] = useState('');
   const [password, setPassword] = useState('');
+  const [isResetMode, setIsResetMode] = useState(false); // ✅ 2. Mode Toggle State
   
   const [validationErrors, setValidationErrors] = useState<{ email?: string; password?: string }>({});
 
-  //Check if form is filled to enable button
-  const isFormFilled = email.length > 0 && password.length > 0;
+  // ✅ 3. Dynamic check: If resetting, we only need Email. If logging in, we need both.
+  const isFormFilled = isResetMode 
+    ? email.length > 0 
+    : (email.length > 0 && password.length > 0);
 
-  const handleLogin = async () => {
-    // 1. Reset previous errors
+  // ✅ 4. New Handler for Password Reset
+  const handleResetPassword = async () => {
     setValidationErrors({});
+    const emailErr = validateEmail(email);
+    if (emailErr) {
+      setValidationErrors({ email: emailErr });
+      return;
+    }
+
+    try {
+      await sendPasswordReset(email);
+      Alert.alert(
+        "Check your email", 
+        "If an account exists with this email, a password reset link has been sent."
+      );
+      setIsResetMode(false); // Go back to login screen
+    } catch (e) {
+      console.log('Reset failed:', e);
+    }
+  };
 
-    // 2. Validate Inputs
+  const handleLogin = async () => {
+    setValidationErrors({});
+    
+    // Validate Inputs
     const emailErr = validateEmail(email);
     const passErr = validatePasswordLogin(password);
 
@@ -48,16 +74,12 @@ export const LoginForm = ({ styles: userStyles }: LoginFormProps) => {
         email: emailErr || undefined,
         password: passErr || undefined
       });
-      return; //Stop if invalid
+      return;
     }
 
-    // 3. Attempt Login
     try {
-      //UPDATED: Clean Object Syntax
       await signInWithEmail({ email, password });
     } catch (e) { 
-      // Auth errors handled by global state
-      // DX: Log it for the developer (Optional but helpful for debugging)
       console.log('Login failed:', e);
     }
   };
@@ -78,16 +100,30 @@ export const LoginForm = ({ styles: userStyles }: LoginFormProps) => {
     }
   };
 
+
+  const toggleResetMode = () => {
+    setIsResetMode(!isResetMode);
+    clearError();
+    setValidationErrors({});
+
+    setPassword('');
+  };
+
   return (
     <View style={[defaultStyles.container, userStyles?.container]}>
-      {/* Global API Error */}
+
       {error && (
         <Text style={[defaultStyles.errorText, userStyles?.errorText]}>
           {error.message}
         </Text>
       )}
 
-      {/* Email Input */}
+
+      {isResetMode && (
+        <Text style={defaultStyles.modeTitle}>Reset Password</Text>
+      )}
+
+
       <TextInput
         style={[
           defaultStyles.input, 
@@ -109,44 +145,69 @@ export const LoginForm = ({ styles: userStyles }: LoginFormProps) => {
         <Text style={defaultStyles.validationText}>{validationErrors.email}</Text>
       )}
 
-      {/* Password Input */}
-      <PasswordInput
-        styles={userStyles}
-        placeholder="Password"
-        value={password}
-        onChangeText={(text) => {
-          setPassword(text);
-          if (validationErrors.password) setValidationErrors({...validationErrors, password: undefined});
-        }}
-        editable={!isLoading}
-      />
-      {validationErrors.password && (
-        <Text style={defaultStyles.validationText}>{validationErrors.password}</Text>
+
+      {!isResetMode && (
+        <>
+          <PasswordInput
+            styles={userStyles}
+            placeholder="Password"
+            value={password}
+            onChangeText={(text) => {
+              setPassword(text);
+              if (validationErrors.password) setValidationErrors({...validationErrors, password: undefined});
+            }}
+            editable={!isLoading}
+          />
+          {validationErrors.password && (
+            <Text style={defaultStyles.validationText}>{validationErrors.password}</Text>
+          )}
+
+
+          <TouchableOpacity 
+            style={defaultStyles.forgotPasswordContainer} 
+            onPress={toggleResetMode}
+            disabled={isLoading}
+          >
+            <Text style={[defaultStyles.forgotPasswordText, userStyles?.linkText]}>
+              Forgot Password?
+            </Text>
+          </TouchableOpacity>
+        </>
       )}
 
-      {/* Sign In Button */}
+
       <TouchableOpacity
         style={[
           defaultStyles.button,
-          // Disable style if loading OR form is incomplete
           (isLoading || !isFormFilled) && defaultStyles.buttonDisabled,
           userStyles?.button
         ]}
-        onPress={handleLogin}
-        // Disable interaction if loading OR form is incomplete
+
+        onPress={isResetMode ? handleResetPassword : handleLogin}
         disabled={isLoading || !isFormFilled}
       >
         {isLoading ? (
           <ActivityIndicator color={userStyles?.loadingIndicatorColor || "#fff"} />
         ) : (
           <Text style={[defaultStyles.buttonText, userStyles?.buttonText]}>
-            Sign In
+            {isResetMode ? "Send Reset Link" : "Sign In"}
           </Text>
         )}
       </TouchableOpacity>
 
-      {/* OAuth Section */}
-      {(config.enableGoogle || config.enableApple) && !isLoading && (
+
+      {isResetMode && (
+        <TouchableOpacity 
+          style={defaultStyles.cancelButton} 
+          onPress={toggleResetMode}
+          disabled={isLoading}
+        >
+          <Text style={defaultStyles.cancelButtonText}>Back to Sign In</Text>
+        </TouchableOpacity>
+      )}
+
+
+      {!isResetMode && (config.enableGoogle || config.enableApple) && !isLoading && (
         <>
           <View style={defaultStyles.dividerContainer}>
             <View style={defaultStyles.divider} />
@@ -157,30 +218,20 @@ export const LoginForm = ({ styles: userStyles }: LoginFormProps) => {
           {/* Google Button */}
           {config.enableGoogle && (
             <TouchableOpacity
-              style={[
-                defaultStyles.oauthButton,
-                defaultStyles.googleButton,
-              ]}
+              style={[defaultStyles.oauthButton, defaultStyles.googleButton]}
               onPress={handleGoogleSignIn}
             >
-              <Text style={defaultStyles.googleButtonText}>
-                Continue with Google
-              </Text>
+              <Text style={defaultStyles.googleButtonText}>Continue with Google</Text>
             </TouchableOpacity>
           )}
 
           {/* Apple Button (iOS Only) */}
           {config.enableApple && Platform.OS === 'ios' && (
             <TouchableOpacity
-              style={[
-                defaultStyles.oauthButton,
-                defaultStyles.appleButton,
-              ]}
+              style={[defaultStyles.oauthButton, defaultStyles.appleButton]}
               onPress={handleAppleSignIn}
             >
-              <Text style={defaultStyles.appleButtonText}>
-                Continue with Apple
-              </Text>
+              <Text style={defaultStyles.appleButtonText}>Continue with Apple</Text>
             </TouchableOpacity>
           )}
         </>
@@ -252,4 +303,33 @@ const defaultStyles = StyleSheet.create({
     fontSize: 16,
     fontWeight: '600',
   },
+
+
+  forgotPasswordContainer: {
+    alignSelf: 'flex-end',
+    marginBottom: 12,
+    padding: 4,
+  },
+  forgotPasswordText: {
+    color: '#007AFF',
+    fontSize: 14,
+    fontWeight: '500',
+  },
+  modeTitle: {
+    fontSize: 18,
+    fontWeight: 'bold',
+    marginBottom: 16,
+    color: '#333',
+    textAlign: 'center',
+  },
+  cancelButton: {
+    marginTop: 16,
+    alignItems: 'center',
+    padding: 8,
+  },
+  cancelButtonText: {
+    color: '#666',
+    fontSize: 14,
+    fontWeight: '500',
+  },
 });

package/src/core/AuthProvider.tsx

@@ -2,22 +2,30 @@ import React, { useEffect, useState, ReactNode, useMemo } from 'react';
 import { Platform } from 'react-native';
 import { initializeApp, getApps, getApp, FirebaseApp } from 'firebase/app';
 import * as FirebaseAuth from 'firebase/auth';
+
+import { sendPasswordResetEmail } from 'firebase/auth'; 
 import ReactNativeAsyncStorage from '@react-native-async-storage/async-storage';
 import { GoogleSignin } from '@react-native-google-signin/google-signin';
 import * as AppleAuthentication from 'expo-apple-authentication';
 import * as Crypto from 'expo-crypto';
-import { mapFirebaseError } from '../errors';
+import {
+  AuthException,
+  mapFirebaseError,
+  ConfigurationException,
+  AppleSignInNotSupportedException,
+  AppleSignInCancelledException,
+  GoogleSignInCancelledException,
+} from '../errors';
 import { AuthContext } from './AuthContext';
-import { 
-  AuthConfig, 
-  AuthStatus, 
-  User, 
-  AuthError, 
-  AuthErrorCode, 
-  ProviderErrorCodes, 
+import {
+  AuthConfig,
+  AuthStatus,
+  User,
+  ProviderErrorCodes,
   EmailSignInOptions,
-  EmailSignUpOptions 
+  EmailSignUpOptions
 } from '../types';
+
 const getReactNativePersistence = (FirebaseAuth as any).getReactNativePersistence;
 
 interface AuthProviderProps {
@@ -28,7 +36,7 @@ interface AuthProviderProps {
 export const AuthProvider: React.FC<AuthProviderProps> = ({ config, children }) => {
   const [user, setUser] = useState<User | null>(null);
   const [status, setStatus] = useState<AuthStatus>(AuthStatus.LOADING);
-  const [error, setError] = useState<AuthError | null>(null);
+  const [error, setError] = useState<AuthException | null>(null);
   const [firebaseAuthInstance, setFirebaseAuthInstance] = useState<FirebaseAuth.Auth | null>(null);
   const [isDataLoading, setIsDataLoading] = useState(true);
 
@@ -47,8 +55,8 @@ export const AuthProvider: React.FC<AuthProviderProps> = ({ config, children })
         appId: config.appId,
       });
 
-      const selectedPersistence = config.persistence === 'memory' 
-        ? FirebaseAuth.inMemoryPersistence 
+      const selectedPersistence = config.persistence === 'memory'
+        ? FirebaseAuth.inMemoryPersistence
         : getReactNativePersistence(ReactNativeAsyncStorage);
 
       auth = FirebaseAuth.initializeAuth(app, {
@@ -66,7 +74,7 @@ export const AuthProvider: React.FC<AuthProviderProps> = ({ config, children })
         GoogleSignin.configure({
           webClientId: config.googleWebClientId,
           offlineAccess: true,
-          iosClientId: config.googleIOSClientId, 
+          iosClientId: config.googleIOSClientId,
         });
         console.log('Google Sign-In configured successfully');
       } catch (err) {
@@ -90,11 +98,13 @@ export const AuthProvider: React.FC<AuthProviderProps> = ({ config, children })
             setStatus(AuthStatus.AUTHENTICATED);
           } catch (tokenError: any) {
             console.error('Token retrieval error:', tokenError);
-            if (tokenError.code === ProviderErrorCodes.USER_TOKEN_EXPIRED || 
+            if (tokenError.code === ProviderErrorCodes.USER_TOKEN_EXPIRED ||
                 tokenError.code === ProviderErrorCodes.NULL_USER) {
               setStatus(AuthStatus.TOKEN_EXPIRED);
+              setError(mapFirebaseError(tokenError));
             } else {
               setStatus(AuthStatus.UNAUTHENTICATED);
+              setError(mapFirebaseError(tokenError));
             }
             setUser(null);
           }
@@ -105,6 +115,7 @@ export const AuthProvider: React.FC<AuthProviderProps> = ({ config, children })
       } catch (err) {
         console.error("Auth State Error:", err);
         setStatus(AuthStatus.UNAUTHENTICATED);
+        setError(mapFirebaseError(err));
       } finally {
         setIsDataLoading(false);
       }
@@ -122,10 +133,10 @@ export const AuthProvider: React.FC<AuthProviderProps> = ({ config, children })
       setStatus(AuthStatus.LOADING);
       await FirebaseAuth.signInWithEmailAndPassword(firebaseAuthInstance, email, password);
     } catch (err: any) {
-      const mapped = mapFirebaseError(err);
-      setError({ ...mapped, originalError: err });
+      const mappedException = mapFirebaseError(err);
+      setError(mappedException);
       setStatus(AuthStatus.UNAUTHENTICATED);
-      throw err; 
+      throw mappedException;
     }
   };
 
@@ -136,18 +147,41 @@ export const AuthProvider: React.FC<AuthProviderProps> = ({ config, children })
       setStatus(AuthStatus.LOADING);
       await FirebaseAuth.createUserWithEmailAndPassword(firebaseAuthInstance, email, password);
     } catch (err: any) {
-      const mapped = mapFirebaseError(err);
-      setError({ ...mapped, originalError: err });
+      const mappedException = mapFirebaseError(err);
+      setError(mappedException);
+      setStatus(AuthStatus.UNAUTHENTICATED);
+      throw mappedException;
+    }
+  };
+
+
+  const sendPasswordReset = async (email: string) => {
+    if (!firebaseAuthInstance) return;
+    try {
+      setError(null);
+      setStatus(AuthStatus.LOADING);
+      
+      await sendPasswordResetEmail(firebaseAuthInstance, email);
+      
+
+      setStatus(AuthStatus.UNAUTHENTICATED);
+      console.log(`Password reset email sent to ${email}`);
+    } catch (err: any) {
+      const mappedException = mapFirebaseError(err);
+      setError(mappedException);
       setStatus(AuthStatus.UNAUTHENTICATED);
-      throw err;
+      throw mappedException;
     }
   };
 
   const signInWithGoogle = async () => {
     if (!firebaseAuthInstance) throw new Error('Firebase not initialized');
     if (!config.enableGoogle || !config.googleWebClientId) {
-      setError({ code: AuthErrorCode.CONFIG_ERROR, message: 'Google Auth not configured. Missing googleWebClientId.' });
-      return;
+      const configError = new ConfigurationException(
+        'Google Auth not configured. Missing googleWebClientId.'
+      );
+      setError(configError);
+      throw configError;
     }
 
     try {
@@ -166,56 +200,33 @@ export const AuthProvider: React.FC<AuthProviderProps> = ({ config, children })
 
     } catch (err: any) {
       console.error('Google Sign-In Error:', err);
-      let mappedError: AuthError;
 
       if (err.code === ProviderErrorCodes.GOOGLE_CANCELLED) {
-        mappedError = {
-          code: AuthErrorCode.GOOGLE_SIGN_IN_CANCELLED,
-          message: 'Google Sign-In was cancelled',
-          originalError: err
-        };
-        setStatus(AuthStatus.UNAUTHENTICATED); 
-        return; 
-      } else if (err.code === ProviderErrorCodes.GOOGLE_IN_PROGRESS) {
-        mappedError = {
-          code: AuthErrorCode.GOOGLE_SIGN_IN_IN_PROGRESS,
-          message: 'Google Sign-In is already in progress',
-          originalError: err
-        };
-      } else if (err.code === ProviderErrorCodes.GOOGLE_PLAY_UNAVAILABLE) {
-        mappedError = {
-          code: AuthErrorCode.GOOGLE_PLAY_SERVICES_NOT_AVAILABLE,
-          message: 'Google Play Services are not available. Please update Google Play Services.',
-          originalError: err
-        };
-      } else {
-        mappedError = mapFirebaseError(err);
+        const cancelError = new GoogleSignInCancelledException(err);
+        setError(cancelError);
+        setStatus(AuthStatus.UNAUTHENTICATED);
+        return;
       }
 
-      setError({ ...mappedError, originalError: err });
+      const mappedException = mapFirebaseError(err);
+      setError(mappedException);
       setStatus(AuthStatus.UNAUTHENTICATED);
-      throw mappedError;
+      throw mappedException;
     }
   };
 
   const signInWithApple = async () => {
     if (!firebaseAuthInstance) throw new Error('Firebase not initialized');
-    
+
     if (Platform.OS !== 'ios') {
-      const platformError: AuthError = {
-        code: AuthErrorCode.APPLE_SIGN_IN_NOT_SUPPORTED,
-        message: 'Apple Sign-In is only available on iOS devices',
-      };
+      const platformError = new AppleSignInNotSupportedException();
       setError(platformError);
       throw platformError;
     }
 
     const isAvailable = await AppleAuthentication.isAvailableAsync();
     if (!isAvailable) {
-      const availabilityError: AuthError = {
-        code: AuthErrorCode.APPLE_SIGN_IN_NOT_SUPPORTED,
-        message: 'Apple Sign-In is not available on this device (requires iOS 13+)',
-      };
+      const availabilityError = new AppleSignInNotSupportedException();
       setError(availabilityError);
       throw availabilityError;
     }
@@ -223,10 +234,10 @@ export const AuthProvider: React.FC<AuthProviderProps> = ({ config, children })
     try {
       setError(null);
       setStatus(AuthStatus.LOADING);
-      
+
       const nonce = Math.random().toString(36).substring(2, 10);
       const hashedNonce = await Crypto.digestStringAsync(Crypto.CryptoDigestAlgorithm.SHA256, nonce);
-      
+
       const appleCredential = await AppleAuthentication.signInAsync({
         requestedScopes: [
           AppleAuthentication.AppleAuthenticationScope.FULL_NAME,
@@ -252,20 +263,16 @@ export const AuthProvider: React.FC<AuthProviderProps> = ({ config, children })
       console.error('Apple Sign-In Error:', err);
 
       if (err.code === ProviderErrorCodes.APPLE_CANCELLED) {
-        const cancelError: AuthError = {
-          code: AuthErrorCode.APPLE_SIGN_IN_CANCELLED,
-          message: 'Apple Sign-In was cancelled',
-          originalError: err
-        };
+        const cancelError = new AppleSignInCancelledException(err);
         setError(cancelError);
         setStatus(AuthStatus.UNAUTHENTICATED);
         return;
       }
 
-      const mappedError = mapFirebaseError(err);
-      setError({ ...mappedError, originalError: err });
+      const mappedException = mapFirebaseError(err);
+      setError(mappedException);
       setStatus(AuthStatus.UNAUTHENTICATED);
-      throw mappedError;
+      throw mappedException;
     }
   };
 
@@ -284,6 +291,8 @@ export const AuthProvider: React.FC<AuthProviderProps> = ({ config, children })
       console.log('Sign out successful');
     } catch (err) {
       console.error('Sign out error:', err);
+      const signOutError = mapFirebaseError(err);
+      setError(signOutError);
       setUser(null);
       setStatus(AuthStatus.UNAUTHENTICATED);
     }
@@ -299,6 +308,7 @@ export const AuthProvider: React.FC<AuthProviderProps> = ({ config, children })
     config,
     signInWithEmail,
     signUpWithEmail,
+    sendPasswordReset,
     signInWithGoogle,
     signInWithApple,
     signOut,