rn-swiftauth-sdk 1.0.2 → 1.0.3

package/dist/errors/exceptions.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UnknownAuthException = exports.ConfigurationException = exports.GooglePlayServicesUnavailableException = exports.AppleSignInNotSupportedException = exports.AppleSignInCancelledException = exports.GoogleSignInCancelledException = exports.NetworkException = exports.TokenExpiredException = exports.WeakPasswordException = exports.EmailAlreadyInUseException = exports.UserNotFoundException = exports.InvalidCredentialsException = exports.AuthException = void 0;
+class AuthException extends Error {
+    code;
+    originalError;
+    timestamp;
+    constructor(message, code, originalError) {
+        super(message);
+        this.name = this.constructor.name;
+        this.code = code;
+        this.originalError = originalError;
+        this.timestamp = new Date();
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            code: this.code,
+            message: this.message,
+            timestamp: this.timestamp.toISOString(),
+            originalError: this.originalError?.code || this.originalError?.message,
+        };
+    }
+}
+exports.AuthException = AuthException;
+class InvalidCredentialsException extends AuthException {
+    constructor(originalError) {
+        super('Invalid email or password. Please check your credentials and try again.', 'auth/invalid-credentials', originalError);
+    }
+}
+exports.InvalidCredentialsException = InvalidCredentialsException;
+/**
+ * Thrown when user account does not exist
+ */
+class UserNotFoundException extends AuthException {
+    constructor(originalError) {
+        super('No account found with this email. Please sign up first.', 'auth/user-not-found', originalError);
+    }
+}
+exports.UserNotFoundException = UserNotFoundException;
+/**
+ * Thrown when attempting to sign up with an email that's already registered
+ */
+class EmailAlreadyInUseException extends AuthException {
+    constructor(originalError) {
+        super('This email is already registered. Please sign in or use a different email.', 'auth/email-already-in-use', originalError);
+    }
+}
+exports.EmailAlreadyInUseException = EmailAlreadyInUseException;
+/**
+ * Thrown when password doesn't meet minimum security requirements
+ */
+class WeakPasswordException extends AuthException {
+    constructor(originalError) {
+        super('Password is too weak. Please use at least 6 characters with a mix of letters and numbers.', 'auth/weak-password', originalError);
+    }
+}
+exports.WeakPasswordException = WeakPasswordException;
+/**
+ * Thrown when user's authentication token has expired
+ */
+class TokenExpiredException extends AuthException {
+    constructor(originalError) {
+        super('Your session has expired. Please sign in again.', 'auth/token-expired', originalError);
+    }
+}
+exports.TokenExpiredException = TokenExpiredException;
+/**
+ * Thrown when network connectivity issues occur
+ */
+class NetworkException extends AuthException {
+    constructor(originalError) {
+        super('Network error. Please check your internet connection and try again.', 'auth/network-error', originalError);
+    }
+}
+exports.NetworkException = NetworkException;
+/**
+ * Thrown when Google Sign-In is cancelled by user
+ */
+class GoogleSignInCancelledException extends AuthException {
+    constructor(originalError) {
+        super('Google Sign-In was cancelled.', 'auth/google-sign-in-cancelled', originalError);
+    }
+}
+exports.GoogleSignInCancelledException = GoogleSignInCancelledException;
+/**
+ * Thrown when Apple Sign-In is cancelled by user
+ */
+class AppleSignInCancelledException extends AuthException {
+    constructor(originalError) {
+        super('Apple Sign-In was cancelled.', 'auth/apple-sign-in-cancelled', originalError);
+    }
+}
+exports.AppleSignInCancelledException = AppleSignInCancelledException;
+/**
+ * Thrown when Apple Sign-In is not supported on the device
+ */
+class AppleSignInNotSupportedException extends AuthException {
+    constructor(originalError) {
+        super('Apple Sign-In is only available on iOS 13+ devices.', 'auth/apple-sign-in-not-supported', originalError);
+    }
+}
+exports.AppleSignInNotSupportedException = AppleSignInNotSupportedException;
+/**
+ * Thrown when Google Play Services are not available
+ */
+class GooglePlayServicesUnavailableException extends AuthException {
+    constructor(originalError) {
+        super('Google Play Services are not available. Please update Google Play Services.', 'auth/google-play-services-unavailable', originalError);
+    }
+}
+exports.GooglePlayServicesUnavailableException = GooglePlayServicesUnavailableException;
+/**
+ * Thrown for configuration errors
+ */
+class ConfigurationException extends AuthException {
+    constructor(message, originalError) {
+        super(message, 'auth/configuration-error', originalError);
+    }
+}
+exports.ConfigurationException = ConfigurationException;
+/**
+ * Generic unknown error
+ */
+class UnknownAuthException extends AuthException {
+    constructor(message = 'An unexpected error occurred.', originalError) {
+        super(message, 'auth/unknown', originalError);
+    }
+}
+exports.UnknownAuthException = UnknownAuthException;

package/dist/errors/index.d.ts

@@ -1 +1,2 @@
-export * from './errorMapper';
+export { AuthException, InvalidCredentialsException, UserNotFoundException, EmailAlreadyInUseException, WeakPasswordException, TokenExpiredException, NetworkException, GoogleSignInCancelledException, AppleSignInCancelledException, AppleSignInNotSupportedException, GooglePlayServicesUnavailableException, ConfigurationException, UnknownAuthException, } from './exceptions';
+export { mapFirebaseError, isAuthException, getErrorMessage, } from './errorMapper';

package/dist/errors/index.js

@@ -1,17 +1,21 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./errorMapper"), exports);
+exports.getErrorMessage = exports.isAuthException = exports.mapFirebaseError = exports.UnknownAuthException = exports.ConfigurationException = exports.GooglePlayServicesUnavailableException = exports.AppleSignInNotSupportedException = exports.AppleSignInCancelledException = exports.GoogleSignInCancelledException = exports.NetworkException = exports.TokenExpiredException = exports.WeakPasswordException = exports.EmailAlreadyInUseException = exports.UserNotFoundException = exports.InvalidCredentialsException = exports.AuthException = void 0;
+var exceptions_1 = require("./exceptions");
+Object.defineProperty(exports, "AuthException", { enumerable: true, get: function () { return exceptions_1.AuthException; } });
+Object.defineProperty(exports, "InvalidCredentialsException", { enumerable: true, get: function () { return exceptions_1.InvalidCredentialsException; } });
+Object.defineProperty(exports, "UserNotFoundException", { enumerable: true, get: function () { return exceptions_1.UserNotFoundException; } });
+Object.defineProperty(exports, "EmailAlreadyInUseException", { enumerable: true, get: function () { return exceptions_1.EmailAlreadyInUseException; } });
+Object.defineProperty(exports, "WeakPasswordException", { enumerable: true, get: function () { return exceptions_1.WeakPasswordException; } });
+Object.defineProperty(exports, "TokenExpiredException", { enumerable: true, get: function () { return exceptions_1.TokenExpiredException; } });
+Object.defineProperty(exports, "NetworkException", { enumerable: true, get: function () { return exceptions_1.NetworkException; } });
+Object.defineProperty(exports, "GoogleSignInCancelledException", { enumerable: true, get: function () { return exceptions_1.GoogleSignInCancelledException; } });
+Object.defineProperty(exports, "AppleSignInCancelledException", { enumerable: true, get: function () { return exceptions_1.AppleSignInCancelledException; } });
+Object.defineProperty(exports, "AppleSignInNotSupportedException", { enumerable: true, get: function () { return exceptions_1.AppleSignInNotSupportedException; } });
+Object.defineProperty(exports, "GooglePlayServicesUnavailableException", { enumerable: true, get: function () { return exceptions_1.GooglePlayServicesUnavailableException; } });
+Object.defineProperty(exports, "ConfigurationException", { enumerable: true, get: function () { return exceptions_1.ConfigurationException; } });
+Object.defineProperty(exports, "UnknownAuthException", { enumerable: true, get: function () { return exceptions_1.UnknownAuthException; } });
+var errorMapper_1 = require("./errorMapper");
+Object.defineProperty(exports, "mapFirebaseError", { enumerable: true, get: function () { return errorMapper_1.mapFirebaseError; } });
+Object.defineProperty(exports, "isAuthException", { enumerable: true, get: function () { return errorMapper_1.isAuthException; } });
+Object.defineProperty(exports, "getErrorMessage", { enumerable: true, get: function () { return errorMapper_1.getErrorMessage; } });

package/dist/types/auth.types.d.ts

@@ -1,5 +1,5 @@
 import { AuthConfig } from './config.types';
-import { AuthError } from './error.types';
+import { AuthException } from '../errors';
 export declare enum AuthStatus {
     AUTHENTICATED = "AUTHENTICATED",
     UNAUTHENTICATED = "UNAUTHENTICATED",
@@ -26,7 +26,7 @@ export interface AuthContextType {
     user: User | null;
     status: AuthStatus;
     isLoading: boolean;
-    error: AuthError | null;
+    error: AuthException | null;
     config: AuthConfig;
     signInWithEmail: (options: EmailSignInOptions) => Promise<void>;
     signUpWithEmail: (options: EmailSignUpOptions) => Promise<void>;

package/dist/types/error.types.d.ts

@@ -13,20 +13,21 @@ export declare enum AuthErrorCode {
     EMAIL_ALREADY_IN_USE = "auth/email-already-in-use",
     WEAK_PASSWORD = "auth/weak-password",
     TOKEN_EXPIRED = "auth/token-expired",
-    NETWORK_ERROR = "auth/network-request-failed",
+    NETWORK_ERROR = "auth/network-error",
     UNKNOWN = "auth/unknown",
     CONFIG_ERROR = "auth/configuration-error",
     CANCELLED = "auth/cancelled",
-    GOOGLE_SIGN_IN_CANCELLED = "GOOGLE_SIGN_IN_CANCELLED",
-    GOOGLE_SIGN_IN_IN_PROGRESS = "GOOGLE_SIGN_IN_IN_PROGRESS",
-    GOOGLE_PLAY_SERVICES_NOT_AVAILABLE = "GOOGLE_PLAY_SERVICES_NOT_AVAILABLE",
-    GOOGLE_SIGN_IN_FAILED = "GOOGLE_SIGN_IN_FAILED",
-    APPLE_SIGN_IN_CANCELLED = "APPLE_SIGN_IN_CANCELLED",
-    APPLE_SIGN_IN_FAILED = "APPLE_SIGN_IN_FAILED",
-    APPLE_SIGN_IN_NOT_SUPPORTED = "APPLE_SIGN_IN_NOT_SUPPORTED"
+    GOOGLE_SIGN_IN_CANCELLED = "auth/google-sign-in-cancelled",
+    GOOGLE_SIGN_IN_IN_PROGRESS = "auth/google-sign-in-in-progress",
+    GOOGLE_PLAY_SERVICES_NOT_AVAILABLE = "auth/google-play-services-unavailable",
+    GOOGLE_SIGN_IN_FAILED = "auth/google-sign-in-failed",
+    APPLE_SIGN_IN_CANCELLED = "auth/apple-sign-in-cancelled",
+    APPLE_SIGN_IN_FAILED = "auth/apple-sign-in-failed",
+    APPLE_SIGN_IN_NOT_SUPPORTED = "auth/apple-sign-in-not-supported"
 }
 export interface AuthError {
     code: string | ProviderErrorCodes | AuthErrorCode;
     message: string;
     originalError?: any;
 }
+export declare const isAuthError: (error: any) => error is AuthError;

package/dist/types/error.types.js

@@ -1,8 +1,6 @@
 "use strict";
-// src/types/error.types.ts
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AuthErrorCode = exports.ProviderErrorCodes = void 0;
-// ✅ 1. Define Known Error Codes (Source of Truth)
+exports.isAuthError = exports.AuthErrorCode = exports.ProviderErrorCodes = void 0;
 var ProviderErrorCodes;
 (function (ProviderErrorCodes) {
     // Firebase specific
@@ -16,26 +14,35 @@ var ProviderErrorCodes;
     ProviderErrorCodes["APPLE_CANCELLED"] = "ERR_REQUEST_CANCELED";
     ProviderErrorCodes["APPLE_NOT_SUPPORTED"] = "APPLE_SIGN_IN_NOT_SUPPORTED";
 })(ProviderErrorCodes || (exports.ProviderErrorCodes = ProviderErrorCodes = {}));
-// Legacy error codes used in mapping (Keep this for backward compatibility if needed)
+// ✅ Standardized error codes (used by custom exceptions)
 var AuthErrorCode;
 (function (AuthErrorCode) {
+    // Core authentication errors
     AuthErrorCode["INVALID_CREDENTIALS"] = "auth/invalid-credentials";
     AuthErrorCode["USER_NOT_FOUND"] = "auth/user-not-found";
     AuthErrorCode["EMAIL_ALREADY_IN_USE"] = "auth/email-already-in-use";
     AuthErrorCode["WEAK_PASSWORD"] = "auth/weak-password";
     AuthErrorCode["TOKEN_EXPIRED"] = "auth/token-expired";
-    AuthErrorCode["NETWORK_ERROR"] = "auth/network-request-failed";
+    AuthErrorCode["NETWORK_ERROR"] = "auth/network-error";
     AuthErrorCode["UNKNOWN"] = "auth/unknown";
-    // Specific to SDK flow
+    // Configuration errors
     AuthErrorCode["CONFIG_ERROR"] = "auth/configuration-error";
+    // User actions
     AuthErrorCode["CANCELLED"] = "auth/cancelled";
-    // Google Sign-In Errors
-    AuthErrorCode["GOOGLE_SIGN_IN_CANCELLED"] = "GOOGLE_SIGN_IN_CANCELLED";
-    AuthErrorCode["GOOGLE_SIGN_IN_IN_PROGRESS"] = "GOOGLE_SIGN_IN_IN_PROGRESS";
-    AuthErrorCode["GOOGLE_PLAY_SERVICES_NOT_AVAILABLE"] = "GOOGLE_PLAY_SERVICES_NOT_AVAILABLE";
-    AuthErrorCode["GOOGLE_SIGN_IN_FAILED"] = "GOOGLE_SIGN_IN_FAILED";
-    // Apple Sign-In Errors
-    AuthErrorCode["APPLE_SIGN_IN_CANCELLED"] = "APPLE_SIGN_IN_CANCELLED";
-    AuthErrorCode["APPLE_SIGN_IN_FAILED"] = "APPLE_SIGN_IN_FAILED";
-    AuthErrorCode["APPLE_SIGN_IN_NOT_SUPPORTED"] = "APPLE_SIGN_IN_NOT_SUPPORTED";
+    // Google Sign-In errors
+    AuthErrorCode["GOOGLE_SIGN_IN_CANCELLED"] = "auth/google-sign-in-cancelled";
+    AuthErrorCode["GOOGLE_SIGN_IN_IN_PROGRESS"] = "auth/google-sign-in-in-progress";
+    AuthErrorCode["GOOGLE_PLAY_SERVICES_NOT_AVAILABLE"] = "auth/google-play-services-unavailable";
+    AuthErrorCode["GOOGLE_SIGN_IN_FAILED"] = "auth/google-sign-in-failed";
+    // Apple Sign-In errors
+    AuthErrorCode["APPLE_SIGN_IN_CANCELLED"] = "auth/apple-sign-in-cancelled";
+    AuthErrorCode["APPLE_SIGN_IN_FAILED"] = "auth/apple-sign-in-failed";
+    AuthErrorCode["APPLE_SIGN_IN_NOT_SUPPORTED"] = "auth/apple-sign-in-not-supported";
 })(AuthErrorCode || (exports.AuthErrorCode = AuthErrorCode = {}));
+const isAuthError = (error) => {
+    return (error &&
+        typeof error === 'object' &&
+        'code' in error &&
+        'message' in error);
+};
+exports.isAuthError = isAuthError;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "rn-swiftauth-sdk",
-    "version": "1.0.2",
+    "version": "1.0.3",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
     "files": [

package/src/core/AuthProvider.tsx

@@ -6,18 +6,24 @@ 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 +34,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 +53,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 +72,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 +96,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 +113,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 +131,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 +145,21 @@ 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 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 +178,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 +212,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 +241,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 +269,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);
     }