@umituz/react-native-firebase 2.4.97 → 2.4.100

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-firebase",
-  "version": "2.4.97",
+  "version": "2.4.100",
   "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/domains/auth/domain/value-objects/FirebaseAuthConfig.ts

@@ -21,7 +21,7 @@ export interface FirebaseAuthConfig {
 
   /**
    * Auth state persistence type
-   * - 'local': Persist across browser/app restarts (default)
+   * - 'local': Persist across app restarts (default)
    * - 'session': Persist only for current session
    * - 'none': No persistence
    */

package/src/domains/auth/infrastructure/config/initializers/FirebaseAuthInitializer.ts

@@ -1,15 +1,7 @@
-/**
- * Firebase Auth Initializer
- *
- * Single Responsibility: Initialize Firebase Auth instance
- * Platform-agnostic: Works on all platforms (Web, iOS, Android)
- */
-
 import {
   initializeAuth,
   getAuth,
   // @ts-expect-error: getReactNativePersistence exists in the React Native bundle but missing from type definitions
-  // See: https://github.com/firebase/firebase-js-sdk/issues/9316
   getReactNativePersistence,
 } from 'firebase/auth';
 import type { Auth } from 'firebase/auth';
@@ -17,40 +9,8 @@ import AsyncStorage from '@react-native-async-storage/async-storage';
 import type { FirebaseApp } from 'firebase/app';
 import type { FirebaseAuthConfig } from '../../../domain/value-objects/FirebaseAuthConfig';
 
-/**
- * Initializes Firebase Auth
- * Platform-agnostic: Works on all platforms (Web, iOS, Android)
- */
 export class FirebaseAuthInitializer {
-  /**
-   * Initialize Firebase Auth with persistence support
-   */
   static initialize(app: FirebaseApp, config?: FirebaseAuthConfig): Auth | null {
-    try {
-      const auth = this.initializeWithPersistence(app, config);
-      return auth;
-    } catch (error: unknown) {
-      return this.handleInitializationError(error, app);
-    }
-  }
-
-  private static handleInitializationError(error: unknown, app: FirebaseApp): Auth | null {
-    // Any initialization error: try to get existing auth instance
-    return this.getExistingAuth(app);
-  }
-
-  private static getExistingAuth(app: FirebaseApp): Auth | null {
-    try {
-      return getAuth(app);
-    } catch {
-      return null;
-    }
-  }
-
-  private static initializeWithPersistence(
-    app: FirebaseApp,
-    config?: FirebaseAuthConfig
-  ): Auth | null {
     try {
       const storage = config?.authStorage || {
         getItem: (key: string) => AsyncStorage.getItem(key),
@@ -62,7 +22,11 @@ export class FirebaseAuthInitializer {
         persistence: getReactNativePersistence(storage),
       });
     } catch {
-      return this.getExistingAuth(app);
+      try {
+        return getAuth(app);
+      } catch {
+        return null;
+      }
     }
   }
 }

package/src/domains/firestore/infrastructure/config/initializers/FirebaseFirestoreInitializer.ts

@@ -1,264 +1,13 @@
-/**
- * Firebase Firestore Initializer (Enhanced)
- *
- * Single Responsibility: Initialize Firestore instance with optimal caching
- *
- * OPTIMIZATIONS:
- * - Web: Persistent IndexedDB cache (survives restarts) with configurable size
- * - React Native: Memory cache (platform limitation)
- * - Configurable cache size limits (10 MB default for persistent cache)
- * - Platform-aware cache strategy
- *
- * COST SAVINGS: ~90% reduction in network reads through persistent caching
- *
- * NOTE: As of Firebase v10+, cacheSizeBytes must be specified within the cache
- * configuration object (e.g., persistentLocalCache({ cacheSizeBytes })) rather than
- * as a separate Firestore setting. Memory cache doesn't support custom sizes.
- */
-
-import {
-  getFirestore,
-  initializeFirestore,
-  memoryLocalCache,
-  persistentLocalCache,
-  type FirestoreSettings,
-} from 'firebase/firestore';
+import { getFirestore, initializeFirestore, memoryLocalCache } from 'firebase/firestore';
 import type { Firestore } from 'firebase/firestore';
 import type { FirebaseApp } from 'firebase/app';
 
-/**
- * Cache configuration options
- */
-export interface FirestoreCacheConfig {
-  /** Cache size in bytes (default: 10 MB) */
-  cacheSizeBytes?: number;
-  /** Enable persistent cache for web (default: true) */
-  enablePersistentCache?: boolean;
-  /** Force memory-only cache (useful for testing) */
-  forceMemoryCache?: boolean;
-}
-
-/**
- * Default cache configuration
- * Optimized for cost savings while maintaining performance
- */
-const DEFAULT_CACHE_CONFIG: Required<FirestoreCacheConfig> = {
-  cacheSizeBytes: 10 * 1024 * 1024, // 10 MB
-  enablePersistentCache: true,
-  forceMemoryCache: false,
-};
-
-/**
- * Platform detection utilities
- */
-const Platform = {
-  isWeb(): boolean {
-    return typeof window !== 'undefined' && typeof window.indexedDB !== 'undefined';
-  },
-
-  isReactNative(): boolean {
-    return typeof navigator !== 'undefined' && navigator.product === 'ReactNative';
-  },
-
-  isNode(): boolean {
-    return typeof process !== 'undefined' && process.versions?.node !== undefined;
-  },
-};
-
-/**
- * Creates persistent cache configuration for web platforms
- * Uses IndexedDB to cache data across browser sessions
- */
-function createPersistentCacheConfig(config: Required<FirestoreCacheConfig>): FirestoreSettings {
-  try {
-    // Create persistent cache with IndexedDB
-    // Note: cacheSizeBytes must be specified inside the cache object, not as a separate setting
-    const cacheConfig = persistentLocalCache({
-      cacheSizeBytes: config.cacheSizeBytes,
-    });
-
-    return {
-      localCache: cacheConfig,
-    };
-  } catch (error) {
-    // If persistent cache fails, fall back to memory cache
-    if (__DEV__) {
-      console.warn('[Firestore] Persistent cache failed, using memory cache:', error);
-    }
-    return createMemoryCacheConfig(config);
-  }
-}
-
-/**
- * Creates optimized memory cache configuration for React Native
- * Uses memory cache for platforms without IndexedDB support
- */
-function createMemoryCacheConfig(config: Required<FirestoreCacheConfig>): FirestoreSettings {
-  // Memory cache - doesn't support cacheSizeBytes parameter
-  // Note: memoryLocalCache() doesn't accept any parameters
-  const cacheConfig = memoryLocalCache();
-
-  return {
-    localCache: cacheConfig,
-  };
-}
-
-/**
- * Initializes Firestore with optimal caching strategy based on platform
- *
- * @param app - Firebase app instance
- * @param config - Cache configuration options
- * @returns Firestore instance
- *
- * @example
- * ```typescript
- * // Default configuration (recommended)
- * const db = FirebaseFirestoreInitializer.initialize(app);
- *
- * // Custom cache size (20 MB)
- * const db = FirebaseFirestoreInitializer.initialize(app, {
- *   cacheSizeBytes: 20 * 1024 * 1024,
- * });
- *
- * // Force memory cache (testing)
- * const db = FirebaseFirestoreInitializer.initialize(app, {
- *   forceMemoryCache: true,
- * });
- * ```
- */
 export class FirebaseFirestoreInitializer {
-  /**
-   * Initialize Firestore with platform-optimized caching
-   *
-   * Platform Strategy:
-   * - Web: Persistent IndexedDB cache (survives restarts, 90% cost savings)
-   * - React Native: Memory cache
-   * - Node.js: Memory cache for server-side rendering
-   */
-  static initialize(
-    app: FirebaseApp,
-    config: FirestoreCacheConfig = {}
-  ): Firestore {
-    const finalConfig = { ...DEFAULT_CACHE_CONFIG, ...config };
-
+  static initialize(app: FirebaseApp): Firestore {
     try {
-      // Web platform with persistent cache (COST OPTIMIZED)
-      if (!finalConfig.forceMemoryCache && Platform.isWeb()) {
-        try {
-          return initializeFirestore(app, createPersistentCacheConfig(finalConfig));
-        } catch (error) {
-          // IndexedDB may be disabled in private browsing mode
-          // Fall back to memory cache
-          if (__DEV__) {
-            console.warn('[Firestore] Persistent cache failed, using memory cache:', error);
-          }
-          return initializeFirestore(app, createMemoryCacheConfig(finalConfig));
-        }
-      }
-
-      // React Native with memory cache
-      // Note: React Native doesn't support IndexedDB, use memory cache
-      if (Platform.isReactNative()) {
-        return initializeFirestore(app, createMemoryCacheConfig(finalConfig));
-      }
-
-      // Node.js / Server-side with memory cache
-      if (Platform.isNode()) {
-        return initializeFirestore(app, createMemoryCacheConfig(finalConfig));
-      }
-
-      // Fallback: Try persistent cache, fall back to memory
-      return initializeFirestore(app, createPersistentCacheConfig(finalConfig));
-    } catch (error) {
-      // If initialization fails, get existing instance
-      // This handles cases where Firestore is already initialized
-      if (__DEV__) {
-        console.warn('[Firestore] Initialization failed, getting existing instance:', error);
-      }
+      return initializeFirestore(app, { localCache: memoryLocalCache() });
+    } catch {
       return getFirestore(app);
     }
   }
-
-  /**
-   * Initialize Firestore with memory-only cache
-   * Useful for testing or sensitive data that shouldn't be persisted
-   */
-  static initializeWithMemoryCache(
-    app: FirebaseApp,
-    config: Omit<FirestoreCacheConfig, 'enablePersistentCache' | 'forceMemoryCache'> = {}
-  ): Firestore {
-    return this.initialize(app, {
-      ...config,
-      forceMemoryCache: true,
-      enablePersistentCache: false,
-    });
-  }
-
-  /**
-   * Check if persistent cache is available on current platform
-   */
-  static isPersistentCacheAvailable(): boolean {
-    return Platform.isWeb() && typeof window.indexedDB !== 'undefined';
-  }
-
-  /**
-   * Get current cache size in bytes
-   * Note: This is an estimate, actual size may vary
-   */
-  static getEstimatedCacheSize(config: FirestoreCacheConfig = {}): number {
-    return config.cacheSizeBytes ?? DEFAULT_CACHE_CONFIG.cacheSizeBytes;
-  }
-
-  /**
-   * Clear all Firestore caches (useful for logout or data reset)
-   * WARNING: This will clear all cached data and force re-fetch
-   */
-  static async clearPersistentCache(app: FirebaseApp): Promise<void> {
-    try {
-      const db = getFirestore(app);
-      await (db as any).clearPersistentCache();
-      if (__DEV__) {
-        console.log('[Firestore] Persistent cache cleared');
-      }
-    } catch (error) {
-      if (__DEV__) {
-        console.warn('[Firestore] Failed to clear persistent cache:', error);
-      }
-      throw error;
-    }
-  }
-}
-
-/**
- * Cache statistics interface
- */
-export interface CacheStatistics {
-  /** Platform type */
-  platform: 'web' | 'react-native' | 'node' | 'unknown';
-  /** Persistent cache available */
-  persistentCacheAvailable: boolean;
-  /** Current cache size limit */
-  cacheSizeBytes: number;
-  /** Estimated cache usage percentage */
-  estimatedCacheUsage: number;
-}
-
-/**
- * Get cache statistics for monitoring and debugging
- */
-export function getCacheStatistics(): CacheStatistics {
-  const platform = Platform.isWeb()
-    ? 'web'
-    : Platform.isReactNative()
-    ? 'react-native'
-    : Platform.isNode()
-    ? 'node'
-    : 'unknown';
-
-  return {
-    platform,
-    persistentCacheAvailable: FirebaseFirestoreInitializer.isPersistentCacheAvailable(),
-    cacheSizeBytes: FirebaseFirestoreInitializer.getEstimatedCacheSize(),
-    estimatedCacheUsage: 0, // Firestore doesn't expose actual cache size
-  };
 }

package/src/index.ts

@@ -32,7 +32,7 @@ export type {
   ServiceInitializationResult,
 } from "./shared/infrastructure/config/services/FirebaseInitializationService";
 
-export type { FirebaseApp } from "./shared/infrastructure/config/initializers/FirebaseAppInitializer";
+export type { FirebaseApp } from 'firebase/app';
 
 // Type Guards
 export {

package/src/shared/infrastructure/config/clients/FirebaseClientSingleton.ts

@@ -5,7 +5,7 @@
 
 import type { FirebaseConfig } from '../../../domain/value-objects/FirebaseConfig';
 import type { IFirebaseClient } from '../../../../application/ports/IFirebaseClient';
-import type { FirebaseApp } from '../initializers/FirebaseAppInitializer';
+import type { FirebaseApp } from 'firebase/app';
 import { FirebaseClientState } from '../state/FirebaseClientState';
 import { FirebaseInitializationOrchestrator } from '../orchestrators/FirebaseInitializationOrchestrator';
 

package/src/shared/infrastructure/config/services/FirebaseInitializationService.ts

@@ -4,7 +4,7 @@
  */
 
 import type { FirebaseConfig } from '../../../domain/value-objects/FirebaseConfig';
-import type { FirebaseApp } from '../initializers/FirebaseAppInitializer';
+import type { FirebaseApp } from 'firebase/app';
 import { FirebaseClientSingleton } from '../clients/FirebaseClientSingleton';
 import { loadFirebaseConfig } from '../FirebaseConfigLoader';
 

package/src/shared/infrastructure/config/state/FirebaseClientState.ts

@@ -6,7 +6,7 @@
  * Uses generic ClientStateManager for shared functionality
  */
 
-import type { FirebaseApp } from '../initializers/FirebaseAppInitializer';
+import type { FirebaseApp } from 'firebase/app';
 import { ClientStateManager } from '../base/ClientStateManager';
 
 export class FirebaseClientState extends ClientStateManager<FirebaseApp> {

package/src/shared/infrastructure/config/initializers/FirebaseAppInitializer.ts

@@ -1,9 +0,0 @@
-/**
- * Firebase App Initializer
- *
- * Single Responsibility: Expose Firebase App type
- */
-
-import type { FirebaseApp as FirebaseAppType } from 'firebase/app';
-
-export type FirebaseApp = FirebaseAppType;