@umituz/react-native-firebase 2.4.100 → 2.5.1

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();

package/src/domains/firestore/infrastructure/services/RequestLoggerService.ts

@@ -1,165 +0,0 @@
-/**
- * Request Logger Service
- * Infrastructure service for logging Firestore requests
- */
-
-import type { RequestLog, RequestStats, RequestType } from '../../domain/entities/RequestLog';
-import { generateUUID } from '@umituz/react-native-design-system/uuid';
-
-/**
- * Maximum number of logs to keep in memory
- * Prevents unbounded memory growth
- */
-export const DEFAULT_MAX_LOGS = 1000;
-
-export class RequestLoggerService {
-  private logs: RequestLog[] = [];
-  private readonly maxLogs: number;
-  private listeners: Set<(log: RequestLog) => void> = new Set();
-  private static readonly LISTENER_ERROR_PREFIX = '[RequestLoggerService] Listener error:';
-
-  constructor(maxLogs: number = DEFAULT_MAX_LOGS) {
-    this.maxLogs = maxLogs;
-  }
-
-  /**
-   * Log a request
-   */
-  logRequest(log: Omit<RequestLog, 'id' | 'timestamp'>): void {
-    const fullLog: RequestLog = {
-      ...log,
-      id: generateUUID(),
-      timestamp: Date.now(),
-    };
-
-    this.logs.push(fullLog);
-
-    if (this.logs.length > this.maxLogs) {
-      this.logs.shift();
-    }
-
-    this.notifyListeners(fullLog);
-  }
-
-  /**
-   * Get all logs
-   */
-  getLogs(): RequestLog[] {
-    return [...this.logs];
-  }
-
-  /**
-   * Get logs by type
-   * Optimized: Return empty array early if no logs
-   */
-  getLogsByType(type: RequestType): RequestLog[] {
-    if (this.logs.length === 0) return [];
-    return this.logs.filter((log) => log.type === type);
-  }
-
-  /**
-   * Get request statistics
-   * Optimized: Single-pass calculation O(n) instead of O(7n)
-   */
-  getStats(): RequestStats {
-    let readRequests = 0;
-    let writeRequests = 0;
-    let deleteRequests = 0;
-    let listenerRequests = 0;
-    let cachedRequests = 0;
-    let failedRequests = 0;
-    let durationSum = 0;
-    let durationCount = 0;
-
-    // Single pass through logs for all statistics
-    for (const log of this.logs) {
-      switch (log.type) {
-        case 'read':
-          readRequests++;
-          break;
-        case 'write':
-          writeRequests++;
-          break;
-        case 'delete':
-          deleteRequests++;
-          break;
-        case 'listener':
-          listenerRequests++;
-          break;
-      }
-
-      if (log.cached) cachedRequests++;
-      if (!log.success) failedRequests++;
-
-      if (log.duration !== undefined) {
-        durationSum += log.duration;
-        durationCount++;
-      }
-    }
-
-    return {
-      totalRequests: this.logs.length,
-      readRequests,
-      writeRequests,
-      deleteRequests,
-      listenerRequests,
-      cachedRequests,
-      failedRequests,
-      averageDuration: durationCount > 0 ? durationSum / durationCount : 0,
-    };
-  }
-
-  /**
-   * Clear all logs
-   */
-  clearLogs(): void {
-    this.logs = [];
-  }
-
-  /**
-   * Add log listener
-   */
-  addListener(listener: (log: RequestLog) => void): () => void {
-    this.listeners.add(listener);
-    return () => {
-      this.listeners.delete(listener);
-    };
-  }
-
-  /**
-   * Remove all listeners
-   * Prevents memory leaks when service is destroyed
-   */
-  removeAllListeners(): void {
-    this.listeners.clear();
-  }
-
-  /**
-   * Destroy service and cleanup resources
-   */
-  destroy(): void {
-    this.removeAllListeners();
-    this.clearLogs();
-  }
-
-  /**
-   * Notify all listeners
-   */
-  private notifyListeners(log: RequestLog): void {
-    this.listeners.forEach((listener) => {
-      try {
-        listener(log);
-      } catch (error) {
-        // Log listener errors in development to help debugging
-        // In production, silently ignore to prevent crashing the app
-        if (__DEV__) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          console.warn(`${RequestLoggerService.LISTENER_ERROR_PREFIX} ${errorMessage}`);
-        }
-      }
-    });
-  }
-}
-
-export const requestLoggerService = new RequestLoggerService();
-