@umituz/react-native-firebase 1.13.48 → 1.13.49

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-firebase",
-  "version": "1.13.48",
+  "version": "1.13.49",
   "description": "Unified Firebase package for React Native apps - Auth and Firestore services using Firebase JS SDK (no native modules).",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/auth/infrastructure/config/FirebaseAuthClient.ts

@@ -1,16 +1,5 @@
 /**
  * Firebase Auth Client - Infrastructure Layer
- *
- * Domain-Driven Design: Infrastructure implementation of Firebase Auth client
- * Singleton pattern for managing Firebase Auth instance
- *
- * IMPORTANT: This package requires Firebase App to be initialized first.
- * Use @umituz/react-native-firebase to initialize Firebase App.
- *
- * SOLID Principles:
- * - Single Responsibility: Only manages Auth initialization
- * - Open/Closed: Extensible through configuration, closed for modification
- * - Dependency Inversion: Depends on Firebase App from @umituz/react-native-firebase
  */
 
 import type { Auth } from 'firebase/auth';
@@ -20,190 +9,46 @@ import type { FirebaseAuthConfig } from '../../domain/value-objects/FirebaseAuth
 
 declare const __DEV__: boolean;
 
-/**
- * Firebase Auth Client Singleton
- * Manages Firebase Auth initialization
- */
 class FirebaseAuthClientSingleton {
   private static instance: FirebaseAuthClientSingleton | null = null;
   private auth: Auth | null = null;
   private initializationError: string | null = null;
 
-  private constructor() {
-    // Private constructor to enforce singleton pattern
-  }
-
-  /**
-   * Get singleton instance
-   */
   static getInstance(): FirebaseAuthClientSingleton {
-    if (!FirebaseAuthClientSingleton.instance) {
-      FirebaseAuthClientSingleton.instance = new FirebaseAuthClientSingleton();
-    }
-    return FirebaseAuthClientSingleton.instance;
+    if (!this.instance) this.instance = new FirebaseAuthClientSingleton();
+    return this.instance;
   }
 
-  /**
-   * Initialize Firebase Auth
-   * Requires Firebase App to be initialized first via @umituz/react-native-firebase
-   *
-   * @param config - Optional Firebase Auth configuration
-   * @returns Firebase Auth instance or null if initialization fails
-   */
   initialize(config?: FirebaseAuthConfig): Auth | null {
-    // Return existing instance if already initialized
-    if (this.auth) {
-      if (__DEV__) {
-        console.log('[FirebaseAuth] Already initialized, returning existing instance');
-      }
-      return this.auth;
-    }
-
-    // Don't retry if initialization already failed
-    if (this.initializationError) {
-      if (__DEV__) {
-        console.warn('[FirebaseAuth] Previous initialization failed:', this.initializationError);
-      }
-      return null;
-    }
+    if (this.auth) return this.auth;
+    if (this.initializationError) return null;
 
     try {
-      // Get Firebase App instance (must be initialized first)
       const app = getFirebaseApp();
-
-      // Return null if Firebase App is not available (offline mode)
-      if (!app) {
-        if (__DEV__) {
-          console.log('[FirebaseAuth] Firebase App not available - skipping Auth initialization');
-        }
-        // Don't set initializationError - this is normal offline mode
-        return null;
-      }
-
-      if (__DEV__) {
-        console.log('[FirebaseAuth] Initializing Firebase Auth...');
-      }
-
-      // Initialize Auth
+      if (!app) return null;
       this.auth = FirebaseAuthInitializer.initialize(app, config);
-
-      if (this.auth) {
-        if (__DEV__) {
-          console.log('[FirebaseAuth] ✅ Successfully initialized');
-        }
-      } else {
-        if (__DEV__) {
-          console.warn('[FirebaseAuth] ⚠️ Initialization returned null');
-        }
-      }
-
       return this.auth;
-    } catch (error) {
-      // Only set error if it's a real initialization failure, not just missing config
-      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-      if (__DEV__) {
-        console.error('[FirebaseAuth] ❌ Initialization error:', errorMessage);
-      }
-      if (!errorMessage.includes('not initialized') && !errorMessage.includes('not available')) {
-        this.initializationError = errorMessage;
-      }
+    } catch (error: any) {
+      if (__DEV__) console.error('[FirebaseAuth] Init error:', error.message);
+      this.initializationError = error.message;
       return null;
     }
   }
 
-  /**
-   * Get the Firebase Auth instance
-   * Auto-initializes if Firebase App is available
-   * Returns null if config is not available (offline mode - no error)
-   * @returns Firebase Auth instance or null if not initialized
-   */
   getAuth(): Auth | null {
-    // Auto-initialize if not already initialized
-    if (!this.auth && !this.initializationError) {
-      try {
-        // Try to get Firebase App (will auto-initialize if config is available)
-        const app = getFirebaseApp();
-        if (app) {
-          this.initialize();
-        }
-      } catch {
-        // Firebase App not available, return null (offline mode)
-        return null;
-      }
-    }
-
-    // Return null if not initialized (offline mode - no error)
-    return this.auth || null;
+    if (!this.auth && !this.initializationError && getFirebaseApp()) this.initialize();
+    return this.auth;
   }
 
-  /**
-   * Check if Auth is initialized
-   */
-  isInitialized(): boolean {
-    return this.auth !== null;
-  }
-
-  /**
-   * Get initialization error if any
-   */
-  getInitializationError(): string | null {
-    return this.initializationError;
-  }
-
-  /**
-   * Reset the Auth client instance
-   * Useful for testing
-   */
-  reset(): void {
-    this.auth = null;
-    this.initializationError = null;
-  }
+  reset(): void { this.auth = null; this.initializationError = null; }
 }
 
-/**
- * Singleton instance
- */
 export const firebaseAuthClient = FirebaseAuthClientSingleton.getInstance();
+export const initializeFirebaseAuth = (c?: FirebaseAuthConfig) => firebaseAuthClient.initialize(c);
+export const getFirebaseAuth = () => firebaseAuthClient.getAuth();
+export const isFirebaseAuthInitialized = () => firebaseAuthClient.getAuth() !== null;
+export const getFirebaseAuthInitializationError = () => firebaseAuthClient.initialize() ? null : "Not initialized"; 
+export const resetFirebaseAuthClient = () => firebaseAuthClient.reset();
 
-export function initializeFirebaseAuth(
-  config?: FirebaseAuthConfig
-): Auth | null {
-  return firebaseAuthClient.initialize(config);
-}
-
-/**
- * Get Firebase Auth instance
- * Auto-initializes if Firebase App is available
- * Returns null if config is not available (offline mode - no error)
- * @returns Firebase Auth instance or null if not initialized
- */
-export function getFirebaseAuth(): Auth | null {
-  return firebaseAuthClient.getAuth();
-}
-
-/**
- * Check if Firebase Auth is initialized
- */
-export function isFirebaseAuthInitialized(): boolean {
-  return firebaseAuthClient.isInitialized();
-}
-
-/**
- * Get initialization error if any
- */
-export function getFirebaseAuthInitializationError(): string | null {
-  return firebaseAuthClient.getInitializationError();
-}
-
-/**
- * Reset Firebase Auth client instance
- * Useful for testing
- */
-export function resetFirebaseAuthClient(): void {
-  firebaseAuthClient.reset();
-}
-
-// Export types
 export type { Auth } from 'firebase/auth';
 export type { FirebaseAuthConfig } from '../../domain/value-objects/FirebaseAuthConfig';
-

package/src/auth/infrastructure/services/account-deletion.service.ts

@@ -1,8 +1,5 @@
 /**
  * Account Deletion Service
- * Handles Firebase Auth account deletion operations with automatic reauthentication
- *
- * SOLID: Single Responsibility - Only handles account deletion
  */
 
 import { deleteUser, type User } from "firebase/auth";
@@ -11,381 +8,74 @@ import {
   getUserAuthProvider,
   reauthenticateWithApple,
   reauthenticateWithPassword,
+  reauthenticateWithGoogle,
 } from "./reauthentication.service";
+import type { AccountDeletionResult, AccountDeletionOptions } from "./reauthentication.types";
 
-export interface AccountDeletionResult {
-  success: boolean;
-  error?: {
-    code: string;
-    message: string;
-    requiresReauth: boolean;
-  };
-}
+export type { AccountDeletionResult, AccountDeletionOptions } from "./reauthentication.types";
 
-export interface AccountDeletionOptions {
-  /**
-   * Google ID token for reauthentication (required if user signed in with Google)
-   * This must be provided by the calling code after prompting user for Google sign-in
-   */
-  googleIdToken?: string;
-  /**
-   * Password for reauthentication (required if user signed in with email/password)
-   * This must be provided by the calling code after prompting user for password
-   */
-  password?: string;
-  /**
-   * If true, will attempt to reauthenticate with Apple automatically
-   * (shows Apple sign-in prompt to user)
-   */
-  autoReauthenticate?: boolean;
-}
+declare const __DEV__: boolean;
 
-/**
- * Delete the current user's Firebase Auth account
- * Now with automatic reauthentication support for Apple Sign-In
- * Note: This is irreversible and also signs out the user
- */
 export async function deleteCurrentUser(
   options: AccountDeletionOptions = { autoReauthenticate: true }
 ): Promise<AccountDeletionResult> {
-  if (__DEV__) {
-    console.log("[deleteCurrentUser] Starting with options:", options);
-  }
-
   const auth = getFirebaseAuth();
+  const user = auth?.currentUser;
 
-  if (!auth) {
-    if (__DEV__) {
-      console.log("[deleteCurrentUser] ❌ Firebase Auth not initialized");
-    }
-    return {
-      success: false,
-      error: {
-        code: "auth/not-initialized",
-        message: "Firebase Auth is not initialized",
-        requiresReauth: false,
-      },
-    };
-  }
-
-  const user = auth.currentUser;
-
-  if (!user) {
-    if (__DEV__) {
-      console.log("[deleteCurrentUser] ❌ No user signed in");
-    }
-    return {
-      success: false,
-      error: {
-        code: "auth/no-user",
-        message: "No user is currently signed in",
-        requiresReauth: false,
-      },
-    };
-  }
-
-  if (user.isAnonymous) {
-    if (__DEV__) {
-      console.log("[deleteCurrentUser] ❌ Cannot delete anonymous user");
-    }
-    return {
-      success: false,
-      error: {
-        code: "auth/anonymous-user",
-        message: "Cannot delete anonymous account",
-        requiresReauth: false,
-      },
-    };
-  }
-
-  if (__DEV__) {
-    const provider = getUserAuthProvider(user);
-    console.log("[deleteCurrentUser] User info:", {
-      uid: user.uid,
-      provider,
-      providerData: user.providerData?.map(p => p.providerId),
-    });
-  }
+  if (!auth || !user) return { 
+    success: false, 
+    error: { code: "auth/not-ready", message: "Auth not ready", requiresReauth: false } 
+  };
+  if (user.isAnonymous) return {
+    success: false,
+    error: { code: "auth/anonymous", message: "Cannot delete anonymous", requiresReauth: false }
+  };
 
-  // First attempt to delete
   try {
-    if (__DEV__) {
-      console.log("[deleteCurrentUser] Attempting to delete user...");
-    }
     await deleteUser(user);
-    if (__DEV__) {
-      console.log("[deleteCurrentUser] ✅ User deleted successfully");
-    }
     return { success: true };
-  } catch (error) {
-    const firebaseError = error as { code?: string; message?: string };
-    const requiresReauth = firebaseError.code === "auth/requires-recent-login";
-
-    if (__DEV__) {
-      console.log("[deleteCurrentUser] First delete attempt failed:", {
-        code: firebaseError.code,
-        message: firebaseError.message,
-        requiresReauth,
-      });
-    }
-
-    // If reauthentication is required and autoReauthenticate is enabled OR password is provided
-    if (requiresReauth && (options.autoReauthenticate || options.password)) {
-      if (__DEV__) {
-        console.log("[deleteCurrentUser] Attempting auto-reauthentication...");
-      }
-      const reauthResult = await attemptReauthenticationAndDelete(user, options);
-      if (reauthResult) {
-        if (__DEV__) {
-          console.log("[deleteCurrentUser] Auto-reauth result:", reauthResult);
-        }
-        return reauthResult;
-      }
+  } catch (error: any) {
+    if (error.code === "auth/requires-recent-login" && (options.autoReauthenticate || options.password || options.googleIdToken)) {
+      const reauth = await attemptReauth(user, options);
+      if (reauth) return reauth;
     }
-
     return {
       success: false,
-      error: {
-        code: firebaseError.code || "auth/unknown",
-        message: requiresReauth
-          ? "Please sign in again before deleting your account"
-          : firebaseError.message || "Failed to delete account",
-        requiresReauth,
-      },
+      error: { code: error.code || "auth/failed", message: error.message, requiresReauth: error.code === "auth/requires-recent-login" }
     };
   }
 }
 
-/**
- * Attempt to reauthenticate based on provider and then delete the account
- */
-async function attemptReauthenticationAndDelete(
-  user: User,
-  options: AccountDeletionOptions
-): Promise<AccountDeletionResult | null> {
+async function attemptReauth(user: User, options: AccountDeletionOptions): Promise<AccountDeletionResult | null> {
   const provider = getUserAuthProvider(user);
-
-  if (__DEV__) {
-    console.log("[attemptReauthenticationAndDelete] Provider:", provider);
-  }
-
-  // Handle Apple reauthentication
-  if (provider === "apple.com") {
-    if (__DEV__) {
-      console.log("[attemptReauthenticationAndDelete] Attempting Apple reauthentication...");
-    }
-
-    const reauthResult = await reauthenticateWithApple(user);
-
-    if (__DEV__) {
-      console.log("[attemptReauthenticationAndDelete] Apple reauth result:", reauthResult);
-    }
-
-    if (reauthResult.success) {
-      // Retry deletion after successful reauthentication
-      try {
-        if (__DEV__) {
-          console.log("[attemptReauthenticationAndDelete] Deleting user after Apple reauth...");
-        }
-        await deleteUser(user);
-        if (__DEV__) {
-          console.log("[attemptReauthenticationAndDelete] ✅ User deleted after Apple reauth");
-        }
-        return { success: true };
-      } catch (deleteError) {
-        const firebaseError = deleteError as { code?: string; message?: string };
-        if (__DEV__) {
-          console.log("[attemptReauthenticationAndDelete] ❌ Delete failed after Apple reauth:", firebaseError);
-        }
-        return {
-          success: false,
-          error: {
-            code: firebaseError.code || "auth/deletion-failed-after-reauth",
-            message: firebaseError.message || "Failed to delete account after reauthentication",
-            requiresReauth: false,
-          },
-        };
-      }
-    } else {
-      // Reauthentication failed
-      if (__DEV__) {
-        console.log("[attemptReauthenticationAndDelete] ❌ Apple reauth failed");
-      }
-      return {
-        success: false,
-        error: {
-          code: reauthResult.error?.code || "auth/reauthentication-failed",
-          message: reauthResult.error?.message || "Reauthentication failed",
-          requiresReauth: true,
-        },
-      };
-    }
-  }
-
-  // Handle Google reauthentication (requires ID token from caller)
-  if (provider === "google.com") {
-    // For Google, we need the caller to provide the ID token
-    // This is because we need to trigger Google Sign-In UI which must be done at the presentation layer
-    if (!options.googleIdToken) {
-      return {
-        success: false,
-        error: {
-          code: "auth/google-reauth-required",
-          message: "Please sign in with Google again to delete your account",
-          requiresReauth: true,
-        },
-      };
-    }
-
-    // If we have a Google ID token, reauthenticate with it
-    const { reauthenticateWithGoogle } = await import("./reauthentication.service");
-    const reauthResult = await reauthenticateWithGoogle(user, options.googleIdToken);
-
-    if (reauthResult.success) {
-      try {
-        await deleteUser(user);
-        return { success: true };
-      } catch (deleteError) {
-        const firebaseError = deleteError as { code?: string; message?: string };
-        return {
-          success: false,
-          error: {
-            code: firebaseError.code || "auth/deletion-failed-after-reauth",
-            message: firebaseError.message || "Failed to delete account after reauthentication",
-            requiresReauth: false,
-          },
-        };
-      }
-    } else {
-      return {
-        success: false,
-        error: {
-          code: reauthResult.error?.code || "auth/reauthentication-failed",
-          message: reauthResult.error?.message || "Google reauthentication failed",
-          requiresReauth: true,
-        },
-      };
-    }
-  }
-
-  // Handle Password reauthentication (requires password from caller)
-  if (provider === "password") {
-    if (__DEV__) {
-      console.log("[attemptReauthenticationAndDelete] Password provider detected");
-    }
-
-    // For password, we need the caller to provide the password
-    if (!options.password) {
-      if (__DEV__) {
-        console.log("[attemptReauthenticationAndDelete] No password provided, requesting reauth");
-      }
-      return {
-        success: false,
-        error: {
-          code: "auth/password-reauth-required",
-          message: "Please enter your password to delete your account",
-          requiresReauth: true,
-        },
-      };
-    }
-
-    if (__DEV__) {
-      console.log("[attemptReauthenticationAndDelete] Attempting password reauthentication...");
-    }
-
-    const reauthResult = await reauthenticateWithPassword(user, options.password);
-
-    if (__DEV__) {
-      console.log("[attemptReauthenticationAndDelete] Password reauth result:", reauthResult);
-    }
-
-    if (reauthResult.success) {
-      try {
-        if (__DEV__) {
-          console.log("[attemptReauthenticationAndDelete] Deleting user after password reauth...");
-        }
-        await deleteUser(user);
-        if (__DEV__) {
-          console.log("[attemptReauthenticationAndDelete] ✅ User deleted after password reauth");
-        }
-        return { success: true };
-      } catch (deleteError) {
-        const firebaseError = deleteError as { code?: string; message?: string };
-        if (__DEV__) {
-          console.log("[attemptReauthenticationAndDelete] ❌ Delete failed after password reauth:", firebaseError);
-        }
-        return {
-          success: false,
-          error: {
-            code: firebaseError.code || "auth/deletion-failed-after-reauth",
-            message: firebaseError.message || "Failed to delete account after reauthentication",
-            requiresReauth: false,
-          },
-        };
-      }
-    } else {
-      if (__DEV__) {
-        console.log("[attemptReauthenticationAndDelete] ❌ Password reauth failed");
-      }
-      return {
-        success: false,
-        error: {
-          code: reauthResult.error?.code || "auth/reauthentication-failed",
-          message: reauthResult.error?.message || "Password reauthentication failed",
-          requiresReauth: true,
-        },
-      };
+  let res: { success: boolean, error?: any };
+
+  if (provider === "apple.com") res = await reauthenticateWithApple(user);
+  else if (provider === "google.com") {
+    if (!options.googleIdToken) return { success: false, error: { code: "auth/google-reauth", message: "Google reauth required", requiresReauth: true } };
+    res = await reauthenticateWithGoogle(user, options.googleIdToken);
+  } else if (provider === "password") {
+    if (!options.password) return { success: false, error: { code: "auth/password-reauth", message: "Password required", requiresReauth: true } };
+    res = await reauthenticateWithPassword(user, options.password);
+  } else return null;
+
+  if (res.success) {
+    try {
+      await deleteUser(user);
+      return { success: true };
+    } catch (err: any) {
+      return { success: false, error: { code: err.code || "auth/post-reauth-failed", message: err.message, requiresReauth: false } };
     }
   }
-
-  // For other providers, return null to use the default error handling
-  return null;
+  return { success: false, error: { code: res.error?.code || "auth/reauth-failed", message: res.error?.message, requiresReauth: true } };
 }
 
-/**
- * Delete a specific user (must be the current user)
- */
-export async function deleteUserAccount(
-  user: User
-): Promise<AccountDeletionResult> {
-  if (!user) {
-    return {
-      success: false,
-      error: {
-        code: "auth/no-user",
-        message: "No user provided",
-        requiresReauth: false,
-      },
-    };
-  }
-
-  if (user.isAnonymous) {
-    return {
-      success: false,
-      error: {
-        code: "auth/anonymous-user",
-        message: "Cannot delete anonymous account",
-        requiresReauth: false,
-      },
-    };
-  }
-
+export async function deleteUserAccount(user: User): Promise<AccountDeletionResult> {
+  if (!user || user.isAnonymous) return { success: false, error: { code: "auth/invalid", message: "Invalid user", requiresReauth: false } };
   try {
     await deleteUser(user);
     return { success: true };
-  } catch (error) {
-    const firebaseError = error as { code?: string; message?: string };
-    const requiresReauth = firebaseError.code === "auth/requires-recent-login";
-
-    return {
-      success: false,
-      error: {
-        code: firebaseError.code || "auth/unknown",
-        message: requiresReauth
-          ? "Please sign in again before deleting your account"
-          : firebaseError.message || "Failed to delete account",
-        requiresReauth,
-      },
-    };
+  } catch (error: any) {
+    return { success: false, error: { code: error.code || "auth/failed", message: error.message, requiresReauth: error.code === "auth/requires-recent-login" } };
   }
 }

package/src/auth/infrastructure/services/reauthentication.service.ts

@@ -1,8 +1,6 @@
 /**
  * Reauthentication Service
  * Handles Firebase Auth reauthentication for sensitive operations
- *
- * SOLID: Single Responsibility - Only handles reauthentication
  */
 
 import {
@@ -11,243 +9,85 @@ import {
   OAuthProvider,
   EmailAuthProvider,
   type User,
-  type AuthCredential,
 } from "firebase/auth";
 import * as AppleAuthentication from "expo-apple-authentication";
 import * as Crypto from "expo-crypto";
 import { Platform } from "react-native";
+import type { 
+  ReauthenticationResult, 
+  AuthProviderType, 
+  ReauthCredentialResult 
+} from "./reauthentication.types";
+
+export type { 
+  ReauthenticationResult, 
+  AuthProviderType, 
+  ReauthCredentialResult 
+} from "./reauthentication.types";
 
-export interface ReauthenticationResult {
-  success: boolean;
-  error?: {
-    code: string;
-    message: string;
-  };
-}
-
-export type AuthProviderType = "google.com" | "apple.com" | "password" | "anonymous" | "unknown";
-
-/**
- * Get the primary auth provider for a user
- */
 export function getUserAuthProvider(user: User): AuthProviderType {
-  if (user.isAnonymous) {
-    return "anonymous";
-  }
-
-  const providerData = user.providerData;
-  if (!providerData || providerData.length === 0) {
-    return "unknown";
-  }
-
-  // Check for Google
-  const googleProvider = providerData.find((p) => p.providerId === "google.com");
-  if (googleProvider) {
-    return "google.com";
-  }
-
-  // Check for Apple
-  const appleProvider = providerData.find((p) => p.providerId === "apple.com");
-  if (appleProvider) {
-    return "apple.com";
-  }
-
-  // Check for password
-  const passwordProvider = providerData.find((p) => p.providerId === "password");
-  if (passwordProvider) {
-    return "password";
-  }
-
+  if (user.isAnonymous) return "anonymous";
+  const data = user.providerData;
+  if (!data?.length) return "unknown";
+  if (data.find(p => p.providerId === "google.com")) return "google.com";
+  if (data.find(p => p.providerId === "apple.com")) return "apple.com";
+  if (data.find(p => p.providerId === "password")) return "password";
   return "unknown";
 }
 
-/**
- * Reauthenticate with Google
- */
-export async function reauthenticateWithGoogle(
-  user: User,
-  idToken: string
-): Promise<ReauthenticationResult> {
+export async function reauthenticateWithGoogle(user: User, idToken: string): Promise<ReauthenticationResult> {
   try {
-    const credential = GoogleAuthProvider.credential(idToken);
-    await reauthenticateWithCredential(user, credential);
+    await reauthenticateWithCredential(user, GoogleAuthProvider.credential(idToken));
     return { success: true };
-  } catch (error) {
-    const firebaseError = error as { code?: string; message?: string };
-    return {
-      success: false,
-      error: {
-        code: firebaseError.code || "auth/reauthentication-failed",
-        message: firebaseError.message || "Google reauthentication failed",
-      },
-    };
+  } catch (error: any) {
+    return { success: false, error: { code: error.code || "auth/failed", message: error.message } };
   }
 }
 
-/**
- * Reauthenticate with Email/Password
- */
-export async function reauthenticateWithPassword(
-  user: User,
-  password: string
-): Promise<ReauthenticationResult> {
+export async function reauthenticateWithPassword(user: User, pass: string): Promise<ReauthenticationResult> {
+  if (!user.email) return { success: false, error: { code: "auth/no-email", message: "User has no email" } };
   try {
-    if (!user.email) {
-      return {
-        success: false,
-        error: {
-          code: "auth/no-email",
-          message: "User has no email address",
-        },
-      };
-    }
-
-    const credential = EmailAuthProvider.credential(user.email, password);
-    await reauthenticateWithCredential(user, credential);
+    await reauthenticateWithCredential(user, EmailAuthProvider.credential(user.email, pass));
     return { success: true };
-  } catch (error) {
-    const firebaseError = error as { code?: string; message?: string };
-    return {
-      success: false,
-      error: {
-        code: firebaseError.code || "auth/reauthentication-failed",
-        message: firebaseError.message || "Password reauthentication failed",
-      },
-    };
+  } catch (error: any) {
+    return { success: false, error: { code: error.code || "auth/failed", message: error.message } };
   }
 }
 
-/**
- * Generate a random nonce for Apple Sign-In security
- */
-async function generateNonce(length: number = 32): Promise<string> {
-  const randomBytes = await Crypto.getRandomBytesAsync(length);
+async function generateNonce(len: number = 32): Promise<string> {
+  const bytes = await Crypto.getRandomBytesAsync(len);
   const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
-  let result = "";
-
-  for (let i = 0; i < randomBytes.length; i++) {
-    const byte = randomBytes[i];
-    if (byte !== undefined) {
-      result += chars.charAt(byte % chars.length);
-    }
-  }
-
-  return result;
+  return Array.from(bytes).map(b => chars.charAt(b % chars.length)).join("");
 }
 
-/**
- * Reauthenticate with Apple
- * Returns the credential that can be used for reauthentication
- */
-export async function getAppleReauthCredential(): Promise<{
-  success: boolean;
-  credential?: AuthCredential;
-  error?: { code: string; message: string };
-}> {
-  if (Platform.OS !== "ios") {
-    return {
-      success: false,
-      error: {
-        code: "auth/platform-not-supported",
-        message: "Apple Sign-In is only available on iOS",
-      },
-    };
-  }
-
+export async function getAppleReauthCredential(): Promise<ReauthCredentialResult> {
+  if (Platform.OS !== "ios") return { success: false, error: { code: "auth/ios-only", message: "iOS only" } };
   try {
-    const isAvailable = await AppleAuthentication.isAvailableAsync();
-    if (!isAvailable) {
-      return {
-        success: false,
-        error: {
-          code: "auth/apple-signin-unavailable",
-          message: "Apple Sign-In is not available on this device",
-        },
-      };
-    }
+    if (!(await AppleAuthentication.isAvailableAsync())) 
+      return { success: false, error: { code: "auth/unavailable", message: "Unavailable" } };
 
-    // Generate nonce
     const nonce = await generateNonce();
-    const hashedNonce = await Crypto.digestStringAsync(
-      Crypto.CryptoDigestAlgorithm.SHA256,
-      nonce
-    );
-
-    // Request Apple Sign-In
-    const appleCredential = await AppleAuthentication.signInAsync({
-      requestedScopes: [
-        AppleAuthentication.AppleAuthenticationScope.FULL_NAME,
-        AppleAuthentication.AppleAuthenticationScope.EMAIL,
-      ],
-      nonce: hashedNonce,
+    const hashed = await Crypto.digestStringAsync(Crypto.CryptoDigestAlgorithm.SHA256, nonce);
+    const apple = await AppleAuthentication.signInAsync({
+      requestedScopes: [AppleAuthentication.AppleAuthenticationScope.FULL_NAME, AppleAuthentication.AppleAuthenticationScope.EMAIL],
+      nonce: hashed,
     });
 
-    if (!appleCredential.identityToken) {
-      return {
-        success: false,
-        error: {
-          code: "auth/no-identity-token",
-          message: "No identity token received from Apple",
-        },
-      };
-    }
-
-    // Create Firebase credential
-    const provider = new OAuthProvider("apple.com");
-    const credential = provider.credential({
-      idToken: appleCredential.identityToken,
-      rawNonce: nonce,
-    });
-
-    return { success: true, credential };
-  } catch (error) {
-    if (error instanceof Error && error.message.includes("ERR_CANCELED")) {
-      return {
-        success: false,
-        error: {
-          code: "auth/cancelled",
-          message: "Apple Sign-In was cancelled",
-        },
-      };
-    }
-
-    return {
-      success: false,
-      error: {
-        code: "auth/apple-reauthentication-failed",
-        message: error instanceof Error ? error.message : "Apple reauthentication failed",
-      },
-    };
+    if (!apple.identityToken) return { success: false, error: { code: "auth/no-token", message: "No token" } };
+    return { success: true, credential: new OAuthProvider("apple.com").credential({ idToken: apple.identityToken, rawNonce: nonce }) };
+  } catch (error: any) {
+    const code = error.message?.includes("ERR_CANCELED") ? "auth/cancelled" : "auth/failed";
+    return { success: false, error: { code, message: error.message } };
   }
 }
 
-/**
- * Reauthenticate with Apple
- */
 export async function reauthenticateWithApple(user: User): Promise<ReauthenticationResult> {
-  const result = await getAppleReauthCredential();
-
-  if (!result.success || !result.credential) {
-    return {
-      success: false,
-      error: result.error || {
-        code: "auth/no-credential",
-        message: "Failed to get Apple credential",
-      },
-    };
-  }
-
+  const res = await getAppleReauthCredential();
+  if (!res.success || !res.credential) return { success: false, error: res.error };
   try {
-    await reauthenticateWithCredential(user, result.credential);
+    await reauthenticateWithCredential(user, res.credential);
     return { success: true };
-  } catch (error) {
-    const firebaseError = error as { code?: string; message?: string };
-    return {
-      success: false,
-      error: {
-        code: firebaseError.code || "auth/reauthentication-failed",
-        message: firebaseError.message || "Apple reauthentication failed",
-      },
-    };
+  } catch (error: any) {
+    return { success: false, error: { code: error.code || "auth/failed", message: error.message } };
   }
 }

package/src/auth/infrastructure/services/reauthentication.types.ts

@@ -0,0 +1,39 @@
+/**
+ * Reauthentication Types
+ */
+
+import type { AuthCredential } from "firebase/auth";
+
+export interface ReauthenticationResult {
+  success: boolean;
+  error?: {
+    code: string;
+    message: string;
+  };
+}
+
+export type AuthProviderType = "google.com" | "apple.com" | "password" | "anonymous" | "unknown";
+
+export interface ReauthCredentialResult {
+  success: boolean;
+  credential?: AuthCredential;
+  error?: { code: string; message: string };
+}
+
+export interface AccountDeletionResult {
+  success: boolean;
+  error?: {
+    code: string;
+    message: string;
+    requiresReauth: boolean;
+  };
+}
+
+export interface AccountDeletionOptions {
+  /** Google ID token for reauthentication */
+  googleIdToken?: string;
+  /** Password for reauthentication */
+  password?: string;
+  /** Attempt Apple reauth automatically */
+  autoReauthenticate?: boolean;
+}