@umituz/react-native-auth 3.6.87 → 3.6.89

package/package.json

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

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

@@ -0,0 +1,60 @@
+/**
+ * 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

@@ -0,0 +1,85 @@
+/**
+ * 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/services/initializeAuth.ts

@@ -6,6 +6,9 @@
 import type { Auth, User } from "firebase/auth";
 import { getFirebaseAuth } 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";
 import type { ConversionState } from "../utils/authConversionDetector";
@@ -13,6 +16,9 @@ import type { AuthConfig } from "../../domain/value-objects/AuthConfig";
 import type { IStorageProvider } from "../types/Storage.types";
 
 export interface InitializeAuthOptions {
+  userCollection?: string;
+  extraFields?: Record<string, unknown>;
+  collectExtras?: () => Promise<UserDocumentExtras>;
   storageProvider?: IStorageProvider;
   autoAnonymousSignIn?: boolean;
   onUserConverted?: (anonymousId: string, authenticatedId: string) => void | Promise<void>;
@@ -52,6 +58,9 @@ async function doInitializeAuth(
 ): Promise<{ success: boolean; auth: Auth | null }> {
 
   const {
+    userCollection = "users",
+    extraFields,
+    collectExtras,
     storageProvider,
     autoAnonymousSignIn = true,
     onUserConverted,
@@ -62,6 +71,12 @@ async function doInitializeAuth(
   const auth = getFirebaseAuth();
   if (!auth) return { success: false, auth: null };
 
+  configureUserDocumentService({
+    collectionName: userCollection,
+    extraFields,
+    collectExtras: collectExtras || collectDeviceExtras,
+  });
+
   let authServiceInitFailed = false;
   try {
     await initializeAuthService(auth, authConfig, storageProvider);

package/src/infrastructure/utils/authStateHandler.ts

@@ -4,6 +4,7 @@
  */
 
 import type { User } from "firebase/auth";
+import { ensureUserDocument } from "../services/UserDocumentService";
 import { detectConversion, type ConversionState } from "./authConversionDetector";
 
 export interface AuthStateHandlerOptions {
@@ -40,6 +41,12 @@ export function createAuthStateHandler(
       }
     }
 
+    const extras = conversion.isConversion && state.current.previousUserId
+      ? { previousAnonymousUserId: state.current.previousUserId }
+      : undefined;
+
+    await ensureUserDocument(user, extras);
+
     state.current = {
       previousUserId: currentUserId,
       wasAnonymous: isCurrentlyAnonymous,

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

@@ -7,10 +7,6 @@ import type { Auth, User } from "firebase/auth";
 import type { AuthActions } from "../../../types/auth-store.types";
 import { completeInitialization } from "./listenerState.util";
 import { handleAnonymousMode } from "./anonymousHandler";
-import {
-  createOrUpdateUserDocument,
-  getFirestoreInstance,
-} from "../../repositories/UserDocumentRepository";
 
 type Store = AuthActions & { isAnonymous: boolean };
 
@@ -36,14 +32,6 @@ export function handleAuthStateChange(
     store.setFirebaseUser(user);
     store.setInitialized(true);
 
-    // Create or update Firestore user document (best practice)
-    if (user) {
-      createOrUpdateUserDocument(getFirestoreInstance(), user).catch((error) => {
-        console.error("[AuthListener] Failed to create/update user document:", error);
-        // Don't throw - Firestore failures shouldn't block auth state updates
-      });
-    }
-
     // Handle conversion from anonymous
     if (user && !user.isAnonymous && store.isAnonymous) {
       store.setIsAnonymous(false);

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

@@ -7,8 +7,10 @@ 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: string, value: string) => void,
+  updateField: (field: RegisterFieldKey, value: string) => void,
   setFieldErrors: React.Dispatch<React.SetStateAction<FieldErrors>>,
   clearLocalError: () => void
 ) {

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,

package/src/infrastructure/repositories/UserDocumentRepository.ts

@@ -1,85 +0,0 @@
-/**
- * User Document Repository
- * Manages Firestore user documents using Firebase Auth UID
- */
-
-import { doc, setDoc, getDoc, serverTimestamp, getFirestore } from "firebase/firestore";
-import type { Firestore } from "firebase/firestore";
-import type { User } from "firebase/auth";
-import type { UserProfile } from "../../domain/entities/UserProfile";
-
-const USERS_COLLECTION = "users";
-
-/**
- * Create or update user document in Firestore
- * Uses Firebase Auth UID as document ID (best practice)
- */
-export async function createOrUpdateUserDocument(
-  firestore: Firestore,
-  user: User
-): Promise<void> {
-  try {
-    const userRef = doc(firestore, USERS_COLLECTION, user.uid);
-    const userDoc = await getDoc(userRef);
-
-    const userData: Partial<UserProfile> = {
-      uid: user.uid,
-      email: user.email,
-      displayName: user.displayName,
-      photoURL: user.photoURL,
-      isAnonymous: user.isAnonymous,
-      lastLoginAt: new Date(),
-    };
-
-    if (!userDoc.exists()) {
-      // New user - create document with createdAt
-      await setDoc(userRef, {
-        ...userData,
-        createdAt: serverTimestamp(),
-        lastLoginAt: serverTimestamp(),
-      });
-    } else {
-      // Existing user - update lastLoginAt only
-      await setDoc(
-        userRef,
-        {
-          lastLoginAt: serverTimestamp(),
-          // Update these in case they changed (e.g., anonymous → registered)
-          email: userData.email,
-          displayName: userData.displayName,
-          photoURL: userData.photoURL,
-          isAnonymous: userData.isAnonymous,
-        },
-        { merge: true }
-      );
-    }
-  } catch (error) {
-    console.error("[UserDocumentRepository] Failed to create/update user document:", error);
-    // Don't throw - allow auth to continue even if Firestore fails
-  }
-}
-
-/**
- * Check if user document exists
- */
-export async function userDocumentExists(
-  firestore: Firestore,
-  uid: string
-): Promise<boolean> {
-  try {
-    const userRef = doc(firestore, USERS_COLLECTION, uid);
-    const userDoc = await getDoc(userRef);
-    return userDoc.exists();
-  } catch (error) {
-    console.error("[UserDocumentRepository] Failed to check user document:", error);
-    return false;
-  }
-}
-
-/**
- * Get Firestore instance
- * Exported for testing and external use
- */
-export function getFirestoreInstance(): Firestore {
-  return getFirestore();
-}