rn-swiftauth-sdk 1.0.2 → 1.0.4

package/src/errors/errorMapper.ts

@@ -1,139 +1,131 @@
-import { FirebaseError } from 'firebase/app';
-import { AuthError, AuthErrorCode } from '../types';
+// swiftauth-sdk/src/errors/errorMapper.ts
 
-export const mapFirebaseError = (error: any): AuthError => {
-  // Default fallback
-  const fallbackError: AuthError = {
-    code: AuthErrorCode.UNKNOWN,
-    message: 'An unexpected error occurred',
-    originalError: error,
-  };
+import { FirebaseError } from 'firebase/app';
+import {
+  AuthException,
+  InvalidCredentialsException,
+  UserNotFoundException,
+  EmailAlreadyInUseException,
+  WeakPasswordException,
+  TokenExpiredException,
+  NetworkException,
+  GoogleSignInCancelledException,
+  AppleSignInCancelledException,
+  AppleSignInNotSupportedException,
+  GooglePlayServicesUnavailableException,
+  ConfigurationException,
+  UnknownAuthException,
+} from './exceptions';
+import { ProviderErrorCodes } from '../types';
+
+
+export const mapFirebaseError = (error: any): AuthException => {
+  // If it's already our custom exception, return it
+  if (error instanceof AuthException) {
+    return error;
+  }
 
-  // If it's not a Firebase error, return generic
+  // If it's not a Firebase error or doesn't have a code, return generic
   if (!error || typeof error.code !== 'string') {
-    return {
-      ...fallbackError,
-      message: error?.message || fallbackError.message
-    };
+    return new UnknownAuthException(
+      error?.message || 'An unexpected error occurred',
+      error
+    );
   }
 
   const fbError = error as FirebaseError;
 
+  // Map Firebase error codes to custom exceptions
   switch (fbError.code) {
-    // Email/Password Errors
+    // Invalid Credentials
     case 'auth/invalid-email':
-    case 'auth/user-not-found':
     case 'auth/wrong-password':
     case 'auth/invalid-credential':
-      return {
-        code: AuthErrorCode.INVALID_CREDENTIALS,
-        message: 'Invalid email or password.',
-        originalError: error
-      };
+    case 'auth/user-disabled':
+      return new InvalidCredentialsException(error);
+
+    // User Not Found
+    case 'auth/user-not-found':
+      return new UserNotFoundException(error);
 
+    // Email Already In Use
     case 'auth/email-already-in-use':
-      return {
-        code: AuthErrorCode.EMAIL_ALREADY_IN_USE,
-        message: 'This email is already registered.',
-        originalError: error
-      };
+    case 'auth/account-exists-with-different-credential':
+      return new EmailAlreadyInUseException(error);
 
+    // Weak Password
     case 'auth/weak-password':
-      return {
-        code: AuthErrorCode.WEAK_PASSWORD,
-        message: 'Password is too weak. Please use a stronger password.',
-        originalError: error
-      };
+      return new WeakPasswordException(error);
+
+    // Token Expired
+    case 'auth/id-token-expired':
+    case 'auth/user-token-expired':
+    case ProviderErrorCodes.USER_TOKEN_EXPIRED:
+      return new TokenExpiredException(error);
 
+    // Network Error
     case 'auth/network-request-failed':
-      return {
-        code: AuthErrorCode.NETWORK_ERROR,
-        message: 'Network error. Please check your connection.',
-        originalError: error
-      };
+    case 'auth/timeout':
+      return new NetworkException(error);
 
     // Google Sign-In Errors
+    case ProviderErrorCodes.GOOGLE_CANCELLED:
     case 'auth/popup-closed-by-user':
     case 'auth/cancelled-popup-request':
-      return {
-        code: AuthErrorCode.UNKNOWN,
-        message: 'Sign-in was cancelled.',
-        originalError: error
-      };
+      return new GoogleSignInCancelledException(error);
 
-    case 'auth/account-exists-with-different-credential':
-      return {
-        code: AuthErrorCode.EMAIL_ALREADY_IN_USE,
-        message: 'An account already exists with this email using a different sign-in method.',
-        originalError: error
-      };
+    case ProviderErrorCodes.GOOGLE_PLAY_UNAVAILABLE:
+      return new GooglePlayServicesUnavailableException(error);
 
-    case 'auth/invalid-credential':
-      return {
-        code: AuthErrorCode.INVALID_CREDENTIALS,
-        message: 'The credential received is invalid. Please try again.',
-        originalError: error
-      };
-
-    case 'auth/operation-not-allowed':
-      return {
-        code: AuthErrorCode.UNKNOWN,
-        message: 'This sign-in method is not enabled. Please contact support.',
-        originalError: error
-      };
+    // Apple Sign-In Errors
+    case ProviderErrorCodes.APPLE_CANCELLED:
+      return new AppleSignInCancelledException(error);
 
-    case 'auth/user-disabled':
-      return {
-        code: AuthErrorCode.INVALID_CREDENTIALS,
-        message: 'This account has been disabled.',
-        originalError: error
-      };
+    case ProviderErrorCodes.APPLE_NOT_SUPPORTED:
+      return new AppleSignInNotSupportedException(error);
 
-    // Apple Sign-In Errors
-    case 'auth/invalid-verification-code':
-    case 'auth/invalid-verification-id':
-      return {
-        code: AuthErrorCode.INVALID_CREDENTIALS,
-        message: 'The verification code is invalid. Please try again.',
-        originalError: error
-      };
-
-    // Token Expiration
-    case 'auth/id-token-expired':
-    case 'auth/user-token-expired':
-      return {
-        code: AuthErrorCode.TOKEN_EXPIRED,
-        message: 'Your session has expired. Please sign in again.',
-        originalError: error
-      };
+    // Configuration Errors
+    case 'auth/operation-not-allowed':
+      return new ConfigurationException(
+        'This sign-in method is not enabled. Please check your Firebase configuration.',
+        error
+      );
 
-    // OAuth-Specific Errors
     case 'auth/unauthorized-domain':
-      return {
-        code: AuthErrorCode.UNKNOWN,
-        message: 'This domain is not authorized for OAuth operations.',
-        originalError: error
-      };
+      return new ConfigurationException(
+        'This domain is not authorized for OAuth operations.',
+        error
+      );
 
     case 'auth/invalid-oauth-provider':
-      return {
-        code: AuthErrorCode.UNKNOWN,
-        message: 'The OAuth provider configuration is invalid.',
-        originalError: error
-      };
-
     case 'auth/invalid-oauth-client-id':
-      return {
-        code: AuthErrorCode.UNKNOWN,
-        message: 'The OAuth client ID is invalid.',
-        originalError: error
-      };
+      return new ConfigurationException(
+        'The OAuth configuration is invalid.',
+        error
+      );
 
+    // Default
     default:
-      return {
-        code: AuthErrorCode.UNKNOWN,
-        message: fbError.message || 'An unknown error occurred.',
-        originalError: error
-      };
+      return new UnknownAuthException(
+        fbError.message || 'An unknown error occurred.',
+        error
+      );
+  }
+};
+
+/**
+ * Helper function to check if an error is a specific exception type
+ */
+export const isAuthException = (error: any, exceptionType: new (...args: any[]) => AuthException): boolean => {
+  return error instanceof exceptionType;
+};
+
+/**
+ * Helper to extract user-friendly message from any error
+ */
+export const getErrorMessage = (error: any): string => {
+  if (error instanceof AuthException) {
+    return error.message;
   }
+  return error?.message || 'An unexpected error occurred';
 };

package/src/errors/exceptions.ts

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

package/src/errors/index.ts

@@ -1 +1,22 @@
-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/src/types/auth.types.ts

@@ -1,5 +1,5 @@
 import { AuthConfig } from './config.types';
-import { AuthError } from './error.types'; 
+import { AuthException } from '../errors';
 
 export enum AuthStatus {
   AUTHENTICATED = 'AUTHENTICATED',
@@ -32,13 +32,13 @@ export interface AuthContextType {
   user: User | null;
   status: AuthStatus;
   isLoading: boolean;
-  error: AuthError | null; // ✅ Uses the type imported from error.types.ts
+  error: AuthException | null;
   config: AuthConfig;
 
   // Function Signatures
   signInWithEmail: (options: EmailSignInOptions) => Promise<void>;
   signUpWithEmail: (options: EmailSignUpOptions) => Promise<void>;
-  
+  sendPasswordReset: (email: string) => Promise<void>;
   signInWithGoogle: () => Promise<void>;
   signInWithApple: () => Promise<void>;
   signOut: () => Promise<void>;

package/src/types/error.types.ts

@@ -1,50 +1,58 @@
-// src/types/error.types.ts
-
-// ✅ 1. Define Known Error Codes (Source of Truth)
 export enum ProviderErrorCodes {
   // Firebase specific
   USER_TOKEN_EXPIRED = 'auth/user-token-expired',
   NULL_USER = 'auth/null-user',
-  
+
   // Google specific
   GOOGLE_CANCELLED = 'SIGN_IN_CANCELLED',
   GOOGLE_IN_PROGRESS = 'IN_PROGRESS',
   GOOGLE_PLAY_UNAVAILABLE = 'PLAY_SERVICES_NOT_AVAILABLE',
-  
+
   // Apple specific
   APPLE_CANCELLED = 'ERR_REQUEST_CANCELED',
   APPLE_NOT_SUPPORTED = 'APPLE_SIGN_IN_NOT_SUPPORTED'
 }
 
-// Legacy error codes used in mapping (Keep this for backward compatibility if needed)
+// ✅ Standardized error codes (used by custom exceptions)
 export enum AuthErrorCode {
+  // Core authentication errors
   INVALID_CREDENTIALS = 'auth/invalid-credentials',
   USER_NOT_FOUND = 'auth/user-not-found',
   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',
-  // Specific to SDK flow
+
+  // Configuration errors
   CONFIG_ERROR = 'auth/configuration-error',
+
+  // User actions
   CANCELLED = 'auth/cancelled',
 
-  // Google Sign-In Errors
-  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',
+  // Google Sign-In errors
+  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 Errors
-  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',
+  // Apple Sign-In errors
+  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',
 }
 
-// ✅ 2. Strong Typing for Error Objects
-// We allow 'code' to be either our new Enum or the legacy Enum
 export interface AuthError {
   code: string | ProviderErrorCodes | AuthErrorCode;
   message: string;
-  originalError?: any; // To store the raw Firebase error for debugging
-}
+  originalError?: any;
+}
+
+export const isAuthError = (error: any): error is AuthError => {
+  return (
+    error &&
+    typeof error === 'object' &&
+    'code' in error &&
+    'message' in error
+  );
+};