@umituz/react-native-firebase 3.0.11 → 3.0.13

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@umituz/react-native-firebase",
-  "version": "3.0.11",
-  "description": "Unified Firebase package for React Native apps - Auth and Firestore services using Firebase JS SDK (no native modules).",
+  "version": "3.0.13",
+  "description": "Firebase package for React Native mobile apps - Auth and Firestore services using Firebase JS SDK. No web or Node.js support. Memory-only caching (no IndexedDB).",
   "main": "./src/index.ts",
   "types": "./src/index.ts",
   "scripts": {

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

@@ -1,259 +1,141 @@
 /**
- * Firebase Firestore Initializer (Enhanced)
+ * Firebase Firestore Initializer for React Native
  *
- * Single Responsibility: Initialize Firestore instance with optimal caching
+ * Single Responsibility: Initialize Firestore instance with memory caching
  *
- * OPTIMIZATIONS:
- * - Web: Persistent IndexedDB cache (survives restarts)
- * - React Native: Optimized memory cache
- * - Configurable cache size limits (10 MB default)
- * - Platform-aware cache strategy
+ * IMPORTANT: This package is designed for React Native mobile applications ONLY.
+ * - No web support
+ * - No Node.js support
+ * - No IndexedDB (idb package) support
+ * - Memory-only caching for optimal performance
  *
- * COST SAVINGS: ~90% reduction in network reads through persistent caching
+ * React Native does not support IndexedDB, so we use Firebase's memory cache.
  */
 
 import {
   getFirestore,
   initializeFirestore,
   memoryLocalCache,
-  persistentLocalCache,
-  type FirestoreSettings,
 } from 'firebase/firestore';
 import type { Firestore } from 'firebase/firestore';
 import type { FirebaseApp } from 'firebase/app';
 
 /**
- * Cache configuration options
+ * Firestore configuration options for React Native
  */
-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;
+export interface FirestoreConfig {
+  /** Custom settings to pass to Firestore */
+  settings?: {
+    cacheSizeBytes?: number;
+    ignoreUndefinedProperties?: boolean;
+  };
 }
 
 /**
- * Default cache configuration
- * Optimized for cost savings while maintaining performance
+ * Default configuration for React Native
  */
-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;
+const DEFAULT_CONFIG: Required<FirestoreConfig> = {
+  settings: {
+    cacheSizeBytes: 10 * 1024 * 1024, // 10 MB
+    ignoreUndefinedProperties: true,
   },
 };
 
 /**
- * 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
+ * Creates memory cache configuration for React Native
+ *
+ * React Native uses memory cache because:
+ * 1. IndexedDB is not supported in React Native
+ * 2. The idb package causes import errors in React Native
+ * 3. Memory cache is sufficient for mobile app use cases
  */
-function createMemoryCacheConfig(config: Required<FirestoreCacheConfig>): FirestoreSettings {
-  // Memory cache - Firebase SDK manages cache size automatically
-  const cacheConfig = memoryLocalCache();
-
+function createMemoryCacheConfig() {
   return {
-    localCache: cacheConfig,
+    localCache: memoryLocalCache(),
   };
 }
 
 /**
- * Initializes Firestore with optimal caching strategy based on platform
+ * Initializes Firestore for React Native with memory caching
  *
  * @param app - Firebase app instance
- * @param config - Cache configuration options
+ * @param config - Optional configuration
  * @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
+   * Initialize Firestore with memory cache for React Native
    *
-   * Platform Strategy:
-   * - Web: Persistent IndexedDB cache (survives restarts, 90% cost savings)
-   * - React Native: Memory cache
-   * - Node.js: Memory cache for server-side rendering
+   * This is the recommended way to initialize Firestore in React Native apps.
+   * Uses memory cache to avoid idb package import errors.
    */
   static initialize(
     app: FirebaseApp,
-    config: FirestoreCacheConfig = {}
+    config: FirestoreConfig = {}
   ): Firestore {
-    const finalConfig = { ...DEFAULT_CACHE_CONFIG, ...config };
+    const finalConfig = { ...DEFAULT_CONFIG, ...config };
 
     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));
+      // Initialize Firestore with memory cache
+      const settings = createMemoryCacheConfig();
+      return initializeFirestore(app, settings);
     } 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] Initialization 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
+   * Clear Firestore cache
+   * Useful for logout or data reset scenarios
+   *
+   * NOTE: With memory cache, this clears in-memory cached data
    */
-  static async clearPersistentCache(app: FirebaseApp): Promise<void> {
+  static async clearCache(app: FirebaseApp): Promise<void> {
     try {
       const db = getFirestore(app);
-      await (db as any).clearPersistentCache();
-      if (__DEV__) {
-        console.log('[Firestore] Persistent cache cleared');
+      // clearPersistentCache may exist in some Firebase SDK versions
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      if (typeof (db as any).clearPersistentCache === 'function') {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        await (db as any).clearPersistentCache();
+        if (__DEV__) {
+          console.log('[Firestore] Cache cleared successfully');
+        }
+      } else {
+        if (__DEV__) {
+          console.log('[Firestore] Memory cache does not support explicit clearing');
+        }
       }
     } catch (error) {
       if (__DEV__) {
-        console.warn('[Firestore] Failed to clear persistent cache:', error);
+        console.warn('[Firestore] Cache clearing failed:', error);
       }
-      throw error;
+      // Don't throw - cache clearing is not critical
     }
   }
 }
 
 /**
- * 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
+ * Get current Firestore instance
+ * Shortcut for getFirestore from Firebase SDK
+ *
+ * @param app - Firebase app instance
+ * @returns Firestore instance
  */
-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
-  };
+export function getFirestoreInstance(app: FirebaseApp): Firestore {
+  return getFirestore(app);
 }