@umituz/react-native-firebase 2.4.97 → 2.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-firebase",
-  "version": "2.4.97",
+  "version": "2.5.1",
   "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/index.ts

@@ -59,61 +59,6 @@ export type {
 } from './types/pagination.types';
 export { EMPTY_PAGINATED_RESULT } from './types/pagination.types';
 
-// Domain Constants
-export {
-  FREE_TIER_LIMITS,
-  QUOTA_THRESHOLDS,
-  calculateQuotaUsage,
-  isQuotaThresholdReached,
-  getRemainingQuota,
-} from './domain/constants/QuotaLimits';
-
-// Domain Entities
-export type {
-  QuotaMetrics,
-  QuotaLimits,
-  QuotaStatus,
-} from './domain/entities/QuotaMetrics';
-export type {
-  RequestLog,
-  RequestStats,
-  RequestType,
-} from './domain/entities/RequestLog';
-
-// Domain Services
-export { QuotaCalculator } from './domain/services/QuotaCalculator';
-
-// Quota Error Detection
-export {
-  isQuotaError,
-  isRetryableError,
-} from '../../shared/domain/utils/error-handlers/error-checkers';
-export {
-  getQuotaErrorMessage,
-} from '../../shared/domain/utils/error-handlers/error-messages';
-
-// Middleware
-export {
-  QueryDeduplicationMiddleware,
-  queryDeduplicationMiddleware,
-  syncDeduplicationWithQuota,
-  useDeduplicationWithQuota,
-} from './infrastructure/middleware/QueryDeduplicationMiddleware';
-export type {
-  QueryDeduplicationConfig,
-  DeduplicationStatistics,
-} from './infrastructure/middleware/QueryDeduplicationMiddleware';
-export {
-  QuotaTrackingMiddleware,
-  quotaTrackingMiddleware,
-} from './infrastructure/middleware/QuotaTrackingMiddleware';
-
-// Services
-export {
-  RequestLoggerService,
-  requestLoggerService,
-} from './infrastructure/services/RequestLoggerService';
-
 // Firestore Helper Utilities
 export {
   withFirestore,
@@ -150,13 +95,10 @@ export {
 export { useFirestoreQuery } from './presentation/hooks/useFirestoreQuery';
 export { useFirestoreMutation } from './presentation/hooks/useFirestoreMutation';
 export { useFirestoreSnapshot } from './presentation/hooks/useFirestoreSnapshot';
-export { useSmartFirestoreSnapshot, useSmartListenerControl } from './presentation/hooks/useSmartFirestoreSnapshot';
-export { createFirestoreKeys } from './presentation/query-keys/createFirestoreKeys';
 
 export type { UseFirestoreQueryOptions } from './presentation/hooks/useFirestoreQuery';
 export type { UseFirestoreMutationOptions } from './presentation/hooks/useFirestoreMutation';
 export type { UseFirestoreSnapshotOptions } from './presentation/hooks/useFirestoreSnapshot';
-export type { UseSmartFirestoreSnapshotOptions, BackgroundStrategy } from './presentation/hooks/useSmartFirestoreSnapshot';
 
 // Firebase types are available from the 'firebase' package directly
 // Import them in your app: import { Timestamp } from 'firebase/firestore';

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/domains/firestore/infrastructure/repositories/BasePaginatedRepository.ts

@@ -43,11 +43,9 @@ export abstract class BasePaginatedRepository extends BaseQueryRepository {
 
     const collectionRef = collection(db, collectionName);
     let q: import("firebase/firestore").Query<DocumentData>;
-    let cursorKey = 'start';
 
     // Handle cursor-based pagination
     if (helper.hasCursor(params) && params?.cursor) {
-      cursorKey = params.cursor;
 
       // FIX: Validate cursor and throw error instead of silent failure
       validateCursorOrThrow(params.cursor);
@@ -77,17 +75,13 @@ export abstract class BasePaginatedRepository extends BaseQueryRepository {
       );
     }
 
-    // Generate a unique key for deduplication (after cursor is resolved)
-    const uniqueKey = `${collectionName}_list_${orderByField}_${orderDirection}_${fetchLimit}_${cursorKey}`;
-
     return this.executeQuery(
       collectionName,
       async () => {
         const snapshot = await getDocs(q);
         return snapshot.docs;
       },
-      false,
-      uniqueKey
+      false
     );
   }
 

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

@@ -1,44 +1,18 @@
-/**
- * Base Repository - Query Operations
- *
- * Provides query and tracking operations for Firestore repositories.
- * Extends BaseRepository with query-specific functionality.
- */
-
-import { queryDeduplicationMiddleware } from "../middleware/QueryDeduplicationMiddleware";
-import { BaseRepository } from "./BaseRepository";
+import { BaseRepository } from './BaseRepository';
 
 export abstract class BaseQueryRepository extends BaseRepository {
-  /**
-   * Execute query with deduplication and quota tracking
-   * Prevents duplicate queries and tracks quota usage
-   */
   protected async executeQuery<T>(
     collection: string,
     queryFn: () => Promise<T>,
-    cached: boolean = false,
-    uniqueKey?: string
+    cached: boolean = false
   ): Promise<T> {
-    const safeKey = uniqueKey || `${collection}_query`;
-
-    const queryKey = {
-      collection,
-      filters: safeKey,
-      limit: undefined,
-      orderBy: undefined,
-    };
-
-    return queryDeduplicationMiddleware.deduplicate(queryKey, async () => {
-      const result = await queryFn();
+    const result = await queryFn();
 
-      // Optimize: Only calculate count if tracking is needed
-      // Check if quota tracking is enabled before computing array length
-      if (!cached) {
-        const count = Array.isArray(result) ? result.length : 1;
-        this.trackRead(collection, count, cached);
-      }
+    if (!cached) {
+      const count = Array.isArray(result) ? result.length : 1;
+      this.trackRead(collection, count, cached);
+    }
 
-      return result;
-    });
+    return result;
   }
 }

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

@@ -10,9 +10,6 @@
 
 import type { Firestore, CollectionReference, DocumentReference, DocumentData } from 'firebase/firestore';
 import { getFirestore, collection, doc } from 'firebase/firestore';
-import { isQuotaError as checkQuotaError } from '../../../../shared/domain/utils/error-handlers/error-checkers';
-import { ERROR_MESSAGES } from '../../../../shared/domain/utils/error-handlers/error-messages';
-import { quotaTrackingMiddleware } from '../middleware/QuotaTrackingMiddleware';
 
 enum RepositoryState {
   ACTIVE = 'active',
@@ -49,11 +46,11 @@ export abstract class BaseRepository implements IPathResolver {
    */
   protected getDbOrThrow(): Firestore {
     if (this.state === RepositoryState.DESTROYED) {
-      throw new Error(ERROR_MESSAGES.REPOSITORY.DESTROYED);
+      throw new Error('Repository is destroyed');
     }
     const db = getFirestore();
     if (!db) {
-      throw new Error(ERROR_MESSAGES.FIRESTORE.NOT_INITIALIZED);
+      throw new Error('Firestore is not initialized');
     }
     return db;
   }
@@ -107,55 +104,19 @@ export abstract class BaseRepository implements IPathResolver {
   protected async executeOperation<T>(
     operation: () => Promise<T>
   ): Promise<T> {
-    try {
-      return await operation();
-    } catch (error) {
-      if (checkQuotaError(error)) {
-        throw new Error(ERROR_MESSAGES.FIRESTORE.QUOTA_EXCEEDED);
-      }
-      throw error;
-    }
+    return await operation();
   }
 
-  /**
-   * Track read operation for quota monitoring
-   *
-   * @param collection - Collection name
-   * @param count - Number of documents read
-   * @param cached - Whether the result is from cache
-   */
-  protected trackRead(
-    collection: string,
-    count: number = 1,
-    cached: boolean = false,
-  ): void {
-    quotaTrackingMiddleware.trackRead(collection, count, cached);
+  protected trackRead(_collection: string, _count: number = 1, _cached: boolean = false): void {
+    // Quota tracking removed - use Firebase console for monitoring
   }
 
-  /**
-   * Track write operation for quota monitoring
-   *
-   * @param collection - Collection name
-   * @param count - Number of documents written
-   */
-  protected trackWrite(
-    collection: string,
-    count: number = 1,
-  ): void {
-    quotaTrackingMiddleware.trackWrite(collection, count);
+  protected trackWrite(_collection: string, _count: number = 1): void {
+    // Quota tracking removed - use Firebase console for monitoring
   }
 
-  /**
-   * Track delete operation for quota monitoring
-   *
-   * @param collection - Collection name
-   * @param count - Number of documents deleted
-   */
-  protected trackDelete(
-    collection: string,
-    count: number = 1,
-  ): void {
-    quotaTrackingMiddleware.trackDelete(collection, count);
+  protected trackDelete(_collection: string, _count: number = 1): void {
+    // Quota tracking removed - use Firebase console for monitoring
   }
 
   /**

package/src/domains/firestore/presentation/hooks/index.ts

@@ -12,13 +12,3 @@ export {
   useFirestoreSnapshot,
   type UseFirestoreSnapshotOptions,
 } from './useFirestoreSnapshot';
-
-export {
-  useSmartFirestoreSnapshot,
-  useSmartListenerControl,
-} from './useSmartFirestoreSnapshot';
-
-export type {
-  UseSmartFirestoreSnapshotOptions,
-  BackgroundStrategy,
-} from './useSmartFirestoreSnapshot';

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> {