@umituz/react-native-auth 3.6.87 → 3.6.88

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-auth",
-  "version": "3.6.87",
+  "version": "3.6.88",
   "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/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/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,