@umituz/react-native-firebase 1.13.48 → 1.13.50

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" } };
   }
 }