@umituz/react-native-auth 3.6.71 → 3.6.73

package/src/presentation/stores/initializeAuthListener.ts

@@ -4,18 +4,22 @@
  * Uses onIdTokenChanged for profile updates (displayName, email)
  */
 
-import { onIdTokenChanged } from "firebase/auth";
 import { getFirebaseAuth } from "@umituz/react-native-firebase";
 import { useAuthStore } from "./authStore";
-import { getAuthService } from "../../infrastructure/services/AuthService";
 import type { AuthListenerOptions } from "../../types/auth-store.types";
-import { createAnonymousSignInHandler } from "../../infrastructure/utils/listener/anonymousSignInHandler";
-
-let listenerInitialized = false;
-let listenerRefCount = 0;
-let firebaseUnsubscribe: (() => void) | null = null;
-let anonymousSignInInProgress = false; // Prevent race conditions
-let initializationInProgress = false; // Prevent duplicate initialization
+import {
+  handleExistingInitialization,
+  handleInitializationInProgress,
+  handleNoFirebaseAuth,
+  setupAuthListener,
+  completeListenerSetup,
+} from "../../infrastructure/utils/listener/listenerLifecycle.util";
+import {
+  isInitializationInProgress,
+  isListenerInitialized,
+  resetListenerState,
+  decrementRefCount,
+} from "../../infrastructure/utils/listener/listenerState.util";
 
 /**
  * Initialize Firebase auth listener
@@ -26,160 +30,33 @@ export function initializeAuthListener(
 ): () => void {
   const { autoAnonymousSignIn = true, onAuthStateChange } = options;
 
-  if (__DEV__) {
-    console.log("[AuthListener] initializeAuthListener called:", {
-      autoAnonymousSignIn,
-      alreadyInitialized: listenerInitialized,
-      initializationInProgress,
-    });
+  // Prevent duplicate initialization
+  if (isInitializationInProgress()) {
+    return handleInitializationInProgress();
   }
 
-  // Prevent duplicate initialization - return existing unsubscribe if already initializing
-  if (initializationInProgress) {
-    if (__DEV__) {
-      console.warn("[AuthListener] Initialization already in progress, returning existing unsubscribe");
-    }
-    return () => {
-      // No-op - will be handled by the initial initialization
-    };
+  // If already initialized, increment ref count and return unsubscribe
+  if (isListenerInitialized()) {
+    return handleExistingInitialization()!;
   }
 
-  // If already initialized, increment ref count and return unsubscribe that decrements
-  if (listenerInitialized) {
-    listenerRefCount++;
-    if (__DEV__) {
-      console.log("[AuthListener] Already initialized, incrementing ref count:", listenerRefCount);
-    }
-    // Return function that decrements ref count
-    return () => {
-      listenerRefCount--;
-      if (__DEV__) {
-        console.log("[AuthListener] Ref count decremented:", listenerRefCount);
-      }
-      // Only cleanup when all subscribers unsubscribe
-      if (listenerRefCount <= 0 && firebaseUnsubscribe) {
-        if (__DEV__) {
-          console.log("[AuthListener] Last subscriber, cleaning up");
-        }
-        firebaseUnsubscribe();
-        firebaseUnsubscribe = null;
-        listenerInitialized = false;
-        listenerRefCount = 0;
-        anonymousSignInInProgress = false;
-      }
-    };
-  }
-
-  // Mark initialization as in progress
-  initializationInProgress = true;
-
   const auth = getFirebaseAuth();
   const store = useAuthStore.getState();
 
   if (!auth) {
-    if (__DEV__) {
-      console.log("[AuthListener] No Firebase auth, marking initialized");
-    }
-    initializationInProgress = false;
-    store.setLoading(false);
-    store.setInitialized(true);
-    return () => {};
+    return handleNoFirebaseAuth(store);
   }
 
-  listenerInitialized = true;
-  listenerRefCount = 1;
-
-  // Initialize listener first, then check anonymous mode
-  // This prevents race conditions where the listener fires before we set up state
-  const service = getAuthService();
-  if (service) {
-    const isAnonymous = service.getIsAnonymousMode();
-    if (__DEV__) {
-      console.log("[AuthListener] Service isAnonymousMode:", isAnonymous);
-    }
-    // Set anonymous mode flag before setting up listener
-    // This ensures consistent state when listener first fires
-    if (isAnonymous) {
-      store.setIsAnonymous(true);
-    }
-  }
-
-  firebaseUnsubscribe = onIdTokenChanged(auth, (user) => {
-    if (__DEV__) {
-      console.log("[AuthListener] onIdTokenChanged:", {
-        uid: user?.uid ?? null,
-        isAnonymous: user?.isAnonymous ?? null,
-        email: user?.email ?? null,
-        displayName: user?.displayName ?? null,
-      });
-    }
-
-    if (!user && autoAnonymousSignIn) {
-      // Prevent race condition: only one anonymous sign-in at a time
-      if (anonymousSignInInProgress) {
-        if (__DEV__) {
-          console.log("[AuthListener] Anonymous sign-in already in progress, skipping");
-        }
-        store.setFirebaseUser(null);
-        return;
-      }
-
-      if (__DEV__) {
-        console.log("[AuthListener] No user, auto signing in anonymously...");
-      }
-
-      anonymousSignInInProgress = true;
-
-      // Create and execute anonymous sign-in handler
-      const handleAnonymousSignIn = createAnonymousSignInHandler(auth, store);
-
-      // Start sign-in without blocking the listener
-      void (async () => {
-        try {
-          await handleAnonymousSignIn();
-        } finally {
-          anonymousSignInInProgress = false;
-        }
-      })();
-
-      // Continue execution - don't return early
-      // The listener will be triggered again when sign-in succeeds
-      store.setFirebaseUser(null);
-      initializationInProgress = false;
-      return;
-    }
-
-    store.setFirebaseUser(user);
-    store.setInitialized(true);
-
-    if (user && !user.isAnonymous && store.isAnonymous) {
-      if (__DEV__) {
-        console.log("[AuthListener] User converted from anonymous, updating");
-      }
-      store.setIsAnonymous(false);
-    }
-
-    onAuthStateChange?.(user);
-  });
-
-  initializationInProgress = false;
+  // Setup the listener
+  setupAuthListener(auth, store, autoAnonymousSignIn, onAuthStateChange);
+  completeListenerSetup();
 
+  // Return cleanup function
   return () => {
-    listenerRefCount--;
-    if (__DEV__) {
-      console.log("[AuthListener] Unsubscribing, ref count:", listenerRefCount);
-    }
-    // Only cleanup when all subscribers unsubscribe
-    if (listenerRefCount <= 0 && firebaseUnsubscribe) {
-      if (__DEV__) {
-        console.log("[AuthListener] Last subscriber, cleaning up listener");
-      }
-      firebaseUnsubscribe();
-      firebaseUnsubscribe = null;
-      listenerInitialized = false;
-      listenerRefCount = 0;
-      anonymousSignInInProgress = false;
-      initializationInProgress = false;
+    const { shouldCleanup } = decrementRefCount();
+
+    if (shouldCleanup) {
+      resetListenerState();
     }
   };
 }
@@ -188,19 +65,12 @@ export function initializeAuthListener(
  * Reset listener state (for testing)
  */
 export function resetAuthListener(): void {
-  if (firebaseUnsubscribe) {
-    firebaseUnsubscribe();
-    firebaseUnsubscribe = null;
-  }
-  listenerInitialized = false;
-  listenerRefCount = 0;
-  anonymousSignInInProgress = false;
-  initializationInProgress = false;
+  resetListenerState();
 }
 
 /**
  * Check if listener is initialized
  */
 export function isAuthListenerInitialized(): boolean {
-  return listenerInitialized;
+  return isListenerInitialized();
 }

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

@@ -21,20 +21,9 @@ export interface DeleteAccountOptions {
 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;
   }
 
@@ -44,9 +33,6 @@ export async function handleAccountDeletion(
   }
 
   if (result.error) {
-    if (__DEV__) {
-      console.log("[AccountDeleteHandler] Delete failed:", result.error);
-    }
     throw new Error(result.error.message);
   }
 }
@@ -71,36 +57,18 @@ async function handleReauthentication(
 }
 
 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;
   }
 
@@ -110,34 +78,15 @@ async function retryWithPassword(onPasswordRequired: () => Promise<string | null
 }
 
 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;
   }
 

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

@@ -0,0 +1,72 @@
+/**
+ * Auth Transition Detection Utilities
+ * Detects and handles authentication state transitions
+ */
+
+import { useRef, useEffect } from "react";
+
+export interface AuthTransitionState {
+  isAuthenticated: boolean;
+  isAnonymous: boolean;
+  isVisible: boolean;
+}
+
+export interface AuthTransitionResult {
+  justAuthenticated: boolean;
+  justConvertedFromAnonymous: boolean;
+  shouldClose: boolean;
+}
+
+/**
+ * Track auth state transitions
+ */
+export function useAuthTransitions(
+  state: AuthTransitionState,
+  onTransition?: (result: AuthTransitionResult) => void
+): void {
+  const prevIsAuthenticatedRef = useRef(state.isAuthenticated);
+  const prevIsAnonymousRef = useRef(state.isAnonymous);
+  const prevIsVisibleRef = useRef(state.isVisible);
+
+  useEffect(() => {
+    const justAuthenticated = !prevIsAuthenticatedRef.current && state.isAuthenticated;
+    const justConvertedFromAnonymous =
+      prevIsAnonymousRef.current && !state.isAnonymous && state.isAuthenticated;
+    const shouldClose =
+      (justAuthenticated || justConvertedFromAnonymous) && state.isVisible && !state.isAnonymous;
+
+    const result: AuthTransitionResult = {
+      justAuthenticated,
+      justConvertedFromAnonymous,
+      shouldClose,
+    };
+
+    onTransition?.(result);
+
+    prevIsAuthenticatedRef.current = state.isAuthenticated;
+    prevIsVisibleRef.current = state.isVisible;
+    prevIsAnonymousRef.current = state.isAnonymous;
+  }, [state.isAuthenticated, state.isVisible, state.isAnonymous, onTransition]);
+}
+
+/**
+ * Check if should close modal after auth transition
+ */
+export function shouldCloseAfterAuth(
+  justAuthenticated: boolean,
+  justConvertedFromAnonymous: boolean,
+  isVisible: boolean,
+  isAnonymous: boolean
+): boolean {
+  return (justAuthenticated || justConvertedFromAnonymous) && isVisible && !isAnonymous;
+}
+
+/**
+ * Execute callback with delay after auth
+ */
+export function executeAfterAuth(
+  callback: () => void,
+  delay: number = 100
+): NodeJS.Timeout {
+  return setTimeout(callback, delay);
+}

package/src/presentation/utils/form/formFieldState.util.ts

@@ -0,0 +1,82 @@
+/**
+ * Form Field State Management Utilities
+ * Shared utilities for form field state management across all auth forms
+ */
+
+import { useCallback, useState } from "react";
+
+export type FieldState = Record<string, string>;
+
+export interface UseFieldStateResult<T extends FieldState> {
+  fields: T;
+  updateField: <K extends keyof T>(field: K, value: T[K]) => void;
+  setFields: (fields: T | ((prev: T) => T)) => void;
+  resetFields: (initial: T) => void;
+}
+
+/**
+ * Hook for managing form field state with automatic error clearing
+ * @param initialFields - Initial field values
+ * @param clearErrors - Function to clear errors when fields change
+ * @returns Field state and handlers
+ */
+export function useFieldState<T extends FieldState>(
+  initialFields: T,
+  clearErrors?: (fields?: (keyof T)[]) => void
+): UseFieldStateResult<T> {
+  const [fields, setFields] = useState<T>(initialFields);
+
+  const updateField = useCallback(
+    <K extends keyof T>(field: K, value: T[K]) => {
+      setFields((prev) => ({ ...prev, [field]: value }));
+      clearErrors?.([field as string]);
+    },
+    [clearErrors]
+  );
+
+  const resetFields = useCallback((initial: T) => {
+    setFields(initial);
+  }, []);
+
+  return {
+    fields,
+    updateField,
+    setFields,
+    resetFields,
+  };
+}
+
+/**
+ * Create a field change handler that updates field value and clears errors
+ * @param setter - State setter for the field
+ * @param clearErrors - Function to clear errors
+ * @param fieldsToClear - Fields to clear when this field changes
+ * @returns Field change handler
+ */
+export function createFieldChangeHandler(
+  setter: (value: string) => void,
+  clearErrors?: () => void
+): (value: string) => void {
+  return (value: string) => {
+    setter(value);
+    clearErrors?.();
+  };
+}
+
+/**
+ * Create multiple field change handlers
+ * @param setters - Object mapping field names to their setters
+ * @param clearErrors - Function to clear errors
+ * @returns Object mapping field names to change handlers
+ */
+export function createFieldChangeHandlers<T extends Record<string, (value: string) => void>>(
+  setters: T,
+  clearErrors?: () => void
+): T {
+  return Object.fromEntries(
+    Object.entries(setters).map(([key, setter]) => [
+      key,
+      createFieldChangeHandler(setter, clearErrors),
+    ])
+  ) as T;
+}

package/src/presentation/utils/form/formValidation.util.ts

@@ -0,0 +1,173 @@
+/**
+ * Form Validation Utilities
+ * Shared validation logic for all auth forms
+ */
+
+import { useCallback } from "react";
+import {
+  validateEmail,
+  validatePasswordForLogin,
+  validatePasswordForRegister,
+  validatePasswordConfirmation,
+} from "../../../infrastructure/utils/AuthValidation";
+import type { PasswordConfig } from "../../../domain/value-objects/AuthConfig";
+
+export interface FormValidationError {
+  field: string;
+  message: string;
+}
+
+export interface FormValidationResult {
+  isValid: boolean;
+  errors: FormValidationError[];
+}
+
+export interface LoginFormValues {
+  email: string;
+  password: string;
+}
+
+export interface RegisterFormValues {
+  displayName?: string;
+  email: string;
+  password: string;
+  confirmPassword: string;
+}
+
+export interface ProfileFormValues {
+  displayName: string;
+  email: string;
+}
+
+/**
+ * Validate login form fields
+ * @param values - Form values to validate
+ * @param getErrorMessage - Function to get localized error messages
+ * @returns Validation result
+ */
+export function validateLoginForm(
+  values: LoginFormValues,
+  getErrorMessage: (key: string) => string
+): FormValidationResult {
+  const errors: FormValidationError[] = [];
+
+  const emailResult = validateEmail(values.email.trim());
+  if (!emailResult.isValid && emailResult.error) {
+    errors.push({ field: "email", message: getErrorMessage(emailResult.error) });
+  }
+
+  const passwordResult = validatePasswordForLogin(values.password);
+  if (!passwordResult.isValid && passwordResult.error) {
+    errors.push({ field: "password", message: getErrorMessage(passwordResult.error) });
+  }
+
+  return {
+    isValid: errors.length === 0,
+    errors,
+  };
+}
+
+/**
+ * Validate register form fields
+ * @param values - Form values to validate
+ * @param getErrorMessage - Function to get localized error messages
+ * @param passwordConfig - Password configuration
+ * @returns Validation result
+ */
+export function validateRegisterForm(
+  values: RegisterFormValues,
+  getErrorMessage: (key: string) => string,
+  passwordConfig: PasswordConfig
+): FormValidationResult {
+  const errors: FormValidationError[] = [];
+
+  const emailResult = validateEmail(values.email.trim());
+  if (!emailResult.isValid && emailResult.error) {
+    errors.push({ field: "email", message: getErrorMessage(emailResult.error) });
+  }
+
+  const passwordResult = validatePasswordForRegister(values.password, passwordConfig);
+  if (!passwordResult.isValid && passwordResult.error) {
+    errors.push({ field: "password", message: getErrorMessage(passwordResult.error) });
+  }
+
+  const confirmResult = validatePasswordConfirmation(values.password, values.confirmPassword);
+  if (!confirmResult.isValid && confirmResult.error) {
+    errors.push({ field: "confirmPassword", message: getErrorMessage(confirmResult.error) });
+  }
+
+  return {
+    isValid: errors.length === 0,
+    errors,
+  };
+}
+
+/**
+ * Validate profile form fields
+ * @param values - Form values to validate
+ * @returns Validation result
+ */
+export function validateProfileForm(values: ProfileFormValues): FormValidationResult {
+  const errors: FormValidationError[] = [];
+
+  if (!values.displayName.trim()) {
+    errors.push({ field: "displayName", message: "Display name is required" });
+  }
+
+  if (values.email) {
+    const emailResult = validateEmail(values.email);
+    if (!emailResult.isValid && emailResult.error) {
+      errors.push({ field: "email", message: emailResult.error });
+    }
+  }
+
+  return {
+    isValid: errors.length === 0,
+    errors,
+  };
+}
+
+/**
+ * Convert validation errors to field error object
+ * @param errors - Validation errors
+ * @returns Object mapping field names to error messages
+ */
+export function errorsToFieldErrors(
+  errors: FormValidationError[]
+): Record<string, string> {
+  const result: Record<string, string> = {};
+  for (const error of errors) {
+    result[error.field] = error.message;
+  }
+  return result;
+}
+
+/**
+ * Hook for form validation with error message resolution
+ * @param getErrorMessage - Function to get localized error messages
+ * @returns Validation functions
+ */
+export function useFormValidation(getErrorMessage: (key: string) => string) {
+  const validateLogin = useCallback(
+    (values: LoginFormValues) => validateLoginForm(values, getErrorMessage),
+    [getErrorMessage]
+  );
+
+  const validateRegister = useCallback(
+    (values: RegisterFormValues, passwordConfig: PasswordConfig) =>
+      validateRegisterForm(values, getErrorMessage, passwordConfig),
+    [getErrorMessage]
+  );
+
+  const validateProfile = useCallback(
+    (values: ProfileFormValues) => validateProfileForm(values),
+    []
+  );
+
+  return {
+    validateLogin,
+    validateRegister,
+    validateProfile,
+    errorsToFieldErrors,
+  };
+}