@umituz/react-native-firebase 3.0.12 → 3.0.14

package/package.json

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

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

@@ -1,261 +1,41 @@
 /**
- * Firebase Firestore Initializer (Enhanced)
+ * Firebase Firestore Initializer for React Native
  *
- * Single Responsibility: Initialize Firestore instance with optimal caching
- *
- * OPTIMIZATIONS:
- * - Web: Persistent IndexedDB cache (survives restarts)
- * - React Native: Optimized memory cache
- * - Configurable cache size limits (10 MB default)
- * - Platform-aware cache strategy
- *
- * COST SAVINGS: ~90% reduction in network reads through persistent caching
+ * Simple initialization for Firestore in React Native apps.
  */
 
-import {
-  getFirestore,
-  initializeFirestore,
-  memoryLocalCache,
-  persistentLocalCache,
-  type FirestoreSettings,
-} from 'firebase/firestore';
+import { getFirestore, initializeFirestore } 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 is deprecated, must be specified in cache object
-    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 - Firebase SDK manages cache size automatically
-  const cacheConfig = memoryLocalCache();
-
-  return {
-    localCache: cacheConfig,
-  };
-}
-
-/**
- * Initializes Firestore with optimal caching strategy based on platform
+ * Initializes Firestore for React Native
  *
  * @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,
- * });
+ * import { initializeApp } from 'firebase/app';
+ * import { FirebaseFirestoreInitializer } from '@umituz/react-native-firebase/firestore';
  *
- * // Force memory cache (testing)
- * const db = FirebaseFirestoreInitializer.initialize(app, {
- *   forceMemoryCache: true,
- * });
+ * const app = initializeApp(firebaseConfig);
+ * const db = FirebaseFirestoreInitializer.initialize(app);
  * ```
  */
 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
+   * Initialize Firestore
    */
-  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));
+      return initializeFirestore(app, {});
     } 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);
+        console.warn('[Firestore] Using existing instance:', error);
       }
       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);
-      // clearPersistentCache exists in Firestore SDK but not in TypeScript definitions
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      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
-  };
 }