@umituz/react-native-firebase 1.13.140 → 1.13.141

package/src/domain/utils/result.util.ts

@@ -0,0 +1,129 @@
+/**
+ * Result Utility
+ * Unified result type for all operations across auth and firestore modules
+ * Provides type-safe success/failure handling
+ */
+
+/**
+ * Standard error information structure
+ */
+export interface ErrorInfo {
+  code: string;
+  message: string;
+}
+
+/**
+ * Standard result type for operations
+ * Success contains data, failure contains error info
+ */
+export interface Result<T = void> {
+  readonly success: boolean;
+  readonly data?: T;
+  readonly error?: ErrorInfo;
+}
+
+/**
+ * Success result type guard
+ */
+export type SuccessResult<T = void> = Result<T> & { readonly success: true; readonly data: T; readonly error?: never };
+
+/**
+ * Failure result type guard
+ */
+export type FailureResult = Result & { readonly success: false; readonly data?: never; readonly error: ErrorInfo };
+
+/**
+ * Create a success result with optional data
+ */
+export function successResult<T = void>(data?: T): SuccessResult<T> {
+  return { success: true, data: data as T };
+}
+
+/**
+ * Create a failure result with error information
+ */
+export function failureResult(error: ErrorInfo): FailureResult {
+  return { success: false, error };
+}
+
+/**
+ * Create a failure result from error code and message
+ */
+export function failureResultFrom(code: string, message: string): FailureResult {
+  return { success: false, error: { code, message } };
+}
+
+/**
+ * Create a failure result from an unknown error
+ */
+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',
+    },
+  };
+}
+
+/**
+ * Check if result is successful
+ */
+export function isSuccess<T>(result: Result<T>): result is SuccessResult<T> {
+  return result.success === true && result.error === undefined;
+}
+
+/**
+ * Check if result is a failure
+ */
+export function isFailure<T>(result: Result<T>): result is FailureResult {
+  return result.success === false;
+}
+
+/**
+ * Get data from result or return default
+ */
+export function getDataOrDefault<T>(result: Result<T>, defaultValue: T): T {
+  return isSuccess(result) ? (result.data ?? defaultValue) : defaultValue;
+}
+
+/**
+ * Map success result data to another type
+ */
+export function mapResult<T, U>(
+  result: Result<T>,
+  mapper: (data: T) => U
+): Result<U> {
+  if (isSuccess(result) && result.data !== undefined) {
+    return successResult(mapper(result.data));
+  }
+  // Return a new failure result to avoid type conflicts
+  if (isFailure(result)) {
+    return { success: false, error: result.error };
+  }
+  return successResult();
+}
+
+/**
+ * Chain multiple results, stopping at first failure
+ */
+export async function chainResults<T>(
+  ...operations: (() => Promise<Result<T>>)[]
+): Promise<Result<T>> {
+  for (const operation of operations) {
+    const result = await operation();
+    if (isFailure(result)) {
+      return result;
+    }
+  }
+  return successResult();
+}

package/src/domain/utils/service-config.util.ts

@@ -0,0 +1,99 @@
+/**
+ * Configurable Service Base Class
+ * Provides common service configuration pattern
+ * Eliminates code duplication across services
+ */
+
+/**
+ * Configuration state management
+ */
+export interface ConfigState<TConfig> {
+  config: TConfig | null;
+  initialized: boolean;
+}
+
+/**
+ * Configurable service interface
+ */
+export interface IConfigurableService<TConfig> {
+  configure(config: TConfig): void;
+  isConfigured(): boolean;
+  getConfig(): TConfig | null;
+  reset(): void;
+}
+
+/**
+ * Base class for configurable services
+ * Provides configuration management pattern
+ */
+export class ConfigurableService<TConfig = unknown> implements IConfigurableService<TConfig> {
+  protected configState: ConfigState<TConfig>;
+  private customValidator?: (config: TConfig) => boolean;
+
+  constructor(validator?: (config: TConfig) => boolean) {
+    this.configState = {
+      config: null,
+      initialized: false,
+    };
+    this.customValidator = validator;
+  }
+
+  /**
+   * Configure the service
+   */
+  configure(config: TConfig): void {
+    this.configState.config = config;
+    this.configState.initialized = this.isValidConfig(config);
+  }
+
+  /**
+   * Check if service is configured
+   */
+  isConfigured(): boolean {
+    return this.configState.initialized && this.configState.config !== null;
+  }
+
+  /**
+   * Get current configuration
+   */
+  getConfig(): TConfig | null {
+    return this.configState.config;
+  }
+
+  /**
+   * Reset configuration
+   */
+  reset(): void {
+    this.configState.config = null;
+    this.configState.initialized = false;
+  }
+
+  /**
+   * Validate configuration - can be overridden by custom validator
+   */
+  protected isValidConfig(config: TConfig): boolean {
+    if (this.customValidator) {
+      return this.customValidator(config);
+    }
+    return true;
+  }
+
+  /**
+   * Get required configuration or throw error
+   */
+  protected requireConfig(): TConfig {
+    if (!this.configState.config) {
+      throw new Error('Service is not configured');
+    }
+    return this.configState.config;
+  }
+}
+
+/**
+ * Create a configurable service instance
+ */
+export function createConfigurableService<TConfig>(
+  validator?: (config: TConfig) => boolean
+): ConfigurableService<TConfig> {
+  return new ConfigurableService<TConfig>(validator);
+}

package/src/domain/utils/validation.util.ts

@@ -131,3 +131,81 @@ export function isPositive(value: number): boolean {
 export function isNonNegative(value: number): boolean {
   return typeof value === 'number' && value >= 0;
 }
+
+/**
+ * Validate password strength
+ * At least 8 characters, containing uppercase, lowercase, and number
+ */
+export function isStrongPassword(password: string): boolean {
+  if (!isValidString(password) || password.length < 8) {
+    return false;
+  }
+  const hasUpperCase = /[A-Z]/.test(password);
+  const hasLowerCase = /[a-z]/.test(password);
+  const hasNumber = /[0-9]/.test(password);
+  return hasUpperCase && hasLowerCase && hasNumber;
+}
+
+/**
+ * Validate username format
+ * Alphanumeric, underscores, and hyphens, 3-20 characters
+ */
+export function isValidUsername(username: string): boolean {
+  if (!isValidString(username)) {
+    return false;
+  }
+  const pattern = /^[a-zA-Z0-9_-]{3,20}$/;
+  return pattern.test(username);
+}
+
+/**
+ * Validate phone number format (basic check)
+ */
+export function isValidPhoneNumber(phone: string): boolean {
+  if (!isValidString(phone)) {
+    return false;
+  }
+  const cleaned = phone.replace(/\s+/g, '').replace(/[-+()]/g, '');
+  return /^[0-9]{10,15}$/.test(cleaned);
+}
+
+/**
+ * Validate object has required properties
+ */
+export function hasRequiredProperties<T extends Record<string, unknown>>(
+  obj: unknown,
+  requiredProps: (keyof T)[]
+): obj is T {
+  if (typeof obj !== 'object' || obj === null) {
+    return false;
+  }
+  return requiredProps.every((prop) => prop in obj);
+}
+
+/**
+ * Validate all items in array match predicate
+ */
+export function allMatch<T>(items: unknown[], predicate: (item: unknown) => item is T): boolean {
+  return Array.isArray(items) && items.every(predicate);
+}
+
+/**
+ * Validate at least one item in array matches predicate
+ */
+export function anyMatch<T>(items: unknown[], predicate: (item: unknown) => item is T): boolean {
+  return Array.isArray(items) && items.some(predicate);
+}
+
+/**
+ * Create a validator that combines multiple validators
+ */
+export function combineValidators(...validators: ((value: string) => boolean)[]): (value: string) => boolean {
+  return (value: string) => validators.every((validator) => validator(value));
+}
+
+/**
+ * Create a validator that checks if value matches one of validators
+ */
+export function anyValidator(...validators: ((value: string) => boolean)[]): (value: string) => boolean {
+  return (value: string) => validators.some((validator) => validator(value));
+}

package/src/firestore/infrastructure/middleware/QueryDeduplicationMiddleware.ts

@@ -30,14 +30,12 @@ export class QueryDeduplicationMiddleware {
   ): Promise<T> {
     const key = generateQueryKey(queryKey);
 
+    // Check if query is already pending
     if (this.queryManager.isPending(key)) {
       const pendingPromise = this.queryManager.get(key);
       if (pendingPromise) {
-        // Type assertion is safe here because the same key was used to store the promise
-        return Promise.race([pendingPromise]).then(() => {
-          // Retry the original query after pending completes
-          return queryFn();
-        });
+        // Return the existing pending promise instead of executing again
+        return pendingPromise as Promise<T>;
       }
     }
 

package/src/firestore/infrastructure/repositories/BaseQueryRepository.ts

@@ -29,9 +29,9 @@ export abstract class BaseQueryRepository extends BaseRepository {
     cached: boolean = false,
     uniqueKey?: string
   ): Promise<T> {
-    // FIX: query.toString() returns "[object Object]" which breaks deduplication
-    // We must rely on the caller providing a uniqueKey or fallback to a collection-based key (less efficient but safe)
-    const safeKey = uniqueKey || `${collection}_generic_query_${Date.now()}`;
+    // Use provided uniqueKey, or generate a stable key based on collection
+    // IMPORTANT: Don't use Date.now() as it defeats deduplication!
+    const safeKey = uniqueKey || `${collection}_query`;
 
     const queryKey = {
       collection,

package/src/firestore/utils/dateUtils.ts

@@ -1,14 +1,30 @@
 import { Timestamp } from 'firebase/firestore';
 
+/**
+ * Validate ISO 8601 date string format
+ */
+function isValidISODate(isoString: string): boolean {
+  // Check if it matches ISO 8601 format (basic check)
+  const isoPattern = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d{3})?Z?([+-]\d{2}:\d{2})?$/;
+  if (!isoPattern.test(isoString)) {
+    return false;
+  }
+
+  // Verify it's a valid date
+  const date = new Date(isoString);
+  return !isNaN(date.getTime());
+}
+
 /**
  * Convert ISO string to Firestore Timestamp
+ * @throws Error if isoString is not a valid ISO 8601 date
  */
 export function isoToTimestamp(isoString: string): Timestamp {
-    const date = new Date(isoString);
-    if (isNaN(date.getTime())) {
-        throw new Error(`Invalid ISO date string: ${isoString}`);
-    }
-    return Timestamp.fromDate(date);
+  if (!isValidISODate(isoString)) {
+    throw new Error(`Invalid ISO date string: ${isoString}`);
+  }
+  const date = new Date(isoString);
+  return Timestamp.fromDate(date);
 }
 
 /**

package/src/firestore/utils/deduplication/pending-query-manager.util.ts

@@ -44,13 +44,9 @@ export class PendingQueryManager {
    * Add query to pending list with guaranteed cleanup
    */
   add(key: string, promise: Promise<unknown>): void {
-    const wrappedPromise = promise
-      .catch((error) => {
-        throw error;
-      })
-      .finally(() => {
-        this.pendingQueries.delete(key);
-      });
+    const wrappedPromise = promise.finally(() => {
+      this.pendingQueries.delete(key);
+    });
 
     this.pendingQueries.set(key, {
       promise: wrappedPromise,

package/src/firestore/utils/deduplication/query-key-generator.util.ts

@@ -10,15 +10,24 @@ export interface QueryKey {
   orderBy?: string;
 }
 
+/**
+ * Escape special characters in query key components
+ * Prevents key collisions when filter strings contain separator characters
+ */
+function escapeKeyComponent(component: string): string {
+  return component.replace(/%/g, '%25').replace(/\|/g, '%7C');
+}
+
 /**
  * Generate a unique key from query parameters
+ * Uses URL encoding to prevent collisions from separator characters
  */
 export function generateQueryKey(key: QueryKey): string {
   const parts = [
-    key.collection,
-    key.filters,
+    escapeKeyComponent(key.collection),
+    escapeKeyComponent(key.filters),
     key.limit?.toString() || '',
-    key.orderBy || '',
+    escapeKeyComponent(key.orderBy || ''),
   ];
   return parts.join('|');
 }

package/src/firestore/utils/deduplication/timer-manager.util.ts

@@ -18,17 +18,23 @@ export class TimerManager {
 
   /**
    * Start the cleanup timer
+   * Idempotent: safe to call multiple times
    */
   start(): void {
+    // Clear existing timer if running (prevents duplicate timers)
     if (this.timer) {
-      clearInterval(this.timer);
+      this.stop();
     }
 
     this.timer = setInterval(() => {
       try {
         this.options.onCleanup();
-      } catch {
+      } catch (error) {
         // Silently handle cleanup errors to prevent timer from causing issues
+        // Log error in development for debugging
+        if (process.env.NODE_ENV === 'development') {
+          console.error('TimerManager cleanup error:', error);
+        }
       }
     }, this.options.cleanupIntervalMs);
   }

package/src/infrastructure/config/FirebaseClient.ts

@@ -45,6 +45,7 @@ export interface ServiceInitializationResult {
 class FirebaseClientSingleton implements IFirebaseClient {
   private static instance: FirebaseClientSingleton | null = null;
   private state: FirebaseClientState;
+  private lastError: string | null = null;
 
   private constructor() {
     this.state = new FirebaseClientState();
@@ -58,23 +59,54 @@ class FirebaseClientSingleton implements IFirebaseClient {
   }
 
   initialize(config: FirebaseConfig): FirebaseApp | null {
-    return FirebaseInitializationOrchestrator.initialize(config);
+    try {
+      const result = FirebaseInitializationOrchestrator.initialize(config);
+      // Sync state with orchestrator result
+      this.state.setInstance(result);
+      this.lastError = null;
+      return result;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+      this.lastError = errorMessage;
+      this.state.setInitializationError(errorMessage);
+      return null;
+    }
   }
 
   getApp(): FirebaseApp | null {
-    return FirebaseInitializationOrchestrator.autoInitialize();
+    // Check local state first
+    const localApp = this.state.getApp();
+    if (localApp) return localApp;
+
+    // Try to get from orchestrator
+    const result = FirebaseInitializationOrchestrator.autoInitialize();
+    if (result) {
+      this.state.setInstance(result);
+    }
+    return result;
   }
 
   isInitialized(): boolean {
-    return this.state.isInitialized();
+    // Check both local state and orchestrator for consistency
+    if (this.state.isInitialized()) return true;
+
+    // Check if Firebase has any apps initialized
+    return FirebaseInitializationOrchestrator.autoInitialize() !== null;
   }
 
   getInitializationError(): string | null {
-    return this.state.getInitializationError();
+    // Check local state first
+    const localError = this.state.getInitializationError();
+    if (localError) return localError;
+    // Return last error
+    return this.lastError;
   }
 
   reset(): void {
+    // Reset local state
     this.state.reset();
+    this.lastError = null;
+    // Note: We don't reset Firebase apps as they might be in use
   }
 }
 

package/src/init/createFirebaseInitModule.ts

@@ -46,12 +46,27 @@ export function createFirebaseInitModule(
     critical,
     init: async () => {
       try {
-        await initializeAllFirebaseServices(undefined, {
+        const result = await initializeAllFirebaseServices(undefined, {
           authInitializer: authInitializer ?? (() => Promise.resolve()),
         });
+
+        // Check if initialization was successful
+        if (!result.app) {
+          console.error('[Firebase] Initialization failed: Firebase app not initialized');
+          return false;
+        }
+
+        // Check if auth initialization failed
+        if (result.auth === false && result.authError) {
+          console.error(`[Firebase] Auth initialization failed: ${result.authError}`);
+          // Auth failure is not critical for the app to function
+          // Log the error but don't fail the entire initialization
+        }
+
         return true;
-      } catch {
-        // Return false to indicate failure, let the app initializer handle it
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        console.error(`[Firebase] Initialization failed: ${errorMessage}`);
         return false;
       }
     },