@umituz/react-native-auth 3.4.22 → 3.4.24

package/src/infrastructure/utils/AuthValidation.ts

@@ -1,38 +1,17 @@
-/**
- * Auth Validation Utilities
- * Single Responsibility: Email and password validation for authentication
- */
-
 import type { PasswordConfig } from "../../domain/value-objects/AuthConfig";
 import { getAuthPackage } from "../services/AuthPackage";
 
-export interface ValidationResult {
-  isValid: boolean;
-  error?: string; // This should be a localization key
-}
-
-export interface PasswordStrengthResult extends ValidationResult {
-  requirements: PasswordRequirements;
-}
-
+export interface ValidationResult { isValid: boolean; error?: string; }
+export interface PasswordStrengthResult extends ValidationResult { requirements: PasswordRequirements; }
 export interface PasswordRequirements {
-  hasMinLength: boolean;
-  hasUppercase: boolean;
-  hasLowercase: boolean;
-  hasNumber: boolean;
-  hasSpecialChar: boolean;
+  hasMinLength: boolean; hasUppercase: boolean; hasLowercase: boolean; hasNumber: boolean; hasSpecialChar: boolean;
 }
-
 export interface ValidationConfig {
-  emailRegex: RegExp;
-  uppercaseRegex: RegExp;
-  lowercaseRegex: RegExp;
-  numberRegex: RegExp;
-  specialCharRegex: RegExp;
-  displayNameMinLength: number;
+  emailRegex: RegExp; uppercaseRegex: RegExp; lowercaseRegex: RegExp;
+  numberRegex: RegExp; specialCharRegex: RegExp; displayNameMinLength: number;
 }
 
-const DEFAULT_VALIDATION_CONFIG: ValidationConfig = {
+const DEFAULT_VAL_CONFIG: ValidationConfig = {
   emailRegex: /^[^\s@]+@[^\s@]+\.[^\s@]+$/,
   uppercaseRegex: /[A-Z]/,
   lowercaseRegex: /[a-z]/,
@@ -41,155 +20,57 @@ const DEFAULT_VALIDATION_CONFIG: ValidationConfig = {
   displayNameMinLength: 2,
 };
 
-function getValidationConfig(): ValidationConfig {
-  const packageConfig = getAuthPackage()?.getConfig();
+function getValConfig(): ValidationConfig {
+  const p = getAuthPackage()?.getConfig();
   return {
-    emailRegex: packageConfig?.validation.emailRegex || DEFAULT_VALIDATION_CONFIG.emailRegex,
-    uppercaseRegex: DEFAULT_VALIDATION_CONFIG.uppercaseRegex,
-    lowercaseRegex: DEFAULT_VALIDATION_CONFIG.lowercaseRegex,
-    numberRegex: DEFAULT_VALIDATION_CONFIG.numberRegex,
-    specialCharRegex: DEFAULT_VALIDATION_CONFIG.specialCharRegex,
-    displayNameMinLength: DEFAULT_VALIDATION_CONFIG.displayNameMinLength,
+    emailRegex: p?.validation.emailRegex || DEFAULT_VAL_CONFIG.emailRegex,
+    uppercaseRegex: DEFAULT_VAL_CONFIG.uppercaseRegex,
+    lowercaseRegex: DEFAULT_VAL_CONFIG.lowercaseRegex,
+    numberRegex: DEFAULT_VAL_CONFIG.numberRegex,
+    specialCharRegex: DEFAULT_VAL_CONFIG.specialCharRegex,
+    displayNameMinLength: DEFAULT_VAL_CONFIG.displayNameMinLength,
   };
 }
 
-/**
- * Validate email format
- */
 export function validateEmail(email: string): ValidationResult {
-  if (!email || email.trim() === "") {
-    return { isValid: false, error: "auth.validation.emailRequired" };
-  }
-
-  const config = getValidationConfig();
-  if (!config.emailRegex.test(email.trim())) {
-    return { isValid: false, error: "auth.validation.invalidEmail" };
-  }
-
+  if (!email || email.trim() === "") return { isValid: false, error: "auth.validation.emailRequired" };
+  if (!getValConfig().emailRegex.test(email.trim())) return { isValid: false, error: "auth.validation.invalidEmail" };
   return { isValid: true };
 }
 
-/**
- * Validate password for login - only checks if password is provided
- * No strength requirements for login (existing users may have old passwords)
- */
 export function validatePasswordForLogin(password: string): ValidationResult {
-  if (!password || password.length === 0) {
-    return { isValid: false, error: "auth.validation.passwordRequired" };
-  }
-
+  if (!password || password.length === 0) return { isValid: false, error: "auth.validation.passwordRequired" };
   return { isValid: true };
 }
 
-/**
- * Validate password strength for registration
- * Returns detailed requirements for UI feedback
- */
-export function validatePasswordForRegister(
-  password: string,
-  config: PasswordConfig
-): PasswordStrengthResult {
-  const validationConfig = getValidationConfig();
-  const requirements: PasswordRequirements = {
+export function validatePasswordForRegister(password: string, config: PasswordConfig): PasswordStrengthResult {
+  const v = getValConfig();
+  const req: PasswordRequirements = {
     hasMinLength: password.length >= config.minLength,
-    hasUppercase: !config.requireUppercase || validationConfig.uppercaseRegex.test(password),
-    hasLowercase: !config.requireLowercase || validationConfig.lowercaseRegex.test(password),
-    hasNumber: !config.requireNumber || validationConfig.numberRegex.test(password),
-    hasSpecialChar:
-      !config.requireSpecialChar || validationConfig.specialCharRegex.test(password),
+    hasUppercase: !config.requireUppercase || v.uppercaseRegex.test(password),
+    hasLowercase: !config.requireLowercase || v.lowercaseRegex.test(password),
+    hasNumber: !config.requireNumber || v.numberRegex.test(password),
+    hasSpecialChar: !config.requireSpecialChar || v.specialCharRegex.test(password),
   };
 
-  if (!password || password.length === 0) {
-    return {
-      isValid: false,
-      error: "auth.validation.passwordRequired",
-      requirements,
-    };
-  }
-
-  if (!requirements.hasMinLength) {
-    return {
-      isValid: false,
-      error: "auth.validation.passwordTooShort",
-      requirements,
-    };
-  }
-
-  if (config.requireUppercase && !validationConfig.uppercaseRegex.test(password)) {
-    return {
-      isValid: false,
-      error: "auth.validation.passwordRequireUppercase",
-      requirements,
-    };
-  }
+  if (!password) return { isValid: false, error: "auth.validation.passwordRequired", requirements: req };
+  if (!req.hasMinLength) return { isValid: false, error: "auth.validation.passwordTooShort", requirements: req };
+  if (config.requireUppercase && !req.hasUppercase) return { isValid: false, error: "auth.validation.passwordRequireUppercase", requirements: req };
+  if (config.requireLowercase && !req.hasLowercase) return { isValid: false, error: "auth.validation.passwordRequireLowercase", requirements: req };
+  if (config.requireNumber && !req.hasNumber) return { isValid: false, error: "auth.validation.passwordRequireNumber", requirements: req };
+  if (config.requireSpecialChar && !req.hasSpecialChar) return { isValid: false, error: "auth.validation.passwordRequireSpecialChar", requirements: req };
 
-  if (config.requireLowercase && !validationConfig.lowercaseRegex.test(password)) {
-    return {
-      isValid: false,
-      error: "auth.validation.passwordRequireLowercase",
-      requirements,
-    };
-  }
-
-  if (config.requireNumber && !validationConfig.numberRegex.test(password)) {
-    return {
-      isValid: false,
-      error: "auth.validation.passwordRequireNumber",
-      requirements,
-    };
-  }
-
-  if (config.requireSpecialChar && !validationConfig.specialCharRegex.test(password)) {
-    return {
-      isValid: false,
-      error: "auth.validation.passwordRequireSpecialChar",
-      requirements,
-    };
-  }
-
-  return { isValid: true, requirements };
+  return { isValid: true, requirements: req };
 }
 
-/**
- * Validate password confirmation
- */
-export function validatePasswordConfirmation(
-  password: string,
-  confirmPassword: string
-): ValidationResult {
-  if (!confirmPassword) {
-    return { isValid: false, error: "auth.validation.confirmPasswordRequired" };
-  }
-
-  if (password !== confirmPassword) {
-    return { isValid: false, error: "auth.validation.passwordsDoNotMatch" };
-  }
-
+export function validatePasswordConfirmation(password: string, confirm: string): ValidationResult {
+  if (!confirm) return { isValid: false, error: "auth.validation.confirmPasswordRequired" };
+  if (password !== confirm) return { isValid: false, error: "auth.validation.passwordsDoNotMatch" };
   return { isValid: true };
 }
 
-/**
- * Validate display name
- */
-export function validateDisplayName(
-  displayName: string,
-  minLength?: number
-): ValidationResult {
-  if (!displayName || displayName.trim() === "") {
-    return { isValid: false, error: "auth.validation.nameRequired" };
-  }
-
-  const config = getValidationConfig();
-  const actualMinLength = minLength ?? config.displayNameMinLength;
-
-  if (displayName.trim().length < actualMinLength) {
-    return {
-      isValid: false,
-      error: "auth.validation.nameTooShort",
-    };
-  }
-
+export function validateDisplayName(name: string, minLength?: number): ValidationResult {
+  if (!name || name.trim() === "") return { isValid: false, error: "auth.validation.nameRequired" };
+  if (name.trim().length < (minLength ?? getValConfig().displayNameMinLength)) return { isValid: false, error: "auth.validation.nameTooShort" };
   return { isValid: 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);
+  }
+}