@umituz/react-native-firebase 1.13.140 → 1.13.142

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-firebase",
-  "version": "1.13.140",
+  "version": "1.13.142",
   "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/infrastructure/config/FirebaseAuthClient.ts

@@ -52,8 +52,17 @@ class FirebaseAuthClientSingleton extends ServiceClientSingleton<Auth, FirebaseA
   getAuth(): Auth | null {
     // Attempt initialization if not already initialized
     if (!this.isInitialized() && !this.getInitializationError()) {
-      const app = getFirebaseApp();
-      if (app) this.initialize();
+      try {
+        const app = getFirebaseApp();
+        if (app) {
+          this.initialize();
+        }
+      } catch (error) {
+        // Silently handle auto-initialization errors
+        // The error will be stored in state for later retrieval
+        const errorMessage = error instanceof Error ? error.message : 'Auto-initialization failed';
+        this.setError(errorMessage);
+      }
     }
     return this.getInstance();
   }

package/src/auth/infrastructure/services/account-deletion.service.ts

@@ -11,10 +11,14 @@ import {
   reauthenticateWithPassword,
   reauthenticateWithGoogle,
 } from "./reauthentication.service";
-import { toAuthErrorInfo } from "../../../domain/utils/error-handler.util";
-import type { AccountDeletionResult, AccountDeletionOptions } from "./reauthentication.types";
+import { successResult, type Result } from "../../../domain/utils";
+import type { AccountDeletionOptions } from "./reauthentication.types";
 
-export type { AccountDeletionResult, AccountDeletionOptions } from "./reauthentication.types";
+export interface AccountDeletionResult extends Result<void> {
+  requiresReauth?: boolean;
+}
+
+export type { AccountDeletionOptions } from "./reauthentication.types";
 
 export async function deleteCurrentUser(
   options: AccountDeletionOptions = { autoReauthenticate: true }
@@ -25,29 +29,36 @@ export async function deleteCurrentUser(
   if (!auth || !user) {
     return {
       success: false,
-      error: { code: "auth/not-ready", message: "Auth not ready", requiresReauth: false }
+      error: { code: "auth/not-ready", message: "Auth not ready" },
+      requiresReauth: false
     };
   }
 
   if (user.isAnonymous) {
     return {
       success: false,
-      error: { code: "auth/anonymous", message: "Cannot delete anonymous", requiresReauth: false }
+      error: { code: "auth/anonymous", message: "Cannot delete anonymous" },
+      requiresReauth: false
     };
   }
 
   try {
     await deleteUser(user);
-    return { success: true };
+    return successResult();
   } catch (error: unknown) {
-    const authErr = toAuthErrorInfo(error);
-    if (authErr.code === "auth/requires-recent-login" && (options.autoReauthenticate || options.password || options.googleIdToken)) {
+    const authErr = error instanceof Error ? (error as { code?: string; message?: string }) : null;
+    const code = authErr?.code ?? "auth/failed";
+    const message = authErr?.message ?? "Account deletion failed";
+
+    if (code === "auth/requires-recent-login" && (options.autoReauthenticate || options.password || options.googleIdToken)) {
       const reauth = await attemptReauth(user, options);
       if (reauth) return reauth;
     }
+
     return {
       success: false,
-      error: { ...authErr, requiresReauth: authErr.code === "auth/requires-recent-login" }
+      error: { code, message },
+      requiresReauth: code === "auth/requires-recent-login"
     };
   }
 }
@@ -62,7 +73,8 @@ async function attemptReauth(user: User, options: AccountDeletionOptions): Promi
     if (!options.googleIdToken) {
       return {
         success: false,
-        error: { code: "auth/google-reauth", message: "Google reauth required", requiresReauth: true }
+        error: { code: "auth/google-reauth", message: "Google reauth required" },
+        requiresReauth: true
       };
     }
     res = await reauthenticateWithGoogle(user, options.googleIdToken);
@@ -70,7 +82,8 @@ async function attemptReauth(user: User, options: AccountDeletionOptions): Promi
     if (!options.password) {
       return {
         success: false,
-        error: { code: "auth/password-reauth", message: "Password required", requiresReauth: true }
+        error: { code: "auth/password-reauth", message: "Password required" },
+        requiresReauth: true
       };
     }
     res = await reauthenticateWithPassword(user, options.password);
@@ -81,10 +94,14 @@ async function attemptReauth(user: User, options: AccountDeletionOptions): Promi
   if (res.success) {
     try {
       await deleteUser(user);
-      return { success: true };
+      return successResult();
     } catch (err: unknown) {
-      const authErr = toAuthErrorInfo(err);
-      return { success: false, error: { ...authErr, requiresReauth: false } };
+      const authErr = err instanceof Error ? (err as { code?: string; message?: string }) : null;
+      return {
+        success: false,
+        error: { code: authErr?.code ?? "auth/failed", message: authErr?.message ?? "Deletion failed" },
+        requiresReauth: false
+      };
     }
   }
 
@@ -93,8 +110,8 @@ async function attemptReauth(user: User, options: AccountDeletionOptions): Promi
     error: {
       code: res.error?.code || "auth/reauth-failed",
       message: res.error?.message || "Reauth failed",
-      requiresReauth: true
-    }
+    },
+    requiresReauth: true
   };
 }
 
@@ -102,18 +119,21 @@ export async function deleteUserAccount(user: User | null): Promise<AccountDelet
   if (!user || user.isAnonymous) {
     return {
       success: false,
-      error: { code: "auth/invalid", message: "Invalid user", requiresReauth: false }
+      error: { code: "auth/invalid", message: "Invalid user" },
+      requiresReauth: false
     };
   }
 
   try {
     await deleteUser(user);
-    return { success: true };
+    return successResult();
   } catch (error: unknown) {
-    const authErr = toAuthErrorInfo(error);
+    const authErr = error instanceof Error ? (error as { code?: string; message?: string }) : null;
+    const code = authErr?.code ?? "auth/failed";
     return {
       success: false,
-      error: { ...authErr, requiresReauth: authErr.code === "auth/requires-recent-login" }
+      error: { code, message: authErr?.message ?? "Deletion failed" },
+      requiresReauth: code === "auth/requires-recent-login"
     };
   }
 }

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

@@ -34,17 +34,13 @@ export class AnonymousAuthService implements AnonymousAuthServiceInterface {
       throw new Error("A non-anonymous user is already signed in. Sign out first before creating an anonymous session.");
     }
 
-    try {
-      const userCredential = await signInAnonymously(auth);
-      const anonymousUser = toAnonymousUser(userCredential.user);
-      return {
-        user: userCredential.user,
-        anonymousUser,
-        wasAlreadySignedIn: false,
-      };
-    } catch (error) {
-      throw error;
-    }
+    const userCredential = await signInAnonymously(auth);
+    const anonymousUser = toAnonymousUser(userCredential.user);
+    return {
+      user: userCredential.user,
+      anonymousUser,
+      wasAlreadySignedIn: false,
+    };
   }
 }
 

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

@@ -13,10 +13,9 @@ import { Platform } from "react-native";
 import { generateNonce, hashNonce } from "./crypto.util";
 import type { AppleAuthResult } from "./apple-auth.types";
 import {
-  createSuccessResult,
-  createFailureResult,
   isCancellationError,
 } from "./base/base-auth.service";
+import { executeAuthOperation, type Result } from "../../../domain/utils";
 
 export class AppleAuthService {
   async isAvailable(): Promise<boolean> {
@@ -28,17 +27,32 @@ export class AppleAuthService {
     }
   }
 
+  private convertToAppleAuthResult(result: Result<{ userCredential: any; isNewUser: boolean }>): AppleAuthResult {
+    if (result.success && result.data) {
+      return {
+        success: true,
+        userCredential: result.data.userCredential,
+        isNewUser: result.data.isNewUser,
+      };
+    }
+    return {
+      success: false,
+      error: result.error?.message ?? "Apple sign-in failed",
+      code: result.error?.code,
+    };
+  }
+
   async signIn(auth: Auth): Promise<AppleAuthResult> {
-    try {
-      const isAvailable = await this.isAvailable();
-      if (!isAvailable) {
-        return {
-          success: false,
-          error: "Apple Sign-In is not available on this device",
-          code: "unavailable"
-        };
-      }
+    const isAvailable = await this.isAvailable();
+    if (!isAvailable) {
+      return {
+        success: false,
+        error: "Apple Sign-In is not available on this device",
+        code: "unavailable"
+      };
+    }
 
+    const result = await executeAuthOperation(async () => {
       const nonce = await generateNonce();
       const hashedNonce = await hashNonce(nonce);
 
@@ -51,11 +65,7 @@ export class AppleAuthService {
       });
 
       if (!appleCredential.identityToken) {
-        return {
-          success: false,
-          error: "No identity token received",
-          code: "no_token"
-        };
+        throw new Error("No identity token received");
       }
 
       const provider = new OAuthProvider("apple.com");
@@ -65,7 +75,22 @@ export class AppleAuthService {
       });
 
       const userCredential = await signInWithCredential(auth, credential);
-      return createSuccessResult(userCredential);
+      return {
+        userCredential,
+        isNewUser: userCredential.user.metadata.creationTime ===
+          userCredential.user.metadata.lastSignInTime
+      };
+    });
+
+    return this.convertToAppleAuthResult(result);
+  }
+
+  /**
+   * Sign in with error handling for cancellation
+   */
+  async signInWithCancellationHandling(auth: Auth): Promise<AppleAuthResult> {
+    try {
+      return await this.signIn(auth);
     } catch (error) {
       if (isCancellationError(error)) {
         return {
@@ -75,7 +100,8 @@ export class AppleAuthService {
         };
       }
 
-      return createFailureResult(error);
+      // Re-throw for executeAuthOperation to handle
+      throw error;
     }
   }
 

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

@@ -6,39 +6,20 @@
  */
 
 import type { UserCredential } from 'firebase/auth';
-import { toAuthErrorInfo } from '../../../../domain/utils/error-handler.util';
+import { authErrorConverter, type Result } from '../../../../domain/utils';
 
 /**
- * Base authentication result interface
+ * Authentication result with user credential
  */
-export interface BaseAuthResult {
-  readonly success: boolean;
-  readonly error?: string;
-  readonly code?: string;
-}
-
-/**
- * Successful authentication result
- */
-export interface AuthSuccessResult extends BaseAuthResult {
-  readonly success: true;
+export interface AuthSuccessData {
   readonly userCredential: UserCredential;
   readonly isNewUser: boolean;
 }
 
 /**
- * Failed authentication result
- */
-export interface AuthFailureResult extends BaseAuthResult {
-  readonly success: false;
-  readonly error: string;
-  readonly code: string;
-}
-
-/**
- * Combined auth result type
+ * Auth result type that extends the base Result
  */
-export type AuthResult = AuthSuccessResult | AuthFailureResult;
+export type AuthResult = Result<AuthSuccessData>;
 
 /**
  * Check if user is new based on metadata
@@ -50,17 +31,6 @@ export function checkIsNewUser(userCredential: UserCredential): boolean {
   );
 }
 
-/**
- * Extract error information from unknown error
- */
-export function extractAuthError(error: unknown): { code: string; message: string } {
-  const errorInfo = toAuthErrorInfo(error);
-  return {
-    code: errorInfo.code,
-    message: errorInfo.message,
-  };
-}
-
 /**
  * Check if error is a cancellation error
  */
@@ -74,19 +44,18 @@ export function isCancellationError(error: unknown): boolean {
 /**
  * Create failure result from error
  */
-export function createFailureResult(error: unknown): AuthFailureResult {
-  const { code, message } = extractAuthError(error);
+export function createFailureResult(error: unknown): { success: false; error: { code: string; message: string } } {
+  const errorInfo = authErrorConverter(error);
   return {
     success: false,
-    error: message,
-    code,
+    error: errorInfo,
   };
 }
 
 /**
  * Create success result from user credential
  */
-export function createSuccessResult(userCredential: UserCredential): AuthSuccessResult {
+export function createSuccessResult(userCredential: UserCredential): { success: true; userCredential: UserCredential; isNewUser: boolean } {
   return {
     success: true,
     userCredential,

package/src/auth/infrastructure/services/firestore-utils.service.ts

@@ -55,7 +55,7 @@ export function shouldSkipFirestoreQuery(
   const {
     skipForGuest = true,
     skipIfNotAuthenticated = true,
-    verifyUserId: shouldVerify = true,
+    verifyUserId: shouldVerifyUserId = true,
     userId,
   } = options;
 
@@ -80,7 +80,7 @@ export function shouldSkipFirestoreQuery(
       return createResult(true, authState, "is_guest");
     }
 
-    if (shouldVerify && userId && !verifyUserId(auth, userId)) {
+    if (shouldVerifyUserId && userId && !verifyUserId(auth, userId)) {
       return createResult(true, authState, "user_id_mismatch");
     }
 

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

@@ -9,46 +9,50 @@ import {
   type Auth,
 } from "firebase/auth";
 import type { GoogleAuthConfig, GoogleAuthResult } from "./google-auth.types";
-import {
-  createSuccessResult,
-  createFailureResult,
-} from "./base/base-auth.service";
+import { executeAuthOperation, type Result } from "../../../domain/utils";
+import { ConfigurableService } from "../../../domain/utils/service-config.util";
 
 /**
  * Google Auth Service
  * Provides Google Sign-In functionality for Firebase
  */
-export class GoogleAuthService {
-  private config: GoogleAuthConfig | null = null;
-
-  configure(config: GoogleAuthConfig): void {
-    this.config = config;
-  }
-
-  isConfigured(): boolean {
+export class GoogleAuthService extends ConfigurableService<GoogleAuthConfig> {
+  protected isValidConfig(config: GoogleAuthConfig): boolean {
     return (
-      this.config !== null &&
-      (!!this.config.webClientId ||
-        !!this.config.iosClientId ||
-        !!this.config.androidClientId)
+      config !== null &&
+      (!!config.webClientId || !!config.iosClientId || !!config.androidClientId)
     );
   }
 
-  getConfig(): GoogleAuthConfig | null {
-    return this.config;
+  private convertToGoogleAuthResult(result: Result<{ userCredential: any; isNewUser: boolean }>): GoogleAuthResult {
+    if (result.success && result.data) {
+      return {
+        success: true,
+        userCredential: result.data.userCredential,
+        isNewUser: result.data.isNewUser,
+      };
+    }
+    return {
+      success: false,
+      error: result.error?.message ?? "Google sign-in failed",
+      code: result.error?.code,
+    };
   }
 
   async signInWithIdToken(
     auth: Auth,
     idToken: string,
   ): Promise<GoogleAuthResult> {
-    try {
+    const result = await executeAuthOperation(async () => {
       const credential = GoogleAuthProvider.credential(idToken);
       const userCredential = await signInWithCredential(auth, credential);
-      return createSuccessResult(userCredential);
-    } catch (error) {
-      return createFailureResult(error);
-    }
+      return {
+        userCredential,
+        isNewUser: userCredential.user.metadata.creationTime ===
+          userCredential.user.metadata.lastSignInTime
+      };
+    });
+    return this.convertToGoogleAuthResult(result);
   }
 }
 

package/src/auth/infrastructure/services/password.service.ts

@@ -4,35 +4,20 @@
  */
 
 import { updatePassword, type User } from 'firebase/auth';
-import { toAuthErrorInfo } from '../../../domain/utils/error-handler.util';
+import { executeAuthOperation, type Result } from '../../../domain/utils';
 
 /**
  * Result of a password update operation
+ * @deprecated Use Result<void> instead
  */
-export interface PasswordUpdateResult {
-  success: boolean;
-  error?: {
-    code: string;
-    message: string;
-  };
-}
+export type PasswordUpdateResult = Result<void>;
 
 /**
  * Update the current user's password
  * Note: Requires recent authentication. Re-authenticate before calling if needed.
  */
-export async function updateUserPassword(user: User, newPassword: string): Promise<PasswordUpdateResult> {
-  try {
+export async function updateUserPassword(user: User, newPassword: string): Promise<Result<void>> {
+  return executeAuthOperation(async () => {
     await updatePassword(user, newPassword);
-    return { success: true };
-  } catch (error: unknown) {
-    const errorInfo = toAuthErrorInfo(error);
-    return {
-      success: false,
-      error: {
-        code: errorInfo.code,
-        message: errorInfo.message,
-      },
-    };
-  }
+  });
 }

package/src/auth/infrastructure/services/reauthentication.service.ts

@@ -13,7 +13,8 @@ import {
 import * as AppleAuthentication from "expo-apple-authentication";
 import { Platform } from "react-native";
 import { generateNonce, hashNonce } from "./crypto.util";
-import { toAuthErrorInfo, isCancelledError } from "../../../domain/utils/error-handler.util";
+import { executeOperation, failureResultFrom } from "../../../domain/utils";
+import { isCancelledError } from "../../../domain/utils/error-handler.util";
 import type {
   ReauthenticationResult,
   AuthProviderType,
@@ -37,30 +38,20 @@ export function getUserAuthProvider(user: User): AuthProviderType {
 }
 
 export async function reauthenticateWithGoogle(user: User, idToken: string): Promise<ReauthenticationResult> {
-  try {
+  return executeOperation(async () => {
     await reauthenticateWithCredential(user, GoogleAuthProvider.credential(idToken));
-    return { success: true };
-  } catch (error: unknown) {
-    const err = toAuthErrorInfo(error);
-    return { success: false, error: err };
-  }
+  });
 }
 
 export async function reauthenticateWithPassword(user: User, pass: string): Promise<ReauthenticationResult> {
-  if (!user.email) {
-    return {
-      success: false,
-      error: { code: "auth/no-email", message: "User has no email" }
-    };
+  const email = user.email;
+  if (!email) {
+    return failureResultFrom("auth/no-email", "User has no email");
   }
 
-  try {
-    await reauthenticateWithCredential(user, EmailAuthProvider.credential(user.email, pass));
-    return { success: true };
-  } catch (error: unknown) {
-    const err = toAuthErrorInfo(error);
-    return { success: false, error: err };
-  }
+  return executeOperation(async () => {
+    await reauthenticateWithCredential(user, EmailAuthProvider.credential(email, pass));
+  });
 }
 
 export async function getAppleReauthCredential(): Promise<ReauthCredentialResult> {
@@ -107,8 +98,8 @@ export async function getAppleReauthCredential(): Promise<ReauthCredentialResult
       credential
     };
   } catch (error: unknown) {
-    const err = toAuthErrorInfo(error);
-    const code = isCancelledError(err) ? "auth/cancelled" : err.code;
+    const err = error instanceof Error ? error : new Error(String(error));
+    const code = isCancelledError({ code: '', message: err.message }) ? "auth/cancelled" : "auth/failed";
     return {
       success: false,
       error: { code, message: err.message }
@@ -118,13 +109,12 @@ export async function getAppleReauthCredential(): Promise<ReauthCredentialResult
 
 export async function reauthenticateWithApple(user: User): Promise<ReauthenticationResult> {
   const res = await getAppleReauthCredential();
-  if (!res.success || !res.credential) return { success: false, error: res.error };
-
-  try {
-    await reauthenticateWithCredential(user, res.credential);
-    return { success: true };
-  } catch (error: unknown) {
-    const err = toAuthErrorInfo(error);
-    return { success: false, error: err };
+  if (!res.success || !res.credential) {
+    return { success: false, error: res.error ?? { code: "auth/failed", message: "Failed to get credential" } };
   }
+
+  const credential = res.credential;
+  return executeOperation(async () => {
+    await reauthenticateWithCredential(user, credential);
+  });
 }