@umituz/react-native-firebase 1.13.152 → 1.13.153

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-firebase",
-  "version": "1.13.152",
+  "version": "1.13.153",
   "description": "Unified Firebase package for React Native apps - Auth and Firestore services using Firebase JS SDK (no native modules).",
   "main": "./src/index.ts",
   "types": "./src/index.ts",

package/src/auth/index.ts

@@ -138,3 +138,36 @@ export {
 } from './infrastructure/services/password.service';
 export type { PasswordUpdateResult } from './infrastructure/services/password.service';
 
+// Email/Password Authentication
+export {
+  signInWithEmail,
+  signUpWithEmail,
+  signOut,
+  linkAnonymousWithEmail,
+} from './infrastructure/services/email-auth.service';
+export type {
+  EmailCredentials,
+  EmailAuthResult,
+} from './infrastructure/services/email-auth.service';
+
+// Auth Listener
+export {
+  setupAuthListener,
+} from './infrastructure/services/auth-listener.service';
+export type {
+  AuthListenerConfig,
+  AuthListenerResult,
+} from './infrastructure/services/auth-listener.service';
+
+// User Document Service
+export {
+  ensureUserDocument,
+  markUserDeleted,
+  configureUserDocumentService,
+} from './infrastructure/services/user-document.service';
+export type {
+  UserDocumentUser,
+  UserDocumentConfig,
+  UserDocumentExtras,
+} from './infrastructure/services/user-document.types';
+

package/src/auth/infrastructure/services/auth-listener.service.ts

@@ -0,0 +1,90 @@
+/**
+ * Auth Listener Service
+ * Manages Firebase auth state listener with timeout protection
+ */
+
+import { onIdTokenChanged, type User } from "firebase/auth";
+import { getFirebaseAuth } from "../config/FirebaseAuthClient";
+import type { Result } from "../../../domain/utils";
+import { successResult, failureResultFrom } from "../../../domain/utils";
+
+export interface AuthListenerConfig {
+  /**
+   * Timeout in milliseconds before marking as initialized
+   * @default 10000 (10 seconds)
+   */
+  timeout?: number;
+  /**
+   * Callback when auth state changes
+   */
+  onAuthStateChange?: (user: User | null) => void;
+  /**
+   * Callback when listener is initialized
+   */
+  onInitialized?: () => void;
+}
+
+export interface AuthListenerResult extends Result<() => void> {
+  unsubscribe?: () => void;
+}
+
+/**
+ * Setup Firebase auth listener with timeout protection
+ */
+export function setupAuthListener(
+  config: AuthListenerConfig = {}
+): AuthListenerResult {
+  const auth = getFirebaseAuth();
+  if (!auth) {
+    return failureResultFrom("auth/not-ready", "Firebase Auth not initialized");
+  }
+
+  const {
+    timeout = 10000,
+    onAuthStateChange,
+    onInitialized,
+  } = config;
+
+  let hasTriggered = false;
+  let unsubscribe: (() => void) | null = null;
+
+  // Safety timeout
+  const timeoutId = setTimeout(() => {
+    if (!hasTriggered) {
+      console.warn(
+        "[AuthListener] Auth listener timeout - marking as initialized"
+      );
+      hasTriggered = true;
+      onInitialized?.();
+    }
+  }, timeout);
+
+  try {
+    unsubscribe = onIdTokenChanged(auth, (user) => {
+      if (!hasTriggered) {
+        hasTriggered = true;
+        clearTimeout(timeoutId);
+        onInitialized?.();
+      }
+      onAuthStateChange?.(user);
+    });
+
+    const cleanup = () => {
+      clearTimeout(timeoutId);
+      unsubscribe?.();
+    };
+
+    return {
+      success: true,
+      data: cleanup,
+      unsubscribe: cleanup,
+    };
+  } catch (error) {
+    clearTimeout(timeoutId);
+    const err = error instanceof Error ? error : new Error(String(error));
+    return failureResultFrom(
+      "auth/listener-failed",
+      err.message
+    );
+  }
+}

package/src/auth/infrastructure/services/email-auth.service.ts

@@ -0,0 +1,140 @@
+/**
+ * Email/Password Authentication Service
+ * Handles email/password sign in, sign up, and account linking
+ */
+
+import {
+  createUserWithEmailAndPassword,
+  signInWithEmailAndPassword,
+  signOut as firebaseSignOut,
+  updateProfile,
+  EmailAuthProvider,
+  linkWithCredential,
+  type User,
+} from "firebase/auth";
+import { getFirebaseAuth } from "../config/FirebaseAuthClient";
+import { executeOperation, failureResultFrom, successResult, type Result } from "../../../domain/utils";
+
+export interface EmailCredentials {
+  email: string;
+  password: string;
+  displayName?: string;
+}
+
+export type EmailAuthResult = Result<User>;
+
+/**
+ * Sign in with email and password
+ */
+export async function signInWithEmail(
+  email: string,
+  password: string
+): Promise<EmailAuthResult> {
+  const auth = getFirebaseAuth();
+  if (!auth) {
+    return failureResultFrom("auth/not-ready", "Firebase Auth not initialized");
+  }
+
+  try {
+    const userCredential = await signInWithEmailAndPassword(
+      auth,
+      email.trim(),
+      password
+    );
+    return { success: true, data: userCredential.user };
+  } catch (error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    const code = (err as any).code || "auth/unknown";
+    return { success: false, error: { code, message: err.message } };
+  }
+}
+
+/**
+ * Sign up with email and password
+ * Automatically links with anonymous account if one exists
+ */
+export async function signUpWithEmail(
+  credentials: EmailCredentials
+): Promise<EmailAuthResult> {
+  const auth = getFirebaseAuth();
+  if (!auth) {
+    return failureResultFrom("auth/not-ready", "Firebase Auth not initialized");
+  }
+
+  try {
+    const currentUser = auth.currentUser;
+    const isAnonymous = currentUser?.isAnonymous ?? false;
+    let userCredential;
+
+    if (currentUser && isAnonymous) {
+      // Link anonymous account with email
+      const credential = EmailAuthProvider.credential(
+        credentials.email.trim(),
+        credentials.password
+      );
+      userCredential = await linkWithCredential(currentUser, credential);
+    } else {
+      // Create new account
+      userCredential = await createUserWithEmailAndPassword(
+        auth,
+        credentials.email.trim(),
+        credentials.password
+      );
+    }
+
+    // Update display name if provided
+    if (credentials.displayName && userCredential.user) {
+      await updateProfile(userCredential.user, {
+        displayName: credentials.displayName.trim(),
+      });
+    }
+
+    return { success: true, data: userCredential.user };
+  } catch (error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    const code = (err as any).code || "auth/unknown";
+    return { success: false, error: { code, message: err.message } };
+  }
+}
+
+/**
+ * Sign out current user
+ */
+export async function signOut(): Promise<Result<void>> {
+  const auth = getFirebaseAuth();
+  if (!auth) {
+    return successResult();
+  }
+
+  return executeOperation(async () => {
+    await firebaseSignOut(auth);
+  });
+}
+
+/**
+ * Link anonymous account with email/password
+ */
+export async function linkAnonymousWithEmail(
+  email: string,
+  password: string
+): Promise<EmailAuthResult> {
+  const auth = getFirebaseAuth();
+  if (!auth || !auth.currentUser) {
+    return failureResultFrom("auth/not-ready", "No current user");
+  }
+
+  const currentUser = auth.currentUser;
+  if (!currentUser.isAnonymous) {
+    return failureResultFrom("auth/invalid-action", "User is not anonymous");
+  }
+
+  try {
+    const credential = EmailAuthProvider.credential(email.trim(), password);
+    const userCredential = await linkWithCredential(currentUser, credential);
+    return { success: true, data: userCredential.user };
+  } catch (error) {
+    const err = error instanceof Error ? error : new Error(String(error));
+    const code = (err as any).code || "auth/unknown";
+    return { success: false, error: { code, message: err.message } };
+  }
+}

package/src/auth/infrastructure/services/user-document-builder.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 "./user-document.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/auth/infrastructure/services/user-document.service.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 "../../../firestore";
+import type {
+  UserDocumentUser,
+  UserDocumentConfig,
+  UserDocumentExtras,
+} from "./user-document.types";
+import {
+  getSignUpMethod,
+  buildBaseData,
+  buildCreateData,
+  buildUpdateData,
+} from "./user-document-builder.util";
+
+export type {
+  UserDocumentUser,
+  UserDocumentConfig,
+  UserDocumentExtras,
+} from "./user-document.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/auth/infrastructure/services/user-document.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;
+}