@umituz/react-native-auth 3.6.86 → 3.6.88

package/src/infrastructure/utils/listener/cleanupHandlers.ts

@@ -0,0 +1,46 @@
+/**
+ * Cleanup Handlers
+ * Manages unsubscribe and cleanup logic for auth listener
+ */
+
+import {
+  isListenerInitialized,
+  incrementRefCount,
+  decrementRefCount,
+  resetListenerState,
+} from "./listenerState.util";
+
+/**
+ * Create unsubscribe function that decrements ref count
+ */
+export function createUnsubscribeHandler(): () => void {
+  return () => {
+    const { shouldCleanup } = decrementRefCount();
+
+    if (shouldCleanup) {
+      resetListenerState();
+    }
+  };
+}
+
+/**
+ * Return existing unsubscribe if already initialized
+ * Returns null if initialization is in progress
+ */
+export function handleExistingInitialization(): (() => void) | null {
+  if (!isListenerInitialized()) {
+    return null;
+  }
+
+  incrementRefCount();
+  return createUnsubscribeHandler();
+}
+
+/**
+ * Return no-op if initialization is in progress
+ */
+export function handleInitializationInProgress(): () => void {
+  return () => {
+    // No-op - handled by initial initialization
+  };
+}

package/src/infrastructure/utils/listener/initializationHandlers.ts

@@ -0,0 +1,26 @@
+/**
+ * Initialization Handlers
+ * Helper functions for listener initialization
+ */
+
+import type { AuthActions } from "../../../types/auth-store.types";
+import { completeInitialization } from "./listenerState.util";
+
+type Store = AuthActions & { isAnonymous: boolean };
+
+/**
+ * Handle case where Firebase auth is not available
+ */
+export function handleNoFirebaseAuth(store: Store): () => void {
+  completeInitialization();
+  store.setLoading(false);
+  store.setInitialized(true);
+  return () => {};
+}
+
+/**
+ * Complete listener setup and mark as initialized
+ */
+export function completeListenerSetup(): void {
+  completeInitialization();
+}

package/src/infrastructure/utils/listener/listenerLifecycle.util.ts

@@ -1,168 +1,26 @@
 /**
- * Auth Listener Lifecycle Utilities
- * Handles subscription and cleanup logic for auth listener
+ * Auth Listener Lifecycle - Main Export
+ * Re-exports all listener lifecycle utilities from modular files
  */
 
-import type { Auth, User } from "firebase/auth";
-import type { AuthActions } from "../../../types/auth-store.types";
-import { createAnonymousSignInHandler } from "./anonymousSignInHandler";
-import {
-  isListenerInitialized,
-  completeInitialization,
-  setUnsubscribe,
-  incrementRefCount,
-  decrementRefCount,
-  startAnonymousSignIn,
-  completeAnonymousSignIn,
-  resetListenerState,
-} from "./listenerState.util";
-import { onIdTokenChanged } from "firebase/auth";
-import { getAuthService } from "../../../infrastructure/services/AuthService";
-import {
-  createOrUpdateUserDocument,
-  getFirestoreInstance
-} from "../../repositories/UserDocumentRepository";
+// Cleanup handlers
+export {
+  createUnsubscribeHandler,
+  handleExistingInitialization,
+  handleInitializationInProgress,
+} from "./cleanupHandlers";
 
-type Store = AuthActions & { isAnonymous: boolean };
+// Setup listener
+export { setupAuthListener } from "./setupListener";
 
-/**
- * Create unsubscribe function that decrements ref count
- */
-export function createUnsubscribeHandler(): () => void {
-  return () => {
-    const { shouldCleanup } = decrementRefCount();
-
-    if (shouldCleanup) {
-      resetListenerState();
-    }
-  };
-}
-
-/**
- * Return existing unsubscribe if already initialized
- * Returns null if initialization is in progress
- */
-export function handleExistingInitialization(): (() => void) | null {
-  if (!isListenerInitialized()) {
-    return null;
-  }
-
-  incrementRefCount();
-  return createUnsubscribeHandler();
-}
-
-/**
- * Return no-op if initialization is in progress
- */
-export function handleInitializationInProgress(): () => void {
-  return () => {
-    // No-op - handled by initial initialization
-  };
-}
-
-/**
- * Setup Firebase auth listener
- */
-export function setupAuthListener(
-  auth: Auth,
-  store: Store,
-  autoAnonymousSignIn: boolean,
-  onAuthStateChange?: (user: User | null) => void
-): void {
-  const service = getAuthService();
-
-  if (service) {
-    const isAnonymous = service.getIsAnonymousMode();
-    if (isAnonymous) {
-      store.setIsAnonymous(true);
-    }
-  }
-
-  try {
-    const unsubscribe = onIdTokenChanged(auth, (user) => {
-      handleAuthStateChange(user, store, auth, autoAnonymousSignIn, onAuthStateChange);
-    });
+// Auth state handler
+export { handleAuthStateChange } from "./authStateHandler";
 
-    setUnsubscribe(unsubscribe);
-  } catch (error) {
-    // If listener setup fails, ensure we clean up and mark as initialized
-    console.error("[AuthListener] Failed to setup auth listener:", error);
-    completeInitialization();
-    store.setLoading(false);
-    store.setInitialized(true);
-    store.setError("Failed to initialize authentication listener");
-    throw error;
-  }
-}
-
-/**
- * Handle auth state change from Firebase
- */
-function handleAuthStateChange(
-  user: User | null,
-  store: Store,
-  auth: Auth,
-  autoAnonymousSignIn: boolean,
-  onAuthStateChange?: (user: User | null) => void
-): void {
-  try {
-    if (!user && autoAnonymousSignIn) {
-      // Start anonymous sign-in without blocking
-      void handleAnonymousMode(store, auth);
-      store.setFirebaseUser(null);
-      completeInitialization();
-      return;
-    }
-
-    store.setFirebaseUser(user);
-    store.setInitialized(true);
-
-    // Create or update Firestore user document (best practice)
-    if (user) {
-      void createOrUpdateUserDocument(getFirestoreInstance(), user);
-    }
-
-    // Handle conversion from anonymous
-    if (user && !user.isAnonymous && store.isAnonymous) {
-      store.setIsAnonymous(false);
-    }
-
-    onAuthStateChange?.(user);
-  } catch (error) {
-    console.error("[AuthListener] Error handling auth state change:", error);
-    // Ensure we don't leave the app in a bad state
-    store.setInitialized(true);
-    store.setLoading(false);
-  }
-}
-
-/**
- * Handle anonymous mode sign-in
- */
-async function handleAnonymousMode(store: Store, auth: Auth): Promise<void> {
-  if (!startAnonymousSignIn()) {
-    return; // Already signing in
-  }
-
-  const handleAnonymousSignIn = createAnonymousSignInHandler(auth, store);
-
-  try {
-    await handleAnonymousSignIn();
-  } finally {
-    completeAnonymousSignIn();
-  }
-}
-
-/**
- * Handle case where Firebase auth is not available
- */
-export function handleNoFirebaseAuth(store: Store): () => void {
-  completeInitialization();
-  store.setLoading(false);
-  store.setInitialized(true);
-  return () => {};
-}
+// Anonymous mode handler
+export { handleAnonymousMode } from "./anonymousHandler";
 
-export function completeListenerSetup() {
-  completeInitialization();
-}
+// Initialization handlers
+export {
+  handleNoFirebaseAuth,
+  completeListenerSetup,
+} from "./initializationHandlers";

package/src/infrastructure/utils/listener/listenerState.util.ts

@@ -8,6 +8,7 @@ export interface ListenerState {
   refCount: number;
   initializationInProgress: boolean;
   anonymousSignInInProgress: boolean;
+  cleanupInProgress: boolean;
   unsubscribe: (() => void) | null;
 }
 
@@ -16,6 +17,7 @@ const state: ListenerState = {
   refCount: 0,
   initializationInProgress: false,
   anonymousSignInInProgress: false,
+  cleanupInProgress: false,
   unsubscribe: null,
 };
 
@@ -60,11 +62,16 @@ export function startInitialization(): boolean {
 
 /**
  * Complete initialization
+ * If refCount is 0, set to 1 (first subscriber)
+ * Otherwise, keep existing refCount from concurrent subscribers
  */
 export function completeInitialization(): void {
   state.initializationInProgress = false;
   state.initialized = true;
-  state.refCount = 1;
+  // Only set refCount to 1 if it's still 0 (no concurrent subscribers)
+  if (state.refCount === 0) {
+    state.refCount = 1;
+  }
 }
 
 /**
@@ -85,10 +92,20 @@ export function incrementRefCount(): number {
 /**
  * Decrement reference count when a subscriber leaves
  * Returns true if cleanup should be performed
+ * Uses cleanupInProgress flag to prevent concurrent cleanup attempts
  */
 export function decrementRefCount(): { shouldCleanup: boolean; count: number } {
   state.refCount--;
-  const shouldCleanup = state.refCount <= 0 && state.unsubscribe !== null;
+  const shouldCleanup =
+    state.refCount <= 0 &&
+    state.unsubscribe !== null &&
+    !state.cleanupInProgress;
+
+  // If cleanup should happen, mark as in progress to prevent concurrent cleanup
+  if (shouldCleanup) {
+    state.cleanupInProgress = true;
+  }
+
   return { shouldCleanup, count: state.refCount };
 }
 
@@ -111,7 +128,7 @@ export function completeAnonymousSignIn(): void {
 }
 
 /**
- * Reset all state (for testing)
+ * Reset all state (for testing and cleanup)
  */
 export function resetListenerState(): void {
   if (state.unsubscribe) {
@@ -121,5 +138,6 @@ export function resetListenerState(): void {
   state.refCount = 0;
   state.initializationInProgress = false;
   state.anonymousSignInInProgress = false;
+  state.cleanupInProgress = false;
   state.unsubscribe = null;
 }

package/src/infrastructure/utils/listener/setupListener.ts

@@ -0,0 +1,63 @@
+/**
+ * Setup Auth Listener
+ * Configures Firebase auth listener with timeout protection
+ */
+
+import type { Auth, User } from "firebase/auth";
+import { onIdTokenChanged } from "firebase/auth";
+import type { AuthActions } from "../../../types/auth-store.types";
+import { getAuthService } from "../../services/AuthService";
+import { completeInitialization, setUnsubscribe } from "./listenerState.util";
+import { handleAuthStateChange } from "./authStateHandler";
+
+type Store = AuthActions & { isAnonymous: boolean };
+
+/**
+ * Setup Firebase auth listener with timeout protection
+ */
+export function setupAuthListener(
+  auth: Auth,
+  store: Store,
+  autoAnonymousSignIn: boolean,
+  onAuthStateChange?: (user: User | null) => void
+): void {
+  const service = getAuthService();
+
+  if (service) {
+    const isAnonymous = service.getIsAnonymousMode();
+    if (isAnonymous) {
+      store.setIsAnonymous(true);
+    }
+  }
+
+  // Safety timeout: if listener doesn't trigger within 10 seconds, mark as initialized
+  let hasTriggered = false;
+  const timeout = setTimeout(() => {
+    if (!hasTriggered) {
+      console.warn("[AuthListener] Auth listener timeout - marking as initialized");
+      store.setInitialized(true);
+      store.setLoading(false);
+    }
+  }, 10000);
+
+  try {
+    const unsubscribe = onIdTokenChanged(auth, (user) => {
+      if (!hasTriggered) {
+        hasTriggered = true;
+        clearTimeout(timeout);
+      }
+      handleAuthStateChange(user, store, auth, autoAnonymousSignIn, onAuthStateChange);
+    });
+
+    setUnsubscribe(unsubscribe);
+  } catch (error) {
+    clearTimeout(timeout);
+    // If listener setup fails, ensure we clean up and mark as initialized
+    console.error("[AuthListener] Failed to setup auth listener:", error);
+    completeInitialization();
+    store.setLoading(false);
+    store.setInitialized(true);
+    store.setError("Failed to initialize authentication listener");
+    throw error;
+  }
+}

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

@@ -0,0 +1,110 @@
+/**
+ * User Document Builder Utility
+ * Builds user document data for Firestore (max 100 lines)
+ */
+
+import { serverTimestamp } from "firebase/firestore";
+import type {
+  UserDocumentUser,
+  UserDocumentExtras,
+} from "../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> = {
+    uid: user.uid,
+    displayName: user.displayName,
+    email: user.email,
+    photoURL: user.photoURL,
+    isAnonymous: user.isAnonymous,
+  };
+
+  if (extras) {
+    const internalFields = ["signUpMethod", "previousAnonymousUserId"];
+    Object.keys(extras).forEach((key) => {
+      if (!internalFields.includes(key)) {
+        const val = extras[key];
+        if (val !== undefined) {
+          data[key] = 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/registerForm/registerFormHandlers.ts

@@ -0,0 +1,59 @@
+/**
+ * Register Form Change Handlers
+ * Input field change handlers with error clearing
+ */
+
+import { useCallback } from "react";
+import type { FieldErrors } from "./useRegisterForm.types";
+import { clearFieldError, clearFieldErrors } from "../../utils/form/formErrorUtils";
+
+type RegisterFieldKey = "displayName" | "email" | "password" | "confirmPassword";
+
+export function useRegisterFormHandlers(
+  updateField: (field: RegisterFieldKey, value: string) => void,
+  setFieldErrors: React.Dispatch<React.SetStateAction<FieldErrors>>,
+  clearLocalError: () => void
+) {
+  const handleDisplayNameChange = useCallback(
+    (text: string) => {
+      updateField("displayName", text);
+      clearFieldError(setFieldErrors, "displayName");
+      clearLocalError();
+    },
+    [updateField, clearLocalError]
+  );
+
+  const handleEmailChange = useCallback(
+    (text: string) => {
+      updateField("email", text);
+      clearFieldError(setFieldErrors, "email");
+      clearLocalError();
+    },
+    [updateField, clearLocalError]
+  );
+
+  const handlePasswordChange = useCallback(
+    (text: string) => {
+      updateField("password", text);
+      clearFieldErrors(setFieldErrors, ["password", "confirmPassword"]);
+      clearLocalError();
+    },
+    [updateField, clearLocalError]
+  );
+
+  const handleConfirmPasswordChange = useCallback(
+    (text: string) => {
+      updateField("confirmPassword", text);
+      clearFieldError(setFieldErrors, "confirmPassword");
+      clearLocalError();
+    },
+    [updateField, clearLocalError]
+  );
+
+  return {
+    handleDisplayNameChange,
+    handleEmailChange,
+    handlePasswordChange,
+    handleConfirmPasswordChange,
+  };
+}

package/src/presentation/hooks/registerForm/registerFormSubmit.ts

@@ -0,0 +1,64 @@
+/**
+ * Register Form Submit Logic
+ * Handles form validation and sign-up submission
+ */
+
+import { useCallback } from "react";
+import { alertService } from "@umituz/react-native-design-system";
+import { DEFAULT_PASSWORD_CONFIG } from "../../../domain/value-objects/AuthConfig";
+import {
+  validateRegisterForm,
+  errorsToFieldErrors,
+} from "../../utils/form/formValidation.util";
+import { getAuthErrorLocalizationKey } from "../../utils/getAuthErrorMessage";
+import type { FieldErrors, RegisterFormTranslations } from "./useRegisterForm.types";
+
+interface RegisterFormFields {
+  displayName: string;
+  email: string;
+  password: string;
+  confirmPassword: string;
+}
+
+export function useRegisterFormSubmit(
+  fields: RegisterFormFields,
+  signUp: (email: string, password: string, displayName?: string) => Promise<void>,
+  setFieldErrors: React.Dispatch<React.SetStateAction<FieldErrors>>,
+  setLocalError: React.Dispatch<React.SetStateAction<string | null>>,
+  clearFormErrors: () => void,
+  getErrorMessage: (key: string) => string,
+  translations?: RegisterFormTranslations
+) {
+  const handleSignUp = useCallback(async () => {
+    clearFormErrors();
+
+    const validation = validateRegisterForm(
+      {
+        displayName: fields.displayName.trim() || undefined,
+        email: fields.email.trim(),
+        password: fields.password,
+        confirmPassword: fields.confirmPassword,
+      },
+      getErrorMessage,
+      DEFAULT_PASSWORD_CONFIG
+    );
+
+    if (!validation.isValid) {
+      setFieldErrors(errorsToFieldErrors(validation.errors));
+      return;
+    }
+
+    try {
+      await signUp(fields.email.trim(), fields.password, fields.displayName.trim() || undefined);
+
+      if (translations) {
+        alertService.success(translations.successTitle, translations.signUpSuccess);
+      }
+    } catch (err: unknown) {
+      const localizationKey = getAuthErrorLocalizationKey(err);
+      setLocalError(getErrorMessage(localizationKey));
+    }
+  }, [fields, signUp, translations, getErrorMessage, clearFormErrors, setFieldErrors, setLocalError]);
+
+  return { handleSignUp };
+}

package/src/presentation/hooks/registerForm/useRegisterForm.types.ts

@@ -0,0 +1,39 @@
+/**
+ * Register Form Types
+ * Type definitions for register form hook
+ */
+
+export type FieldErrors = {
+  displayName?: string;
+  email?: string;
+  password?: string;
+  confirmPassword?: string;
+};
+
+export interface RegisterFormTranslations {
+  successTitle: string;
+  signUpSuccess: string;
+  errors: Record<string, string>;
+}
+
+export interface UseRegisterFormConfig {
+  translations: RegisterFormTranslations;
+}
+
+export interface UseRegisterFormResult {
+  displayName: string;
+  email: string;
+  password: string;
+  confirmPassword: string;
+  fieldErrors: FieldErrors;
+  localError: string | null;
+  loading: boolean;
+  passwordRequirements: { hasMinLength: boolean };
+  passwordsMatch: boolean;
+  handleDisplayNameChange: (text: string) => void;
+  handleEmailChange: (text: string) => void;
+  handlePasswordChange: (text: string) => void;
+  handleConfirmPasswordChange: (text: string) => void;
+  handleSignUp: () => Promise<void>;
+  displayError: string | null;
+}

package/src/presentation/hooks/useProfileEdit.ts

@@ -58,10 +58,13 @@ export const useProfileEdit = (
     isValid: boolean;
     errors: string[];
   } => {
-    const result = validateProfileForm({
-      displayName: formState.displayName,
-      email: formState.email,
-    });
+    const result = validateProfileForm(
+      {
+        displayName: formState.displayName,
+        email: formState.email,
+      },
+      (key) => key // Pass-through function - returns key as-is since caller handles translation
+    );
 
     return {
       isValid: result.isValid,