@umituz/react-native-firebase 2.4.97 → 2.5.1

package/src/domains/firestore/domain/constants/QuotaLimits.ts

@@ -1,101 +0,0 @@
-/**
- * Quota Limit Constants
- * Domain layer - Default Firestore quota limits
- *
- * General-purpose constants for any app using Firestore
- * Based on Firestore free tier and pricing documentation
- */
-
-import { calculatePercentage, calculateRemaining } from '../../../../shared/domain/utils/calculation.util';
-
-/**
- * Firestore free tier daily limits
- * https://firebase.google.com/docs/firestore/quotas
- */
-export const FREE_TIER_LIMITS = {
-  /**
-   * Daily read operations (documents)
-   * Free tier: 50,000 reads/day
-   */
-  DAILY_READS: 50_000,
-
-  /**
-   * Daily write operations (documents)
-   * Free tier: 20,000 writes/day
-   */
-  DAILY_WRITES: 20_000,
-
-  /**
-   * Daily delete operations (documents)
-   * Free tier: 20,000 deletes/day
-   */
-  DAILY_DELETES: 20_000,
-
-  /**
-   * Stored data (GB)
-   * Free tier: 1 GB
-   */
-  STORAGE_GB: 1,
-} as const;
-
-/**
- * Quota warning thresholds (percentage of limit)
- * Apps can use these to show warnings before hitting limits
- */
-export const QUOTA_THRESHOLDS = {
-  /**
-   * Warning threshold (80% of limit)
-   * Show warning to user
-   */
-  WARNING: 0.8,
-
-  /**
-   * Critical threshold (95% of limit)
-   * Show critical alert, consider disabling features
-   */
-  CRITICAL: 0.95,
-
-  /**
-   * Emergency threshold (98% of limit)
-   * Disable non-essential features
-   */
-  EMERGENCY: 0.98,
-} as const;
-
-/**
- * Calculate quota usage percentage
- * Optimized: Uses centralized calculation utility
- * @param current - Current usage count
- * @param limit - Total limit
- * @returns Percentage (0-1)
- */
-export function calculateQuotaUsage(current: number, limit: number): number {
-  return calculatePercentage(current, limit);
-}
-
-/**
- * Check if quota threshold is reached
- * @param current - Current usage count
- * @param limit - Total limit
- * @param threshold - Threshold to check (0-1)
- * @returns true if threshold is reached
- */
-export function isQuotaThresholdReached(
-  current: number,
-  limit: number,
-  threshold: number,
-): boolean {
-  const usage = calculateQuotaUsage(current, limit);
-  return usage >= threshold;
-}
-
-/**
- * Get remaining quota
- * Optimized: Uses centralized calculation utility
- * @param current - Current usage count
- * @param limit - Total limit
- * @returns Remaining quota count
- */
-export function getRemainingQuota(current: number, limit: number): number {
-  return calculateRemaining(current, limit);
-}

package/src/domains/firestore/domain/entities/QuotaMetrics.ts

@@ -1,26 +0,0 @@
-/**
- * Quota Metrics Types
- */
-
-export interface QuotaMetrics {
-    readCount: number;
-    writeCount: number;
-    deleteCount: number;
-    lastResetDate: string;
-}
-
-export interface QuotaLimits {
-    dailyReadLimit: number;
-    dailyWriteLimit: number;
-    dailyDeleteLimit: number;
-}
-
-export interface QuotaStatus {
-    metrics: QuotaMetrics;
-    limits: QuotaLimits;
-    readPercentage: number;
-    writePercentage: number;
-    deletePercentage: number;
-    isNearLimit: boolean;
-    isOverLimit: boolean;
-}

package/src/domains/firestore/domain/entities/RequestLog.ts

@@ -1,28 +0,0 @@
-/**
- * Request Log Types
- */
-
-export type RequestType = 'read' | 'write' | 'delete' | 'listener';
-
-export interface RequestLog {
-    id: string;
-    type: RequestType;
-    collection: string;
-    documentId?: string;
-    cached: boolean;
-    success: boolean;
-    error?: string;
-    duration?: number;
-    timestamp: number;
-}
-
-export interface RequestStats {
-    totalRequests: number;
-    readRequests: number;
-    writeRequests: number;
-    deleteRequests: number;
-    listenerRequests: number;
-    cachedRequests: number;
-    failedRequests: number;
-    averageDuration: number;
-}

package/src/domains/firestore/domain/services/QuotaCalculator.ts

@@ -1,71 +0,0 @@
-/**
- * Quota Calculator Service
- * Domain service for calculating quota usage and status
- */
-
-import type { QuotaMetrics, QuotaLimits, QuotaStatus } from '../entities/QuotaMetrics';
-import { FREE_TIER_LIMITS, QUOTA_THRESHOLDS, calculateQuotaUsage } from '../constants/QuotaLimits';
-
-/**
- * Default quota limits (Firebase Spark Plan)
- * Can be overridden via configuration
- */
-const DEFAULT_QUOTA_LIMITS: QuotaLimits = {
-  dailyReadLimit: FREE_TIER_LIMITS.DAILY_READS,
-  dailyWriteLimit: FREE_TIER_LIMITS.DAILY_WRITES,
-  dailyDeleteLimit: FREE_TIER_LIMITS.DAILY_DELETES,
-};
-
-export class QuotaCalculator {
-  /**
-   * Calculate quota status from metrics and limits
-   */
-  static calculateStatus(
-    metrics: QuotaMetrics,
-    limits: QuotaLimits = DEFAULT_QUOTA_LIMITS,
-  ): QuotaStatus {
-    const readPercentage = calculateQuotaUsage(metrics.readCount, limits.dailyReadLimit) * 100;
-    const writePercentage = calculateQuotaUsage(metrics.writeCount, limits.dailyWriteLimit) * 100;
-    const deletePercentage = calculateQuotaUsage(metrics.deleteCount, limits.dailyDeleteLimit) * 100;
-
-    const warningThreshold = QUOTA_THRESHOLDS.WARNING * 100;
-    const isNearLimit =
-      readPercentage >= warningThreshold ||
-      writePercentage >= warningThreshold ||
-      deletePercentage >= warningThreshold;
-
-    const isOverLimit =
-      readPercentage >= 100 ||
-      writePercentage >= 100 ||
-      deletePercentage >= 100;
-
-    return {
-      metrics,
-      limits,
-      readPercentage,
-      writePercentage,
-      deletePercentage,
-      isNearLimit,
-      isOverLimit,
-    };
-  }
-
-  /**
-   * Get default quota limits
-   */
-  static getDefaultLimits(): QuotaLimits {
-    return { ...DEFAULT_QUOTA_LIMITS };
-  }
-
-  /**
-   * Check if metrics are within limits
-   */
-  static isWithinLimits(
-    metrics: QuotaMetrics,
-    limits: QuotaLimits = DEFAULT_QUOTA_LIMITS,
-  ): boolean {
-    const status = this.calculateStatus(metrics, limits);
-    return !status.isOverLimit;
-  }
-}
-

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

@@ -1,312 +0,0 @@
-/**
- * Query Deduplication Middleware (Enhanced)
- *
- * Prevents duplicate Firestore queries within a configurable time window
- * with quota-aware adaptive deduplication
- *
- * FEATURES:
- * - Configurable deduplication window (default: 10s, was 1s)
- * - Quota-aware adaptive window adjustment
- * - Statistics and monitoring
- * - Memory leak prevention
- * - Automatic cleanup optimization
- *
- * COST SAVINGS: ~90% reduction in duplicate query reads
- */
-
-import type { QueryKey } from '../../utils/deduplication/query-key-generator.util';
-import { generateQueryKey } from '../../utils/deduplication/query-key-generator.util';
-import { PendingQueryManager } from '../../utils/deduplication/pending-query-manager.util';
-import { TimerManager } from '../../utils/deduplication/timer-manager.util';
-
-/**
- * Default configuration
- * Optimized for cost savings while maintaining freshness
- */
-const DEFAULT_DEDUPLICATION_WINDOW_MS = 10000;  // 10s (was 1s)
-const DEFAULT_CLEANUP_INTERVAL_MS = 15000;       // 15s (was 3s)
-
-/**
- * Quota-based window adjustment thresholds
- */
-const QUOTA_THRESHOLDS = {
-  HIGH_USAGE: 0.80,   // 80% - extend window to 60s (1 min)
-  MEDIUM_USAGE: 0.60, // 60% - extend window to 20s
-  NORMAL: 0.50,       // < 50% - use default 10s
-} as const;
-
-/**
- * Deduplication statistics
- */
-export interface DeduplicationStatistics {
-  /** Total queries processed */
-  totalQueries: number;
-  /** Queries served from cache (deduplicated) */
-  cachedQueries: number;
-  /** Queries executed (not cached) */
-  executedQueries: number;
-  /** Current deduplication window in ms */
-  currentWindowMs: number;
-  /** Cache hit rate (0-1) */
-  cacheHitRate: number;
-  /** Memory usage (number of cached queries) */
-  pendingQueries: number;
-}
-
-/**
- * Configuration options for deduplication middleware
- */
-export interface QueryDeduplicationConfig {
-  /** Base deduplication window in ms (default: 10000) */
-  baseWindowMs?: number;
-  /** Cleanup interval in ms (default: 15000) */
-  cleanupIntervalMs?: number;
-  /** Enable quota-aware adaptive window (default: true) */
-  quotaAware?: boolean;
-  /** Maximum window size in ms (default: 60000 = 1 minute) */
-  maxWindowMs?: number;
-  /** Minimum window size in ms (default: 1000 = 1 second) */
-  minWindowMs?: number;
-}
-
-/**
- * Enhanced Query Deduplication Middleware
- * Prevents duplicate queries with adaptive quota-aware behavior
- */
-export class QueryDeduplicationMiddleware {
-  private readonly queryManager: PendingQueryManager;
-  private readonly timerManager: TimerManager;
-  private readonly baseWindowMs: number;
-  private readonly maxWindowMs: number;
-  private readonly minWindowMs: number;
-  private readonly quotaAware: boolean;
-  private destroyed = false;
-
-  // Statistics tracking
-  private stats: DeduplicationStatistics = {
-    totalQueries: 0,
-    cachedQueries: 0,
-    executedQueries: 0,
-    currentWindowMs: DEFAULT_DEDUPLICATION_WINDOW_MS,
-    cacheHitRate: 0,
-    pendingQueries: 0,
-  };
-
-  constructor(config: QueryDeduplicationConfig = {}) {
-    this.baseWindowMs = config.baseWindowMs ?? DEFAULT_DEDUPLICATION_WINDOW_MS;
-    this.maxWindowMs = config.maxWindowMs ?? 60000; // 1 minute max
-    this.minWindowMs = config.minWindowMs ?? 1000; // 1 second min
-    this.quotaAware = config.quotaAware ?? true;
-
-    const cleanupIntervalMs = config.cleanupIntervalMs ?? DEFAULT_CLEANUP_INTERVAL_MS;
-
-    this.queryManager = new PendingQueryManager(this.baseWindowMs);
-    this.timerManager = new TimerManager({
-      cleanupIntervalMs,
-      onCleanup: () => {
-        if (!this.destroyed) {
-          this.queryManager.cleanup();
-          this.updateStats();
-        }
-      },
-    });
-    this.timerManager.start();
-  }
-
-  /**
-   * Execute query with deduplication
-   * Returns cached result if available within window, otherwise executes
-   */
-  async deduplicate<T>(
-    queryKey: QueryKey,
-    queryFn: () => Promise<T>,
-  ): Promise<T> {
-    if (this.destroyed) {
-      // If middleware is destroyed, execute query directly without deduplication
-      return queryFn();
-    }
-
-    this.stats.totalQueries++;
-    const key = generateQueryKey(queryKey);
-
-    // Check for existing promise (atomic get-or-create pattern)
-    const existingPromise = this.queryManager.get(key);
-    if (existingPromise) {
-      this.stats.cachedQueries++;
-      this.updateCacheHitRate();
-      return existingPromise as Promise<T>;
-    }
-
-    // Create promise with cleanup on completion
-    this.stats.executedQueries++;
-    const promise = (async () => {
-      try {
-        return await queryFn();
-      } finally {
-        // Immediate cleanup after completion (success or error)
-        this.queryManager.remove(key);
-        this.stats.pendingQueries = this.queryManager.size();
-      }
-    })();
-
-    // Add before any await - this prevents race between check and add
-    this.queryManager.add(key, promise);
-    this.stats.pendingQueries = this.queryManager.size();
-
-    return promise;
-  }
-
-  /**
-   * Adjust deduplication window based on quota usage
-   * Call this periodically with current quota percentage
-   *
-   * @param quotaPercentage - Current quota usage (0-1)
-   *
-   * @example
-   * ```typescript
-   * const quotaStatus = getQuotaStatus();
-   * middleware.adjustWindowForQuota(quotaStatus.readPercentage / 100);
-   * ```
-   */
-  adjustWindowForQuota(quotaPercentage: number): void {
-    if (!this.quotaAware || this.destroyed) {
-      return;
-    }
-
-    let newWindowMs: number;
-
-    if (quotaPercentage >= QUOTA_THRESHOLDS.HIGH_USAGE) {
-      // High usage: extend window to maximum (1 minute)
-      newWindowMs = this.maxWindowMs;
-    } else if (quotaPercentage >= QUOTA_THRESHOLDS.MEDIUM_USAGE) {
-      // Medium usage: extend window to 20s
-      newWindowMs = Math.min(20000, this.maxWindowMs);
-    } else {
-      // Normal usage: use base window (10s)
-      newWindowMs = this.baseWindowMs;
-    }
-
-    // Clamp to min/max bounds
-    newWindowMs = Math.max(this.minWindowMs, Math.min(newWindowMs, this.maxWindowMs));
-
-    // Only update if changed
-    if (newWindowMs !== this.stats.currentWindowMs) {
-      this.queryManager.setWindow(newWindowMs);
-      this.stats.currentWindowMs = newWindowMs;
-
-      if (__DEV__) {
-        console.log(
-          `[Deduplication] Adjusted window to ${newWindowMs}ms ` +
-          `(quota: ${(quotaPercentage * 100).toFixed(1)}%)`
-        );
-      }
-    }
-  }
-
-  /**
-   * Get current deduplication statistics
-   */
-  getStatistics(): DeduplicationStatistics {
-    return { ...this.stats };
-  }
-
-  /**
-   * Reset statistics
-   */
-  resetStatistics(): void {
-    this.stats = {
-      totalQueries: 0,
-      cachedQueries: 0,
-      executedQueries: 0,
-      currentWindowMs: this.stats.currentWindowMs,
-      cacheHitRate: 0,
-      pendingQueries: this.queryManager.size(),
-    };
-  }
-
-  /**
-   * Update cache hit rate
-   */
-  private updateCacheHitRate(): void {
-    this.stats.cacheHitRate =
-      this.stats.totalQueries > 0
-        ? this.stats.cachedQueries / this.stats.totalQueries
-        : 0;
-  }
-
-  /**
-   * Update statistics
-   */
-  private updateStats(): void {
-    this.stats.pendingQueries = this.queryManager.size();
-    this.updateCacheHitRate();
-  }
-
-  /**
-   * Clear all cached queries
-   */
-  clear(): void {
-    this.queryManager.clear();
-    this.stats.pendingQueries = 0;
-  }
-
-  /**
-   * Destroy middleware and cleanup resources
-   */
-  destroy(): void {
-    this.destroyed = true;
-    this.timerManager.destroy();
-    this.queryManager.clear();
-    this.stats.pendingQueries = 0;
-  }
-
-  /**
-   * Get number of pending queries
-   */
-  getPendingCount(): number {
-    return this.queryManager.size();
-  }
-}
-
-/**
- * Default singleton instance with recommended settings
- */
-export const queryDeduplicationMiddleware = new QueryDeduplicationMiddleware({
-  baseWindowMs: DEFAULT_DEDUPLICATION_WINDOW_MS,
-  cleanupIntervalMs: DEFAULT_CLEANUP_INTERVAL_MS,
-  quotaAware: true,
-  maxWindowMs: 60000, // 1 minute
-  minWindowMs: 1000,  // 1 second
-});
-
-/**
- * Helper function to integrate deduplication with quota tracking
- * Automatically adjusts window based on quota usage
- *
- * Note: This is NOT a React hook, but a helper function.
- * Call this from your own hook or effect as needed.
- *
- * @example
- * ```typescript
- * // In your own hook or component:
- * useEffect(() => {
- *   syncDeduplicationWithQuota(queryDeduplicationMiddleware, quotaMiddleware, quotaLimits);
- * }, [quotaMiddleware.getCounts().reads]);
- * ```
- */
-export function syncDeduplicationWithQuota(
-  deduplication: QueryDeduplicationMiddleware,
-  quotaMiddleware: { getCounts: () => { reads: number; writes: number; deletes: number } },
-  quotaLimits: { dailyReadLimit: number }
-): void {
-  // Adjust deduplication window based on quota
-  const counts = quotaMiddleware.getCounts();
-  const quotaPercentage = counts.reads / quotaLimits.dailyReadLimit;
-  deduplication.adjustWindowForQuota(quotaPercentage);
-}
-
-/**
- * @deprecated Use syncDeduplicationWithQuota instead (not a hook)
- * This will be removed in a future version
- */
-export const useDeduplicationWithQuota = syncDeduplicationWithQuota;

package/src/domains/firestore/infrastructure/middleware/QuotaTrackingMiddleware.ts

@@ -1,95 +0,0 @@
-/**
- * Quota Tracking Middleware
- * Tracks Firestore operations for quota monitoring
- */
-
-interface OperationInfo {
-    type: 'read' | 'write' | 'delete';
-    collection: string;
-    count: number;
-    cached: boolean;
-}
-
-export class QuotaTrackingMiddleware {
-    private readCount = 0;
-    private writeCount = 0;
-    private deleteCount = 0;
-
-    /**
-     * Track a Firestore operation
-     */
-    async trackOperation<T>(
-        info: OperationInfo,
-        operation: () => Promise<T>
-    ): Promise<T> {
-        try {
-            return await operation();
-        } finally {
-            switch (info.type) {
-                case 'read':
-                    if (!info.cached) {
-                        this.readCount += info.count;
-                    }
-                    break;
-                case 'write':
-                    this.writeCount += info.count;
-                    break;
-                case 'delete':
-                    this.deleteCount += info.count;
-                    break;
-            }
-        }
-    }
-
-    /**
-     * Track read operation
-     * @param _collection - Collection name (reserved for future per-collection tracking)
-     * @param count - Number of documents read
-     * @param cached - Whether result was from cache
-     */
-    trackRead(_collection: string, count: number = 1, cached: boolean = false): void {
-        if (!cached) {
-            this.readCount += count;
-        }
-    }
-
-    /**
-     * Track write operation
-     * @param _collection - Collection name (reserved for future per-collection tracking)
-     * @param count - Number of documents written
-     */
-    trackWrite(_collection: string, count: number = 1): void {
-        this.writeCount += count;
-    }
-
-    /**
-     * Track delete operation
-     * @param _collection - Collection name (reserved for future per-collection tracking)
-     * @param count - Number of documents deleted
-     */
-    trackDelete(_collection: string, count: number = 1): void {
-        this.deleteCount += count;
-    }
-
-    /**
-     * Get current counts
-     */
-    getCounts(): { reads: number; writes: number; deletes: number } {
-        return {
-            reads: this.readCount,
-            writes: this.writeCount,
-            deletes: this.deleteCount,
-        };
-    }
-
-    /**
-     * Reset counts
-     */
-    reset(): void {
-        this.readCount = 0;
-        this.writeCount = 0;
-        this.deleteCount = 0;
-    }
-}
-
-export const quotaTrackingMiddleware = new QuotaTrackingMiddleware();