@umituz/react-native-auth 3.4.23 → 3.4.24

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-auth",
-  "version": "3.4.23",
+  "version": "3.4.24",
   "description": "Authentication service for React Native apps - Secure, type-safe, and production-ready. Provider-agnostic design with dependency injection, configurable validation, and comprehensive error handling.",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/infrastructure/services/UserDocumentService.ts

@@ -11,6 +11,12 @@ import type {
   UserDocumentConfig,
   UserDocumentExtras,
 } from "./UserDocument.types";
+import {
+  getSignUpMethod,
+  buildBaseData,
+  buildCreateData,
+  buildUpdateData,
+} from "../utils/userDocumentBuilder.util";
 
 export type {
   UserDocumentUser,
@@ -26,90 +32,6 @@ export function configureUserDocumentService(config: UserDocumentConfig): void {
   userDocumentConfig = { ...config };
 }
 
-function getSignUpMethod(user: UserDocumentUser): string | undefined {
-  if (user.isAnonymous) return "anonymous";
-  if (user.email) {
-    const providerData = (
-      user as unknown as { providerData?: { providerId: string }[] }
-    ).providerData;
-    if (providerData && providerData.length > 0) {
-      const providerId = providerData[0].providerId;
-      if (providerId === "google.com") return "google";
-      if (providerId === "apple.com") return "apple";
-      if (providerId === "password") return "email";
-    }
-    return "email";
-  }
-  return undefined;
-}
-
-function buildBaseData(
-  user: UserDocumentUser,
-  extras?: UserDocumentExtras,
-): Record<string, unknown> {
-  const data: Record<string, unknown> = {
-    displayName: user.displayName,
-    email: user.email,
-    photoURL: user.photoURL,
-    isAnonymous: user.isAnonymous,
-  };
-
-  const fields: (keyof UserDocumentExtras)[] = [
-    'deviceId', 'platform', 'deviceModel', 'deviceBrand', 
-    'osVersion', 'appVersion', 'buildNumber', 'locale', 'timezone'
-  ];
-
-  fields.forEach(field => {
-    const val = extras?.[field];
-    if (val) data[field] = val;
-  });
-
-  return data;
-}
-
-function buildCreateData(
-  baseData: Record<string, unknown>,
-  extras?: UserDocumentExtras,
-): Record<string, unknown> {
-  const createData: Record<string, unknown> = {
-    ...baseData,
-    ...userDocumentConfig.extraFields,
-    createdAt: serverTimestamp(),
-    updatedAt: serverTimestamp(),
-    lastLoginAt: serverTimestamp(),
-  };
-
-  if (extras?.previousAnonymousUserId) {
-    createData.previousAnonymousUserId = extras.previousAnonymousUserId;
-    createData.convertedFromAnonymous = true;
-    createData.convertedAt = serverTimestamp();
-  }
-
-  if (extras?.signUpMethod) createData.signUpMethod = extras.signUpMethod;
-
-  return createData;
-}
-
-function buildUpdateData(
-  baseData: Record<string, unknown>,
-  extras?: UserDocumentExtras,
-): Record<string, unknown> {
-  const updateData: Record<string, unknown> = {
-    ...baseData,
-    lastLoginAt: serverTimestamp(),
-    updatedAt: serverTimestamp(),
-  };
-
-  if (extras?.previousAnonymousUserId) {
-    updateData.previousAnonymousUserId = extras.previousAnonymousUserId;
-    updateData.convertedFromAnonymous = true;
-    updateData.convertedAt = serverTimestamp();
-    if (extras?.signUpMethod) updateData.signUpMethod = extras.signUpMethod;
-  }
-
-  return updateData;
-}
-
 export async function ensureUserDocument(
   user: UserDocumentUser | User,
   extras?: UserDocumentExtras,
@@ -131,8 +53,8 @@ export async function ensureUserDocument(
     const userDoc = await getDoc(userRef);
     const baseData = buildBaseData(user, allExtras);
 
-    const docData = !userDoc.exists() 
-      ? buildCreateData(baseData, allExtras) 
+    const docData = !userDoc.exists()
+      ? buildCreateData(baseData, userDocumentConfig.extraFields, allExtras)
       : buildUpdateData(baseData, allExtras);
 
     await setDoc(userRef, docData, { merge: true });

package/src/infrastructure/utils/userDocumentBuilder.util.ts

@@ -0,0 +1,107 @@
+/**
+ * User Document Builder Utility
+ * Builds user document data for Firestore
+ */
+
+import { serverTimestamp } from "firebase/firestore";
+import type {
+  UserDocumentUser,
+  UserDocumentExtras,
+} from "../../infrastructure/services/UserDocument.types";
+
+/**
+ * Gets the sign-up method from user provider data
+ */
+export function getSignUpMethod(user: UserDocumentUser): string | undefined {
+  if (user.isAnonymous) return "anonymous";
+  if (user.email) {
+    const providerData = (
+      user as unknown as { providerData?: { providerId: string }[] }
+    ).providerData;
+    if (providerData && providerData.length > 0) {
+      const providerId = providerData[0].providerId;
+      if (providerId === "google.com") return "google";
+      if (providerId === "apple.com") return "apple";
+      if (providerId === "password") return "email";
+    }
+    return "email";
+  }
+  return undefined;
+}
+
+/**
+ * Builds base user data from user object and extras
+ */
+export function buildBaseData(
+  user: UserDocumentUser,
+  extras?: UserDocumentExtras,
+): Record<string, unknown> {
+  const data: Record<string, unknown> = {
+    displayName: user.displayName,
+    email: user.email,
+    photoURL: user.photoURL,
+    isAnonymous: user.isAnonymous,
+  };
+
+  const fields: (keyof UserDocumentExtras)[] = [
+    'deviceId', 'platform', 'deviceModel', 'deviceBrand',
+    'osVersion', 'appVersion', 'buildNumber', 'locale', 'timezone'
+  ];
+
+  fields.forEach(field => {
+    const val = extras?.[field];
+    if (val) data[field] = val;
+  });
+
+  return data;
+}
+
+/**
+ * Builds user document data for creation
+ */
+export function buildCreateData(
+  baseData: Record<string, unknown>,
+  extraFields: Record<string, unknown> | undefined,
+  extras?: UserDocumentExtras,
+): Record<string, unknown> {
+  const createData: Record<string, unknown> = {
+    ...baseData,
+    ...extraFields,
+    createdAt: serverTimestamp(),
+    updatedAt: serverTimestamp(),
+    lastLoginAt: serverTimestamp(),
+  };
+
+  if (extras?.previousAnonymousUserId) {
+    createData.previousAnonymousUserId = extras.previousAnonymousUserId;
+    createData.convertedFromAnonymous = true;
+    createData.convertedAt = serverTimestamp();
+  }
+
+  if (extras?.signUpMethod) createData.signUpMethod = extras.signUpMethod;
+
+  return createData;
+}
+
+/**
+ * Builds user document data for update
+ */
+export function buildUpdateData(
+  baseData: Record<string, unknown>,
+  extras?: UserDocumentExtras,
+): Record<string, unknown> {
+  const updateData: Record<string, unknown> = {
+    ...baseData,
+    lastLoginAt: serverTimestamp(),
+    updatedAt: serverTimestamp(),
+  };
+
+  if (extras?.previousAnonymousUserId) {
+    updateData.previousAnonymousUserId = extras.previousAnonymousUserId;
+    updateData.convertedFromAnonymous = true;
+    updateData.convertedAt = serverTimestamp();
+    if (extras?.signUpMethod) updateData.signUpMethod = extras.signUpMethod;
+  }
+
+  return updateData;
+}

package/src/presentation/hooks/useAccountManagement.ts

@@ -4,10 +4,9 @@
  * Generic hook - reauthentication is handled via callback from calling app
  */
 
-/* eslint-disable @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access, @typescript-eslint/no-unsafe-argument */
 import { useCallback, useState } from "react";
 import { useAuth } from "./useAuth";
-import { deleteCurrentUser } from "@umituz/react-native-firebase";
+import { handleAccountDeletion } from "../utils/accountDeleteHandler.util";
 
 export interface UseAccountManagementOptions {
   /**
@@ -60,110 +59,7 @@ export const useAccountManagement = (
     setIsDeletingAccount(true);
 
     try {
-      if (__DEV__) {
-        console.log("[useAccountManagement] Calling deleteCurrentUser with autoReauthenticate: true");
-      }
-
-      const result = await deleteCurrentUser({ autoReauthenticate: true });
-
-      if (__DEV__) {
-        console.log("[useAccountManagement] First delete attempt result:", result);
-      }
-
-      if (result.success) {
-        if (__DEV__) {
-          console.log("[useAccountManagement] ✅ Delete successful on first attempt");
-        }
-        return;
-      }
-
-      // If reauthentication required
-      if (result.error?.requiresReauth) {
-        // Handle password-based reauth
-        if (result.error.code === "auth/password-reauth-required" && onPasswordRequired) {
-          if (__DEV__) {
-            console.log("[useAccountManagement] Password reauth required, prompting user");
-          }
-
-          const password = await onPasswordRequired();
-
-          if (password) {
-            if (__DEV__) {
-              console.log("[useAccountManagement] Password provided, retrying delete");
-            }
-
-            const retryResult = await deleteCurrentUser({
-              autoReauthenticate: false,
-              password,
-            });
-
-            if (__DEV__) {
-              console.log("[useAccountManagement] Retry delete with password result:", retryResult);
-            }
-
-            if (retryResult.success) {
-              if (__DEV__) {
-                console.log("[useAccountManagement] ✅ Delete successful after password reauth");
-              }
-              return;
-            }
-
-            if (retryResult.error) {
-              throw new Error(retryResult.error.message);
-            }
-          } else {
-            if (__DEV__) {
-              console.log("[useAccountManagement] Password prompt cancelled");
-            }
-            throw new Error("Password required to delete account");
-          }
-        }
-
-        // Handle Google/Apple reauth
-        if (onReauthRequired) {
-          if (__DEV__) {
-            console.log("[useAccountManagement] Reauth required, calling onReauthRequired callback");
-          }
-
-          const reauthSuccess = await onReauthRequired();
-
-          if (__DEV__) {
-            console.log("[useAccountManagement] onReauthRequired result:", reauthSuccess);
-          }
-
-          if (reauthSuccess) {
-            if (__DEV__) {
-              console.log("[useAccountManagement] Retrying delete after reauth");
-            }
-
-            const retryResult = await deleteCurrentUser({
-              autoReauthenticate: false,
-            });
-
-            if (__DEV__) {
-              console.log("[useAccountManagement] Retry delete result:", retryResult);
-            }
-
-            if (retryResult.success) {
-              if (__DEV__) {
-                console.log("[useAccountManagement] ✅ Delete successful after reauth");
-              }
-              return;
-            }
-
-            if (retryResult.error) {
-              throw new Error(retryResult.error.message);
-            }
-          }
-        }
-      }
-
-      if (result.error) {
-        if (__DEV__) {
-          console.log("[useAccountManagement] ❌ Delete failed:", result.error);
-        }
-        throw new Error(result.error.message);
-      }
+      await handleAccountDeletion({ onReauthRequired, onPasswordRequired });
     } finally {
       setIsDeletingAccount(false);
     }

package/src/presentation/utils/accountDeleteHandler.util.ts

@@ -0,0 +1,147 @@
+/**
+ * Account Delete Handler Utility
+ * Handles reauthentication flow for account deletion
+ */
+
+import { deleteCurrentUser } from "@umituz/react-native-firebase";
+
+export interface DeleteAccountCallbacks {
+  onReauthRequired?: () => Promise<boolean>;
+  onPasswordRequired?: () => Promise<string | null>;
+}
+
+export interface DeleteAccountOptions {
+  autoReauthenticate: boolean;
+  password?: string;
+}
+
+/**
+ * Handles account deletion with reauthentication retry logic
+ */
+export async function handleAccountDeletion(
+  callbacks: DeleteAccountCallbacks
+): Promise<void> {
+  if (__DEV__) {
+    console.log("[AccountDeleteHandler] Starting deletion with auto-reauthenticate");
+  }
+
+  const result = await deleteCurrentUser({ autoReauthenticate: true });
+
+  if (__DEV__) {
+    console.log("[AccountDeleteHandler] First attempt result:", result);
+  }
+
+  if (result.success) {
+    if (__DEV__) {
+      console.log("[AccountDeleteHandler] Delete successful");
+    }
+    return;
+  }
+
+  if (result.error?.requiresReauth) {
+    await handleReauthentication(result, callbacks);
+    return;
+  }
+
+  if (result.error) {
+    if (__DEV__) {
+      console.log("[AccountDeleteHandler] Delete failed:", result.error);
+    }
+    throw new Error(result.error.message);
+  }
+}
+
+async function handleReauthentication(
+  initialResult: Awaited<ReturnType<typeof deleteCurrentUser>>,
+  callbacks: DeleteAccountCallbacks
+): Promise<void> {
+  const { onReauthRequired, onPasswordRequired } = callbacks;
+
+  // Handle password reauth
+  if (initialResult.error?.code === "auth/password-reauth-required" && onPasswordRequired) {
+    await retryWithPassword(onPasswordRequired);
+    return;
+  }
+
+  // Handle social auth reauth
+  if (onReauthRequired) {
+    await retryWithSocialAuth(onReauthRequired);
+    return;
+  }
+}
+
+async function retryWithPassword(onPasswordRequired: () => Promise<string | null>): Promise<void> {
+  if (__DEV__) {
+    console.log("[AccountDeleteHandler] Prompting for password");
+  }
+
+  const password = await onPasswordRequired();
+
+  if (!password) {
+    if (__DEV__) {
+      console.log("[AccountDeleteHandler] Password prompt cancelled");
+    }
+    throw new Error("Password required to delete account");
+  }
+
+  if (__DEV__) {
+    console.log("[AccountDeleteHandler] Retrying with password");
+  }
+
+  const result = await deleteCurrentUser({
+    autoReauthenticate: false,
+    password,
+  });
+
+  if (__DEV__) {
+    console.log("[AccountDeleteHandler] Password retry result:", result);
+  }
+
+  if (result.success) {
+    if (__DEV__) {
+      console.log("[AccountDeleteHandler] Delete successful after password reauth");
+    }
+    return;
+  }
+
+  if (result.error) {
+    throw new Error(result.error.message);
+  }
+}
+
+async function retryWithSocialAuth(onReauthRequired: () => Promise<boolean>): Promise<void> {
+  if (__DEV__) {
+    console.log("[AccountDeleteHandler] Requesting social auth reauth");
+  }
+
+  const reauthSuccess = await onReauthRequired();
+
+  if (__DEV__) {
+    console.log("[AccountDeleteHandler] Reauth result:", reauthSuccess);
+  }
+
+  if (!reauthSuccess) {
+    throw new Error("Reauthentication required to delete account");
+  }
+
+  if (__DEV__) {
+    console.log("[AccountDeleteHandler] Retrying deletion after reauth");
+  }
+
+  const result = await deleteCurrentUser({ autoReauthenticate: false });
+
+  if (__DEV__) {
+    console.log("[AccountDeleteHandler] Reauth retry result:", result);
+  }
+
+  if (result.success) {
+    if (__DEV__) {
+      console.log("[AccountDeleteHandler] Delete successful after reauth");
+    }
+    return;
+  }
+
+  if (result.error) {
+    throw new Error(result.error.message);
+  }
+}