@umituz/react-native-firebase 2.4.14 → 2.4.16

package/src/domains/auth/infrastructure/services/utils/auth-result-converter.util.ts

@@ -0,0 +1,71 @@
+/**
+ * Auth Result Converter Utilities
+ * Shared utilities for converting Result types to service-specific result types
+ * Eliminates duplicate result conversion logic in OAuth providers (Apple, Google)
+ */
+
+import { isSuccess } from '../../../../../shared/domain/utils/result/result-helpers';
+import type { Result } from '../../../../../shared/domain/utils/result/result-types';
+
+/**
+ * Generic OAuth authentication success result
+ * Used by Apple, Google, and other OAuth providers
+ */
+export interface OAuthAuthSuccessResult {
+  success: true;
+  userCredential: any;
+  isNewUser: boolean;
+}
+
+/**
+ * Generic OAuth authentication error result
+ */
+export interface OAuthAuthErrorResult {
+  success: false;
+  error: string;
+  code?: string;
+}
+
+/**
+ * Generic OAuth authentication result (discriminated union)
+ */
+export type OAuthAuthResult = OAuthAuthSuccessResult | OAuthAuthErrorResult;
+
+/**
+ * Convert standard Result to OAuth-specific result format
+ * Eliminates duplicate conversion logic in Apple and Google auth services
+ *
+ * @param result - Standard Result from executeAuthOperation
+ * @param defaultErrorMessage - Default error message for the specific OAuth provider
+ * @returns OAuth-specific result with userCredential and isNewUser
+ *
+ * @example
+ * ```typescript
+ * // In AppleAuthService
+ * private convertToAppleAuthResult(result: Result<{ userCredential: any; isNewUser: boolean }>): AppleAuthResult {
+ *   return convertToOAuthResult(result, "Apple sign-in failed");
+ * }
+ *
+ * // In GoogleAuthService
+ * private convertToGoogleAuthResult(result: Result<{ userCredential: any; isNewUser: boolean }>): GoogleAuthResult {
+ *   return convertToOAuthResult(result, "Google sign-in failed");
+ * }
+ * ```
+ */
+export function convertToOAuthResult(
+  result: Result<{ userCredential: any; isNewUser: boolean }>,
+  defaultErrorMessage: string = 'Authentication failed'
+): OAuthAuthResult {
+  if (isSuccess(result) && result.data) {
+    return {
+      success: true,
+      userCredential: result.data.userCredential,
+      isNewUser: result.data.isNewUser,
+    } as OAuthAuthSuccessResult;
+  }
+  return {
+    success: false,
+    error: result.error?.message ?? defaultErrorMessage,
+    code: result.error?.code,
+  } as OAuthAuthErrorResult;
+}

package/src/domains/auth/infrastructure/utils/auth-guard.util.ts

@@ -0,0 +1,98 @@
+/**
+ * Auth Guard Utilities
+ * Reusable helpers for auth initialization checks and error handling
+ * Eliminates duplicate auth guard patterns across services and hooks
+ */
+
+import type { Auth } from 'firebase/auth';
+import { getFirebaseAuth } from '../config/FirebaseAuthClient';
+import {
+  failureResultFrom,
+  successResult,
+  failureResultFromError,
+} from '../../../../shared/domain/utils/result/result-creators';
+import type { Result, FailureResult } from '../../../../shared/domain/utils/result/result-types';
+import { ERROR_MESSAGES } from '../../../../shared/domain/utils/error-handlers/error-messages';
+
+/**
+ * Result of auth guard check
+ */
+export type AuthGuardResult =
+  | { success: true; auth: Auth }
+  | FailureResult;
+
+/**
+ * Guard that ensures auth is initialized before proceeding
+ * Returns auth instance or failure result
+ *
+ * @example
+ * ```typescript
+ * const guardResult = requireAuth();
+ * if (!guardResult.success) {
+ *   return guardResult;
+ * }
+ * const auth = guardResult.auth;
+ * ```
+ */
+export function requireAuth(): AuthGuardResult {
+  const auth = getFirebaseAuth();
+  if (!auth) {
+    return failureResultFrom('auth/not-ready', ERROR_MESSAGES.AUTH.NOT_INITIALIZED);
+  }
+  return { success: true, auth };
+}
+
+/**
+ * Execute auth operation with automatic auth initialization check and error handling
+ * Eliminates need for manual auth guards and try-catch blocks
+ *
+ * @param operation - Operation that requires auth instance
+ * @returns Result with operation data or error
+ *
+ * @example
+ * ```typescript
+ * export async function signInWithEmail(email: string, password: string): Promise<Result<User>> {
+ *   return withAuth(async (auth) => {
+ *     const userCredential = await signInWithEmailAndPassword(auth, email, password);
+ *     return userCredential.user;
+ *   });
+ * }
+ * ```
+ */
+export async function withAuth<T>(
+  operation: (auth: Auth) => Promise<T>
+): Promise<Result<T>> {
+  const guardResult = requireAuth();
+  if (!guardResult.success) {
+    return guardResult;
+  }
+
+  try {
+    const data = await operation(guardResult.auth);
+    return successResult(data);
+  } catch (error) {
+    return failureResultFromError(error, 'auth/operation-failed');
+  }
+}
+
+/**
+ * Synchronous version of withAuth for non-async operations
+ *
+ * @param operation - Synchronous operation that requires auth instance
+ * @returns Result with operation data or error
+ */
+export function withAuthSync<T>(
+  operation: (auth: Auth) => T
+): Result<T> {
+  const guardResult = requireAuth();
+  if (!guardResult.success) {
+    return guardResult;
+  }
+
+  try {
+    const data = operation(guardResult.auth);
+    return successResult(data);
+  } catch (error) {
+    return failureResultFromError(error, 'auth/operation-failed');
+  }
+}

package/src/domains/firestore/index.ts

@@ -120,7 +120,7 @@ export {
   runTransaction,
   serverTimestamp,
 } from './utils/firestore-helper';
-export type { FirestoreResult, NoDbResult } from './utils/firestore-helper';
+export type { NoDbResult } from './utils/firestore-helper';
 
 // Validation Utilities
 export {

package/src/domains/firestore/infrastructure/config/FirestoreClient.ts

@@ -38,25 +38,12 @@ class FirestoreClientSingleton extends ServiceClientSingleton<Firestore> {
   }
 
   private static instance: FirestoreClientSingleton | null = null;
-  private static initInProgress = false;
 
   static getInstance(): FirestoreClientSingleton {
-    if (!FirestoreClientSingleton.instance && !FirestoreClientSingleton.initInProgress) {
-      FirestoreClientSingleton.initInProgress = true;
-      try {
-        FirestoreClientSingleton.instance = new FirestoreClientSingleton();
-      } finally {
-        FirestoreClientSingleton.initInProgress = false;
-      }
+    if (!this.instance) {
+      this.instance = new FirestoreClientSingleton();
     }
-
-    // Wait for initialization to complete if in progress
-    while (FirestoreClientSingleton.initInProgress && !FirestoreClientSingleton.instance) {
-      // Busy wait - in practice this should be very brief
-      // Consider using a Promise-based approach for better async handling
-    }
-
-    return FirestoreClientSingleton.instance!;
+    return this.instance;
   }
 
   /**

package/src/domains/firestore/infrastructure/repositories/BaseRepository.ts

@@ -71,14 +71,11 @@ export abstract class BaseRepository implements IPathResolver {
    * @param operation - Operation to execute
    * @returns Operation result
    * @throws Error if operation fails
+   * @note State check is handled by getDb() - all Firestore operations must go through getDb()
    */
   protected async executeOperation<T>(
     operation: () => Promise<T>
   ): Promise<T> {
-    if (this.state === RepositoryState.DESTROYED) {
-      throw new Error(ERROR_MESSAGES.REPOSITORY.DESTROYED);
-    }
-
     try {
       return await operation();
     } catch (error) {

package/src/domains/firestore/utils/firestore-helper.ts

@@ -8,9 +8,6 @@ export type { Firestore } from "../infrastructure/config/FirestoreClient";
 export {
   createErrorResult,
   createSuccessResult,
-  isSuccess,
-  isError,
-  type FirestoreResult,
   type NoDbResult,
   NO_DB_ERROR,
 } from "./result/result.util";

package/src/domains/firestore/utils/operation/operation-executor.util.ts

@@ -5,7 +5,7 @@
 
 import type { Firestore } from "../../infrastructure/config/FirestoreClient";
 import { getFirestore } from "../../infrastructure/config/FirestoreClient";
-import type { FirestoreResult } from "../result/result.util";
+import type { Result } from "../../../../shared/domain/utils/result/result-types";
 import { createNoDbErrorResult } from "../result/result.util";
 
 /**
@@ -13,8 +13,8 @@ import { createNoDbErrorResult } from "../result/result.util";
  * Returns error result if db is not available
  */
 export async function withFirestore<T>(
-  operation: (db: Firestore) => Promise<FirestoreResult<T>>,
-): Promise<FirestoreResult<T>> {
+  operation: (db: Firestore) => Promise<Result<T>>,
+): Promise<Result<T>> {
   const db = getFirestore();
   if (!db) {
     return createNoDbErrorResult<T>();

package/src/domains/firestore/utils/result/result.util.ts

@@ -3,13 +3,9 @@
  * Utilities for creating Firestore result objects
  */
 
-export interface FirestoreResult<T> {
-  success: boolean;
-  data?: T;
-  error?: { message: string; code: string };
-}
+import type { Result, FailureResult } from '../../../../shared/domain/utils/result/result-types';
 
-export type NoDbResult = FirestoreResult<never>;
+export type NoDbResult = FailureResult;
 
 export const NO_DB_ERROR: NoDbResult = {
   success: false,
@@ -19,37 +15,23 @@ export const NO_DB_ERROR: NoDbResult = {
 /**
  * Create a standard error result
  */
-export function createErrorResult<T>(message: string, code: string): FirestoreResult<T> {
+export function createErrorResult<T>(message: string, code: string): Result<T> {
   return { success: false, error: { message, code } };
 }
 
 /**
  * Create a standard success result
  */
-export function createFirestoreSuccessResult<T>(data?: T): FirestoreResult<T> {
-  return { success: true, data };
+export function createFirestoreSuccessResult<T>(data?: T): Result<T> {
+  return { success: true, data: data as T };
 }
 
 /**
  * Create no-db error result with proper typing
  */
-export function createNoDbErrorResult<T>(): FirestoreResult<T> {
+export function createNoDbErrorResult<T>(): Result<T> {
   return { success: false, error: NO_DB_ERROR.error };
 }
 
-/**
- * Check if result is successful
- */
-export function isSuccess<T>(result: FirestoreResult<T>): result is FirestoreResult<T> & { success: true } {
-  return result.success;
-}
-
-/**
- * Check if result is an error
- */
-export function isError<T>(result: FirestoreResult<T>): result is FirestoreResult<T> & { success: false } {
-  return !result.success;
-}
-
-// Keep old function name for backwards compatibility
+// Alias for backward compatibility
 export const createSuccessResult = createFirestoreSuccessResult;

package/src/index.ts

@@ -88,7 +88,7 @@ export {
   runTransaction,
   serverTimestamp,
 } from "./domains/firestore/utils/firestore-helper";
-export type { FirestoreResult, NoDbResult } from "./domains/firestore/utils/firestore-helper";
+export type { NoDbResult } from "./domains/firestore/utils/firestore-helper";
 
 // Init Module Factory
 export {

package/src/shared/domain/utils/async-executor.util.ts

@@ -1,13 +1,8 @@
 /**
  * Async Operation Executor Utility
- * Re-exports all async executors for backward compatibility
- * @deprecated Import from specific executor files instead
+ * Re-exports all async executors
  */
 
-// Error Converters
-export type { ErrorConverter } from './executors/error-converters.util';
-export { authErrorConverter, defaultErrorConverter } from './executors/error-converters.util';
-
 // Basic Executors
 export {
   executeOperation,

package/src/shared/domain/utils/error-handler.util.ts

@@ -4,9 +4,11 @@
  * @deprecated Import from specific error-handler files instead
  */
 
+// Error Types
+export type { ErrorInfo } from './result/result-types';
+
 // Error Converters
-export type { ErrorInfo } from './error-handlers/error-converters';
-export { toErrorInfo, toAuthErrorInfo } from './error-handlers/error-converters';
+export { toErrorInfo } from './error-handlers/error-converters';
 
 // Error Checkers
 export {

package/src/shared/domain/utils/error-handlers/error-checkers.ts

@@ -3,7 +3,7 @@
  * Check error types and categories
  */
 
-import type { ErrorInfo } from './error-converters';
+import type { ErrorInfo } from '../result/result-types';
 import { hasCodeProperty, hasMessageProperty } from '../type-guards.util';
 
 /**

package/src/shared/domain/utils/error-handlers/error-converters.ts

@@ -4,45 +4,23 @@
  */
 
 import { hasCodeProperty } from '../type-guards.util';
-
-/**
- * Standard error structure with code and message
- */
-export interface ErrorInfo {
-  code: string;
-  message: string;
-}
+import type { ErrorInfo } from '../result/result-types';
 
 /**
  * Convert unknown error to standard error info
  * Handles Error objects, strings, and unknown types
+ * @param error - Unknown error object
+ * @param defaultCode - Default error code if none found (e.g., 'auth/failed', 'firestore/error')
  */
-export function toErrorInfo(error: unknown): ErrorInfo {
-  if (error instanceof Error) {
-    return {
-      code: hasCodeProperty(error) ? error.code : 'unknown',
-      message: error.message,
-    };
-  }
-  return {
-    code: 'unknown',
-    message: typeof error === 'string' ? error : 'Unknown error',
-  };
-}
-
-/**
- * Convert unknown error to auth error info
- * Auth-specific error codes are prefixed with 'auth/'
- */
-export function toAuthErrorInfo(error: unknown): ErrorInfo {
+export function toErrorInfo(error: unknown, defaultCode: string = 'unknown'): ErrorInfo {
   if (error instanceof Error) {
     return {
-      code: hasCodeProperty(error) && error.code ? error.code : 'auth/failed',
+      code: hasCodeProperty(error) ? error.code : defaultCode,
       message: error.message,
     };
   }
   return {
-    code: 'auth/failed',
+    code: defaultCode,
     message: typeof error === 'string' ? error : 'Unknown error',
   };
 }

package/src/shared/domain/utils/executors/basic-executors.util.ts

@@ -4,9 +4,13 @@
  */
 
 import type { Result } from '../result.util';
-import { successResult } from '../result.util';
-import type { ErrorConverter } from './error-converters.util';
-import { authErrorConverter, defaultErrorConverter } from './error-converters.util';
+import { successResult, failureResultFromError } from '../result.util';
+import { toErrorInfo } from '../error-handlers/error-converters';
+
+/**
+ * Error converter function type
+ */
+export type ErrorConverter = (error: unknown) => { code: string; message: string };
 
 /**
  * Execute async operation with error handling
@@ -20,7 +24,7 @@ export async function executeOperation<T>(
     const data = await operation();
     return successResult(data);
   } catch (error) {
-    const converter = errorConverter ?? defaultErrorConverter;
+    const converter = errorConverter ?? ((err: unknown) => toErrorInfo(err, 'operation/failed'));
     return { success: false, error: converter(error) };
   }
 }
@@ -32,7 +36,7 @@ export async function executeOperationWithCode<T>(
   operation: () => Promise<T>,
   defaultErrorCode = 'operation/failed'
 ): Promise<Result<T>> {
-  return executeOperation(operation, (error) => defaultErrorConverter(error, defaultErrorCode));
+  return executeOperation(operation, (error: unknown) => toErrorInfo(error, defaultErrorCode));
 }
 
 /**
@@ -52,5 +56,5 @@ export async function executeVoidOperation(
 export async function executeAuthOperation<T>(
   operation: () => Promise<T>
 ): Promise<Result<T>> {
-  return executeOperation(operation, authErrorConverter);
+  return executeOperation(operation, (error: unknown) => toErrorInfo(error, 'auth/failed'));
 }

package/src/shared/domain/utils/index.ts

@@ -30,9 +30,6 @@ export {
   executeSequence,
   executeWithRetry,
   executeWithTimeout,
-  authErrorConverter,
-  defaultErrorConverter,
-  type ErrorConverter,
 } from './async-executor.util';
 
 // Service configuration
@@ -57,7 +54,6 @@ export {
 // Error handling
 export {
   toErrorInfo,
-  toAuthErrorInfo,
   hasErrorCode,
   isCancelledError,
   isQuotaErrorInfo,

package/src/shared/domain/utils/result/result-creators.ts

@@ -4,6 +4,7 @@
  */
 
 import type { SuccessResult, FailureResult, ErrorInfo } from './result-types';
+import { toErrorInfo } from '../error-handlers/error-converters';
 
 /**
  * Create a success result with optional data
@@ -28,22 +29,8 @@ export function failureResultFrom(code: string, message: string): FailureResult
 
 /**
  * Create a failure result from an unknown error
+ * Uses consolidated error converter for consistency
  */
 export function failureResultFromError(error: unknown, defaultCode = 'operation/failed'): FailureResult {
-  if (error instanceof Error) {
-    return {
-      success: false,
-      error: {
-        code: (error as { code?: string }).code ?? defaultCode,
-        message: error.message,
-      },
-    };
-  }
-  return {
-    success: false,
-    error: {
-      code: defaultCode,
-      message: typeof error === 'string' ? error : 'Unknown error occurred',
-    },
-  };
+  return failureResult(toErrorInfo(error, defaultCode));
 }

package/src/shared/domain/utils/type-guards.util.ts

@@ -5,14 +5,42 @@
  * Provides type-safe checking without using 'as' assertions.
  */
 
+/**
+ * Type guard for non-null objects
+ * Eliminates duplicate object checking pattern throughout the codebase
+ *
+ * @example
+ * ```typescript
+ * if (isObject(value)) {
+ *   // value is Record<string, unknown>
+ * }
+ * ```
+ */
+export function isObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null;
+}
+
+/**
+ * Type guard for objects with a specific property
+ *
+ * @param value - Value to check
+ * @param key - Property key to check for
+ * @returns True if value is an object with the specified property
+ */
+export function hasProperty<K extends string>(
+  value: unknown,
+  key: K
+): value is Record<K, unknown> {
+  return isObject(value) && key in value;
+}
+
 /**
  * Type guard for objects with a 'code' property of type string
  * Commonly used for Firebase errors and other error objects
  */
 export function hasCodeProperty(error: unknown): error is { code: string } {
   return (
-    typeof error === 'object' &&
-    error !== null &&
+    isObject(error) &&
     'code' in error &&
     typeof (error as { code: unknown }).code === 'string'
   );
@@ -24,8 +52,7 @@ export function hasCodeProperty(error: unknown): error is { code: string } {
  */
 export function hasMessageProperty(error: unknown): error is { message: string } {
   return (
-    typeof error === 'object' &&
-    error !== null &&
+    isObject(error) &&
     'message' in error &&
     typeof (error as { message: unknown }).message === 'string'
   );
@@ -45,8 +72,7 @@ export function hasCodeAndMessageProperties(error: unknown): error is { code: st
  */
 export function hasNameProperty(error: unknown): error is { name: string } {
   return (
-    typeof error === 'object' &&
-    error !== null &&
+    isObject(error) &&
     'name' in error &&
     typeof (error as { name: unknown }).name === 'string'
   );
@@ -58,8 +84,7 @@ export function hasNameProperty(error: unknown): error is { name: string } {
  */
 export function hasStackProperty(error: unknown): error is { stack: string } {
   return (
-    typeof error === 'object' &&
-    error !== null &&
+    isObject(error) &&
     'stack' in error &&
     typeof (error as { stack: unknown }).stack === 'string'
   );

package/src/shared/domain/utils/validators/firebase.validator.ts

@@ -14,7 +14,7 @@ export function isValidFirebaseApiKey(apiKey: string): boolean {
     return false;
   }
   const apiKeyPattern = /^AIza[0-9A-Za-z_-]{35}$/;
-  return apiKeyPattern.test(apiKey.trim());
+  return apiKeyPattern.test(apiKey);
 }
 
 /**
@@ -25,10 +25,9 @@ export function isValidFirebaseAuthDomain(authDomain: string): boolean {
   if (!isValidString(authDomain)) {
     return false;
   }
-  const trimmed = authDomain.trim();
   return (
-    trimmed.includes('.firebaseapp.com') ||
-    trimmed.includes('.web.app')
+    authDomain.includes('.firebaseapp.com') ||
+    authDomain.includes('.web.app')
   );
 }
 
@@ -41,5 +40,5 @@ export function isValidFirebaseProjectId(projectId: string): boolean {
     return false;
   }
   const pattern = /^[a-z0-9][a-z0-9-]{4,28}[a-z0-9]$/;
-  return pattern.test(projectId.trim());
+  return pattern.test(projectId);
 }

package/src/shared/domain/utils/validators/url.validator.ts

@@ -13,7 +13,7 @@ export function isValidUrl(url: string): boolean {
     return false;
   }
   try {
-    new URL(url.trim());
+    new URL(url);
     return true;
   } catch {
     return false;
@@ -28,7 +28,7 @@ export function isValidHttpsUrl(url: string): boolean {
     return false;
   }
   try {
-    const urlObj = new URL(url.trim());
+    const urlObj = new URL(url);
     return urlObj.protocol === 'https:';
   } catch {
     return false;

package/src/shared/domain/utils/validators/user-input.validator.ts

@@ -13,7 +13,7 @@ export function isValidEmail(email: string): boolean {
     return false;
   }
   const emailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
-  return emailPattern.test(email.trim());
+  return emailPattern.test(email);
 }
 
 /**