@umituz/react-native-auth 3.6.91 → 3.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-auth",
-  "version": "3.6.91",
+  "version": "3.7.0",
   "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",
@@ -32,10 +32,10 @@
     "url": "git+https://github.com/umituz/react-native-auth.git"
   },
   "peerDependencies": {
-    "expo": ">=54.0.0",
     "@react-navigation/native": ">=6.0.0",
     "@react-navigation/stack": ">=6.0.0",
     "@tanstack/react-query": ">=5.0.0",
+    "expo": ">=54.0.0",
     "expo-auth-session": ">=5.0.0",
     "expo-web-browser": ">=12.0.0",
     "firebase": ">=11.0.0",
@@ -49,6 +49,7 @@
   "devDependencies": {
     "@expo/vector-icons": "^15.0.3",
     "@react-native-async-storage/async-storage": "^2.2.0",
+    "@react-native-community/datetimepicker": "^8.2.0",
     "@react-native-community/slider": "^5.1.1",
     "@react-navigation/bottom-tabs": "^7.9.0",
     "@react-navigation/native": "^7.1.26",
@@ -61,7 +62,6 @@
     "@typescript-eslint/eslint-plugin": "^7.0.0",
     "@typescript-eslint/parser": "^7.0.0",
     "@umituz/react-native-design-system": "latest",
-    "@umituz/react-native-firebase": "latest",
     "@umituz/react-native-localization": "latest",
     "eslint": "^8.57.0",
     "expo-apple-authentication": "^6.0.0",
@@ -92,10 +92,9 @@
     "react-native-gesture-handler": "^2.0.0",
     "react-native-safe-area-context": "^5.6.2",
     "react-native-svg": "^15.15.1",
+    "rn-emoji-keyboard": "^1.7.0",
     "typescript": "^5.3.0",
-    "zustand": "^5.0.0",
-    "@react-native-community/datetimepicker": "^8.2.0",
-    "rn-emoji-keyboard": "^1.7.0"
+    "zustand": "^5.0.0"
   },
   "publishConfig": {
     "access": "public"
@@ -104,5 +103,8 @@
     "src",
     "README.md",
     "LICENSE"
-  ]
+  ],
+  "dependencies": {
+    "@umituz/react-native-firebase": "^1.13.154"
+  }
 }

package/src/application/ports/IAuthRepository.ts

@@ -1,6 +1,6 @@
 
 import type { AuthUser } from "../../domain/entities/AuthUser";
-import type { AuthCredentials, SignUpCredentials } from "./IAuthProvider";
+import type { AuthCredentials, SignUpCredentials } from "../../infrastructure/repositories/AuthRepository";
 
 export interface IAuthRepository {
     signUp(params: SignUpCredentials): Promise<AuthUser>;

package/src/index.ts

@@ -19,13 +19,12 @@ export { DEFAULT_AUTH_CONFIG, DEFAULT_PASSWORD_CONFIG, DEFAULT_SOCIAL_CONFIG } f
 // APPLICATION LAYER
 // =============================================================================
 
-export type { IAuthProvider, AuthCredentials, SignUpCredentials, SocialSignInResult } from './application/ports/IAuthProvider';
+export type { AuthCredentials, SignUpCredentials } from './infrastructure/repositories/AuthRepository';
 
 // =============================================================================
 // INFRASTRUCTURE LAYER
 // =============================================================================
 
-export { FirebaseAuthProvider } from './infrastructure/providers/FirebaseAuthProvider';
 export { AuthService, initializeAuthService, getAuthService, resetAuthService } from './infrastructure/services/AuthService';
 export type { IStorageProvider } from './infrastructure/types/Storage.types';
 export { createStorageProvider, StorageProviderAdapter } from './infrastructure/adapters/StorageProviderAdapter';

package/src/infrastructure/repositories/AuthRepository.ts

@@ -1,17 +1,24 @@
 /**
  * Auth Repository
- * Implementation of the Auth Repository Port
- * Handles data access for authentication
+ * Handles authentication with validation
  */
 
 import type { IAuthRepository } from "../../application/ports/IAuthRepository";
-import type { IAuthProvider } from "../../application/ports/IAuthProvider";
 import type { AuthUser } from "../../domain/entities/AuthUser";
-import type { AuthCredentials, SignUpCredentials } from "../../application/ports/IAuthProvider";
+import type { User } from "firebase/auth";
+import {
+    signInWithEmail,
+    signUpWithEmail,
+    signOut as firebaseSignOut,
+    getCurrentUserFromGlobal,
+    setupAuthListener,
+    type EmailCredentials,
+} from "@umituz/react-native-firebase";
 import {
     AuthValidationError,
     AuthWeakPasswordError,
     AuthInvalidEmailError,
+    AuthError,
 } from "../../domain/errors/AuthError";
 import {
     validateEmail,
@@ -21,13 +28,23 @@ import {
 } from "../utils/AuthValidation";
 import type { AuthConfig } from "../../domain/value-objects/AuthConfig";
 import { sanitizeEmail, sanitizeName, sanitizePassword } from "../utils/validation/sanitization";
+import { mapToAuthUser } from "../utils/UserMapper";
+
+export interface SignUpCredentials {
+    email: string;
+    password: string;
+    displayName?: string;
+}
+
+export interface AuthCredentials {
+    email: string;
+    password: string;
+}
 
 export class AuthRepository implements IAuthRepository {
-    private provider: IAuthProvider;
     private config: AuthConfig;
 
-    constructor(provider: IAuthProvider, config: AuthConfig) {
-        this.provider = provider;
+    constructor(config: AuthConfig) {
         this.config = config;
     }
 
@@ -36,13 +53,11 @@ export class AuthRepository implements IAuthRepository {
         const password = sanitizePassword(params.password);
         const displayName = params.displayName ? sanitizeName(params.displayName) : undefined;
 
-        // Validate email
         const emailResult = validateEmail(email);
         if (!emailResult.isValid) {
             throw new AuthInvalidEmailError(emailResult.error);
         }
 
-        // Validate display name if provided
         if (displayName) {
             const nameResult = validateDisplayName(displayName);
             if (!nameResult.isValid) {
@@ -50,43 +65,68 @@ export class AuthRepository implements IAuthRepository {
             }
         }
 
-        // Validate password strength for registration
         const passwordResult = validatePasswordForRegister(password, this.config.password);
         if (!passwordResult.isValid) {
             throw new AuthWeakPasswordError(passwordResult.error);
         }
 
-        return this.provider.signUp({ email, password, displayName });
+        const result = await signUpWithEmail({ email, password, displayName });
+        if (!result.success || !result.data) {
+            throw new AuthError(result.error?.message || "Sign up failed");
+        }
+
+        const authUser = mapToAuthUser(result.data);
+        if (!authUser) {
+            throw new AuthError("Failed to map user");
+        }
+        return authUser;
     }
 
     async signIn(params: AuthCredentials): Promise<AuthUser> {
         const email = sanitizeEmail(params.email);
         const password = sanitizePassword(params.password);
 
-        // Validate email format
         const emailResult = validateEmail(email);
         if (!emailResult.isValid) {
             throw new AuthInvalidEmailError(emailResult.error);
         }
 
-        // For login, only check if password is provided (no strength requirements)
         const passwordResult = validatePasswordForLogin(password);
         if (!passwordResult.isValid) {
             throw new AuthValidationError(passwordResult.error || "Password is required", "password");
         }
 
-        return this.provider.signIn({ email, password });
+        const result = await signInWithEmail(email, password);
+        if (!result.success || !result.data) {
+            throw new AuthError(result.error?.message || "Sign in failed");
+        }
+
+        const authUser = mapToAuthUser(result.data);
+        if (!authUser) {
+            throw new AuthError("Failed to map user");
+        }
+        return authUser;
     }
 
     async signOut(): Promise<void> {
-        await this.provider.signOut();
+        const result = await firebaseSignOut();
+        if (!result.success) {
+            throw new AuthError(result.error?.message || "Sign out failed");
+        }
     }
 
     getCurrentUser(): AuthUser | null {
-        return this.provider.getCurrentUser();
+        const user = getCurrentUserFromGlobal();
+        return user ? mapToAuthUser(user) : null;
     }
 
     onAuthStateChange(callback: (user: AuthUser | null) => void): () => void {
-        return this.provider.onAuthStateChange(callback);
+        const result = setupAuthListener({
+            onAuthStateChange: (user) => {
+                const authUser = user ? mapToAuthUser(user) : null;
+                callback(authUser);
+            },
+        });
+        return result.success && result.unsubscribe ? result.unsubscribe : () => {};
     }
 }

package/src/infrastructure/services/AnonymousModeService.ts

@@ -3,7 +3,6 @@
  * Handles anonymous mode functionality
  */
 
-import type { IAuthProvider } from "../../application/ports/IAuthProvider";
 import type { AuthUser } from "../../domain/entities/AuthUser";
 import { emitAnonymousModeEnabled } from "./AuthEventService";
 import type { IStorageProvider } from "../types/Storage.types";
@@ -46,19 +45,7 @@ export class AnonymousModeService {
     }
   }
 
-  async enable(storageProvider: IStorageProvider, provider?: IAuthProvider): Promise<void> {
-    // Sign out from provider if logged in
-    if (provider?.getCurrentUser()) {
-      try {
-        await provider.signOut();
-      } catch (error) {
-        // Log error but don't throw - allow anonymous mode to be enabled
-        // even if sign-out fails (user might be in inconsistent state but
-        // subsequent auth operations will resolve it)
-        console.warn("[AnonymousModeService] Sign-out failed during anonymous mode enable:", error);
-      }
-    }
-
+  async enable(storageProvider: IStorageProvider): Promise<void> {
     this.isAnonymousMode = true;
     await this.save(storageProvider);
     emitAnonymousModeEnabled();

package/src/infrastructure/services/AuthService.ts

@@ -1,16 +1,12 @@
 /**
  * Auth Service
- * Orchestrates authentication operations using composition
+ * Orchestrates authentication operations
  */
 
-import type { Auth } from "firebase/auth";
-import type { AuthCredentials, SignUpCredentials } from "../../application/ports/IAuthProvider";
-import type { IAuthProvider } from "../../application/ports/IAuthProvider";
-import { FirebaseAuthProvider } from "../providers/FirebaseAuthProvider";
 import type { AuthUser } from "../../domain/entities/AuthUser";
 import type { AuthConfig } from "../../domain/value-objects/AuthConfig";
 import { sanitizeAuthConfig } from "../../domain/value-objects/AuthConfig";
-import { AuthRepository } from "../repositories/AuthRepository";
+import { AuthRepository, type SignUpCredentials, type AuthCredentials } from "../repositories/AuthRepository";
 import { AnonymousModeService } from "./AnonymousModeService";
 import { authEventService } from "./AuthEventService";
 import type { IStorageProvider } from "../types/Storage.types";
@@ -33,33 +29,10 @@ export class AuthService {
     return this.repository;
   }
 
-  private isFirebaseAuth(obj: IAuthProvider | Auth): obj is Auth {
-    return (
-      typeof obj === "object" &&
-      obj !== null &&
-      "currentUser" in obj &&
-      "onAuthStateChanged" in obj &&
-      "signInWithEmailAndPassword" in obj &&
-      "createUserWithEmailAndPassword" in obj &&
-      typeof obj.onAuthStateChanged === "function"
-    );
-  }
-
-  async initialize(providerOrAuth: IAuthProvider | Auth): Promise<void> {
+  async initialize(): Promise<void> {
     if (this.initialized) return;
 
-    let provider: IAuthProvider;
-
-    if (this.isFirebaseAuth(providerOrAuth)) {
-      const firebaseProvider = new FirebaseAuthProvider(providerOrAuth);
-      await firebaseProvider.initialize();
-      provider = firebaseProvider;
-    } else {
-      provider = providerOrAuth;
-      await provider.initialize();
-    }
-
-    this.repository = new AuthRepository(provider, this.config);
+    this.repository = new AuthRepository(this.config);
 
     if (this.storageProvider) {
       await this.anonymousModeService.load(this.storageProvider);
@@ -122,14 +95,13 @@ export class AuthService {
 let authServiceInstance: AuthService | null = null;
 
 export async function initializeAuthService(
-  providerOrAuth: IAuthProvider | Auth,
   config?: Partial<AuthConfig>,
   storageProvider?: IStorageProvider
 ): Promise<AuthService> {
   if (!authServiceInstance) {
     authServiceInstance = new AuthService(config, storageProvider);
   }
-  await authServiceInstance.initialize(providerOrAuth);
+  await authServiceInstance.initialize();
   return authServiceInstance;
 }
 

package/src/infrastructure/services/initializeAuth.ts

@@ -1,13 +1,12 @@
 /**
  * Unified Auth Initialization
- * Initializes Firebase auth with user document sync and conversion tracking
+ * Initializes auth with user document sync and conversion tracking
  */
 
-import type { Auth, User } from "firebase/auth";
-import { getFirebaseAuth } from "@umituz/react-native-firebase";
+import type { User } from "firebase/auth";
+import { getFirebaseAuth, configureUserDocumentService } from "@umituz/react-native-firebase";
+import type { UserDocumentExtras } from "@umituz/react-native-firebase";
 import { initializeAuthService } from "./AuthService";
-import { configureUserDocumentService } from "./UserDocumentService";
-import type { UserDocumentExtras } from "./UserDocumentService";
 import { collectDeviceExtras } from "@umituz/react-native-design-system";
 import { initializeAuthListener } from "../../presentation/stores/initializeAuthListener";
 import { createAuthStateHandler } from "../utils/authStateHandler";
@@ -27,7 +26,7 @@ export interface InitializeAuthOptions {
 }
 
 let isInitialized = false;
-let initializationPromise: Promise<{ success: boolean; auth: Auth | null }> | null = null;
+let initializationPromise: Promise<{ success: boolean }> | null = null;
 const conversionState: { current: ConversionState } = {
   current: { previousUserId: null, wasAnonymous: false },
 };
@@ -37,9 +36,9 @@ const conversionState: { current: ConversionState } = {
  */
 export async function initializeAuth(
   options: InitializeAuthOptions = {}
-): Promise<{ success: boolean; auth: Auth | null }> {
+): Promise<{ success: boolean }> {
   if (isInitialized) {
-    return { success: true, auth: getFirebaseAuth() };
+    return { success: true };
   }
   // Prevent race condition: return existing promise if initialization is in progress
   if (initializationPromise) {
@@ -55,7 +54,7 @@ export async function initializeAuth(
 
 async function doInitializeAuth(
   options: InitializeAuthOptions
-): Promise<{ success: boolean; auth: Auth | null }> {
+): Promise<{ success: boolean }> {
 
   const {
     userCollection = "users",
@@ -69,7 +68,7 @@ async function doInitializeAuth(
   } = options;
 
   const auth = getFirebaseAuth();
-  if (!auth) return { success: false, auth: null };
+  if (!auth) return { success: false };
 
   configureUserDocumentService({
     collectionName: userCollection,
@@ -79,7 +78,7 @@ async function doInitializeAuth(
 
   let authServiceInitFailed = false;
   try {
-    await initializeAuthService(auth, authConfig, storageProvider);
+    await initializeAuthService(authConfig, storageProvider);
   } catch {
     authServiceInitFailed = true;
   }
@@ -97,7 +96,7 @@ async function doInitializeAuth(
   });
 
   isInitialized = true;
-  return { success: !authServiceInitFailed, auth };
+  return { success: !authServiceInitFailed };
 }
 
 export function isAuthInitialized(): boolean {

package/src/infrastructure/utils/authStateHandler.ts

@@ -4,7 +4,7 @@
  */
 
 import type { User } from "firebase/auth";
-import { ensureUserDocument } from "../services/UserDocumentService";
+import { ensureUserDocument } from "@umituz/react-native-firebase";
 import { detectConversion, type ConversionState } from "./authConversionDetector";
 
 export interface AuthStateHandlerOptions {

package/src/presentation/hooks/mutations/useAuthMutations.ts

@@ -5,7 +5,7 @@
 
 import { useMutation } from "@umituz/react-native-design-system";
 import { getAuthService } from "../../../infrastructure/services/AuthService";
-import type { AuthCredentials, SignUpCredentials } from "../../../application/ports/IAuthProvider";
+import type { AuthCredentials, SignUpCredentials } from "../../../infrastructure/repositories/AuthRepository";
 import type { AuthUser } from "../../../domain/entities/AuthUser";
 
 export const useSignUpMutation = () => {

package/src/presentation/hooks/useAccountManagement.ts

@@ -6,7 +6,7 @@
 import { useCallback, useState } from "react";
 import { Alert } from "react-native";
 import { useAuth } from "./useAuth";
-import { handleAccountDeletion } from "../utils/accountDeleteHandler.util";
+import { deleteCurrentUser } from "@umituz/react-native-firebase";
 
 export interface UseAccountManagementOptions {
   /**
@@ -111,14 +111,56 @@ export const useAccountManagement = (
     setIsDeletingAccount(true);
 
     try {
-      await handleAccountDeletion({
-        onReauthRequired,
-        onPasswordRequired: passwordHandler,
-      });
+      // First attempt - Firebase will check if reauthentication is needed
+      const result = await deleteCurrentUser({ autoReauthenticate: true });
+
+      if (result.success) {
+        return;
+      }
+
+      // Handle password reauthentication
+      if (result.error?.code === "auth/password-reauth") {
+        const password = await passwordHandler();
+        if (!password) {
+          throw new Error("Password required to delete account");
+        }
+
+        // Retry with password
+        const retryResult = await deleteCurrentUser({
+          autoReauthenticate: true,
+          password,
+        });
+
+        if (!retryResult.success) {
+          throw new Error(retryResult.error?.message || "Failed to delete account");
+        }
+
+        return;
+      }
+
+      // Handle social auth reauthentication
+      if (result.requiresReauth && onReauthRequired) {
+        const reauthSuccess = await onReauthRequired();
+        if (!reauthSuccess) {
+          throw new Error("Reauthentication required to delete account");
+        }
+
+        // Retry after social reauth
+        const retryResult = await deleteCurrentUser({ autoReauthenticate: true });
+
+        if (!retryResult.success) {
+          throw new Error(retryResult.error?.message || "Failed to delete account");
+        }
+
+        return;
+      }
+
+      // Other errors
+      throw new Error(result.error?.message || "Failed to delete account");
     } finally {
       setIsDeletingAccount(false);
     }
-  }, [user, onReauthRequired, passwordHandler]);
+  }, [user, passwordHandler, onReauthRequired]);
 
   return {
     logout,

package/src/application/ports/IAuthProvider.ts

@@ -1,78 +0,0 @@
-/**
- * Auth Provider Interface
- * Port for provider-agnostic authentication (Firebase, Supabase, etc.)
- */
-
-import type { AuthUser } from "../../domain/entities/AuthUser";
-import type { SocialAuthProvider } from "../../domain/value-objects/AuthConfig";
-
-export interface AuthCredentials {
-  email: string;
-  password: string;
-}
-
-export interface SignUpCredentials extends AuthCredentials {
-  displayName?: string;
-}
-
-/**
- * Result from social sign-in operations
- */
-export interface SocialSignInResult {
-  user: AuthUser;
-  isNewUser: boolean;
-}
-
-export interface IAuthProvider {
-  /**
-   * Initialize the auth provider
-   */
-  initialize(): Promise<void>;
-
-  /**
-   * Check if provider is initialized
-   */
-  isInitialized(): boolean;
-
-  /**
-   * Sign in with email and password
-   */
-  signIn(credentials: AuthCredentials): Promise<AuthUser>;
-
-  /**
-   * Sign up with email, password, and optional display name
-   */
-  signUp(credentials: SignUpCredentials): Promise<AuthUser>;
-
-  /**
-   * Sign in with Google
-   * @returns User and whether this is a new user
-   */
-  signInWithGoogle?(): Promise<SocialSignInResult>;
-
-  /**
-   * Sign in with Apple
-   * @returns User and whether this is a new user
-   */
-  signInWithApple?(): Promise<SocialSignInResult>;
-
-  /**
-   * Check if a social provider is supported
-   */
-  isSocialProviderSupported?(provider: SocialAuthProvider): boolean;
-
-  /**
-   * Sign out current user
-   */
-  signOut(): Promise<void>;
-
-  /**
-   * Get current authenticated user
-   */
-  getCurrentUser(): AuthUser | null;
-
-  /**
-   * Subscribe to auth state changes
-   */
-  onAuthStateChange(callback: (user: AuthUser | null) => void): () => void;
-}

package/src/infrastructure/providers/FirebaseAuthProvider.ts

@@ -1,117 +0,0 @@
-/**
- * Firebase Auth Provider
- * IAuthProvider implementation for Firebase Authentication
- */
-
-import {
-  createUserWithEmailAndPassword,
-  signInWithEmailAndPassword,
-  signOut as firebaseSignOut,
-  onAuthStateChanged,
-  updateProfile,
-  EmailAuthProvider,
-  linkWithCredential,
-  type Auth,
-} from "firebase/auth";
-import type { IAuthProvider, AuthCredentials, SignUpCredentials } from "../../application/ports/IAuthProvider";
-import type { AuthUser } from "../../domain/entities/AuthUser";
-import { mapFirebaseAuthError } from "../utils/AuthErrorMapper";
-import { mapToAuthUser } from "../utils/UserMapper";
-
-export class FirebaseAuthProvider implements IAuthProvider {
-  private auth: Auth | null = null;
-
-  constructor(auth?: Auth) {
-    if (auth) this.auth = auth;
-  }
-
-  initialize(): Promise<void> {
-    if (!this.auth) throw new Error("Firebase Auth instance must be provided");
-    return Promise.resolve();
-  }
-
-  setAuth(auth: Auth): void {
-    this.auth = auth;
-  }
-
-  isInitialized(): boolean {
-    return this.auth !== null;
-  }
-
-  async signIn(credentials: AuthCredentials): Promise<AuthUser> {
-    if (!this.auth) throw new Error("Firebase Auth is not initialized");
-
-    try {
-      const userCredential = await signInWithEmailAndPassword(this.auth, credentials.email.trim(), credentials.password);
-      const user = mapToAuthUser(userCredential.user);
-      if (!user) throw new Error("Failed to sign in");
-      return user;
-    } catch (error: unknown) {
-      throw mapFirebaseAuthError(error);
-    }
-  }
-
-  async signUp(credentials: SignUpCredentials): Promise<AuthUser> {
-    if (!this.auth) throw new Error("Firebase Auth is not initialized");
-
-    try {
-      const currentUser = this.auth.currentUser;
-      const isAnonymous = currentUser?.isAnonymous ?? false;
-      let userCredential;
-
-      if (currentUser && isAnonymous) {
-        // Try to reload to get fresh user data, but don't fail if it doesn't work
-        try {
-          await currentUser.reload();
-        } catch (reloadError) {
-          // Log the reload error but proceed - the user might still be valid
-          console.warn("[FirebaseAuthProvider] User reload failed during anonymous upgrade:", reloadError);
-        }
-        const credential = EmailAuthProvider.credential(credentials.email.trim(), credentials.password);
-        userCredential = await linkWithCredential(currentUser, credential);
-      } else {
-        userCredential = await createUserWithEmailAndPassword(this.auth, credentials.email.trim(), credentials.password);
-      }
-
-      if (credentials.displayName && userCredential.user) {
-        try {
-          await updateProfile(userCredential.user, { displayName: credentials.displayName.trim() });
-        } catch (profileError) {
-          // Display name update failed, but account was created successfully
-          // Log this for debugging but don't fail the entire operation
-          console.warn("[FirebaseAuthProvider] Display name update failed:", profileError);
-        }
-      }
-
-      const user = mapToAuthUser(userCredential.user);
-      if (!user) throw new Error("Failed to create user account");
-      return user;
-    } catch (error: unknown) {
-      throw mapFirebaseAuthError(error);
-    }
-  }
-
-  async signOut(): Promise<void> {
-    if (!this.auth) return;
-    try {
-      await firebaseSignOut(this.auth);
-    } catch (error: unknown) {
-      throw mapFirebaseAuthError(error);
-    }
-  }
-
-  getCurrentUser(): AuthUser | null {
-    if (!this.auth) return null;
-    const currentUser = this.auth.currentUser;
-    if (!currentUser) return null;
-    return mapToAuthUser(currentUser);
-  }
-
-  onAuthStateChange(callback: (user: AuthUser | null) => void): () => void {
-    if (!this.auth) {
-      callback(null);
-      return () => {};
-    }
-    return onAuthStateChanged(this.auth, (user) => callback(mapToAuthUser(user)));
-  }
-}

package/src/infrastructure/services/UserDocument.types.ts

@@ -1,60 +0,0 @@
-/**
- * User Document Types and Configuration
- */
-
-/**
- * Minimal user interface for document creation
- * Compatible with both Firebase User and AuthUser
- */
-export interface UserDocumentUser {
-  uid: string;
-  displayName?: string | null;
-  email?: string | null;
-  photoURL?: string | null;
-  isAnonymous?: boolean;
-}
-
-/**
- * Configuration for user document service
- */
-export interface UserDocumentConfig {
-  /** Firestore collection name (default: "users") */
-  collectionName?: string;
-  /** Additional fields to store with user document */
-  extraFields?: Record<string, unknown>;
-  /** Callback to collect device/app info */
-  collectExtras?: () => Promise<UserDocumentExtras>;
-}
-
-/**
- * User document extras from device/app
- */
-export interface UserDocumentExtras {
-  [key: string]: string | number | boolean | null | undefined;
-  deviceId?: string;
-  persistentDeviceId?: string;
-  nativeDeviceId?: string;
-  platform?: string;
-  deviceModel?: string;
-  deviceBrand?: string;
-  deviceName?: string;
-  deviceType?: number | string;
-  deviceYearClass?: number | string;
-  isDevice?: boolean;
-  osName?: string;
-  osVersion?: string;
-  osBuildId?: string;
-  totalMemory?: number | string;
-  appVersion?: string;
-  buildNumber?: string;
-  locale?: string;
-  region?: string;
-  timezone?: string;
-  screenWidth?: number;
-  screenHeight?: number;
-  screenScale?: number;
-  fontScale?: number;
-  isLandscape?: boolean;
-  previousAnonymousUserId?: string;
-  signUpMethod?: string;
-}

package/src/infrastructure/services/UserDocumentService.ts

@@ -1,85 +0,0 @@
-/**
- * User Document Service
- * Generic service for creating/updating user documents in Firestore
- */
-
-import { doc, getDoc, setDoc, serverTimestamp } from "firebase/firestore";
-import type { User } from "firebase/auth";
-import { getFirestore } from "@umituz/react-native-firebase";
-import type {
-  UserDocumentUser,
-  UserDocumentConfig,
-  UserDocumentExtras,
-} from "./UserDocument.types";
-import {
-  getSignUpMethod,
-  buildBaseData,
-  buildCreateData,
-  buildUpdateData,
-} from "../utils/userDocumentBuilder.util";
-
-export type {
-  UserDocumentUser,
-  UserDocumentConfig,
-  UserDocumentExtras,
-} from "./UserDocument.types";
-
-declare const __DEV__: boolean;
-
-let userDocumentConfig: UserDocumentConfig = {};
-
-export function configureUserDocumentService(config: UserDocumentConfig): void {
-  userDocumentConfig = { ...config };
-}
-
-export async function ensureUserDocument(
-  user: UserDocumentUser | User,
-  extras?: UserDocumentExtras,
-): Promise<boolean> {
-  const db = getFirestore();
-  if (!db || !user.uid) return false;
-
-  try {
-    let allExtras = extras || {};
-    if (userDocumentConfig.collectExtras) {
-      const collectedExtras = await userDocumentConfig.collectExtras();
-      allExtras = { ...collectedExtras, ...allExtras };
-    }
-
-    if (!allExtras.signUpMethod) allExtras.signUpMethod = getSignUpMethod(user);
-
-    const collectionName = userDocumentConfig.collectionName || "users";
-    const userRef = doc(db, collectionName, user.uid);
-    const userDoc = await getDoc(userRef);
-    const baseData = buildBaseData(user, allExtras);
-
-    const docData = !userDoc.exists()
-      ? buildCreateData(baseData, userDocumentConfig.extraFields, allExtras)
-      : buildUpdateData(baseData, allExtras);
-
-    await setDoc(userRef, docData, { merge: true });
-    return true;
-  } catch (error) {
-    if (typeof __DEV__ !== "undefined" && __DEV__) {
-      console.error("[UserDocumentService] Failed:", error);
-    }
-    return false;
-  }
-}
-
-export async function markUserDeleted(userId: string): Promise<boolean> {
-  const db = getFirestore();
-  if (!db || !userId) return false;
-
-  try {
-    const userRef = doc(db, userDocumentConfig.collectionName || "users", userId);
-    await setDoc(userRef, {
-      isDeleted: true,
-      deletedAt: serverTimestamp(),
-      updatedAt: serverTimestamp(),
-    }, { merge: true });
-    return true;
-  } catch {
-    return false;
-  }
-}

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

@@ -1,110 +0,0 @@
-/**
- * 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/utils/accountDeleteHandler.util.ts

@@ -1,96 +0,0 @@
-/**
- * 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> {
-  const result = await deleteCurrentUser({ autoReauthenticate: true });
-
-  if (result.success) {
-    return;
-  }
-
-  if (result.error?.requiresReauth) {
-    await handleReauthentication(result, callbacks);
-    return;
-  }
-
-  if (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" && onPasswordRequired) {
-    await retryWithPassword(onPasswordRequired);
-    return;
-  }
-
-  // Handle social auth reauth
-  if (onReauthRequired) {
-    await retryWithSocialAuth(onReauthRequired);
-    return;
-  }
-}
-
-async function retryWithPassword(onPasswordRequired: () => Promise<string | null>): Promise<void> {
-  const password = await onPasswordRequired();
-
-  if (!password) {
-    throw new Error("Password required to delete account");
-  }
-
-  const result = await deleteCurrentUser({
-    autoReauthenticate: false,
-    password,
-  });
-
-  if (result.success) {
-    return;
-  }
-
-  if (result.error) {
-    throw new Error(result.error.message);
-  }
-}
-
-async function retryWithSocialAuth(onReauthRequired: () => Promise<boolean>): Promise<void> {
-  const reauthSuccess = await onReauthRequired();
-
-  if (!reauthSuccess) {
-    throw new Error("Reauthentication required to delete account");
-  }
-
-  const result = await deleteCurrentUser({ autoReauthenticate: false });
-
-  if (result.success) {
-    return;
-  }
-
-  if (result.error) {
-    throw new Error(result.error.message);
-  }
-}