@umituz/react-native-firebase 1.13.20 → 1.13.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-firebase",
-  "version": "1.13.20",
+  "version": "1.13.23",
   "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",
@@ -52,4 +52,4 @@
     "README.md",
     "LICENSE"
   ]
-}
+}

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

@@ -1,28 +1,26 @@
 /**
- * Quota Metrics Entity
- * Domain entity for tracking Firestore quota usage
+ * Quota Metrics Types
  */
 
 export interface QuotaMetrics {
-  readCount: number;
-  writeCount: number;
-  deleteCount: number;
-  timestamp: number;
+    readCount: number;
+    writeCount: number;
+    deleteCount: number;
+    lastResetDate: string;
 }
 
 export interface QuotaLimits {
-  dailyReadLimit: number;
-  dailyWriteLimit: number;
-  dailyDeleteLimit: number;
+    dailyReadLimit: number;
+    dailyWriteLimit: number;
+    dailyDeleteLimit: number;
 }
 
 export interface QuotaStatus {
-  metrics: QuotaMetrics;
-  limits: QuotaLimits;
-  readPercentage: number;
-  writePercentage: number;
-  deletePercentage: number;
-  isNearLimit: boolean;
-  isOverLimit: boolean;
+    metrics: QuotaMetrics;
+    limits: QuotaLimits;
+    readPercentage: number;
+    writePercentage: number;
+    deletePercentage: number;
+    isNearLimit: boolean;
+    isOverLimit: boolean;
 }
-

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

@@ -1,30 +1,28 @@
 /**
- * Request Log Entity
- * Domain entity for tracking Firestore requests
+ * Request Log Types
  */
 
 export type RequestType = 'read' | 'write' | 'delete' | 'listener';
 
 export interface RequestLog {
-  id: string;
-  type: RequestType;
-  collection: string;
-  documentId?: string;
-  timestamp: number;
-  duration?: number;
-  success: boolean;
-  error?: string;
-  cached: boolean;
+    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;
+    totalRequests: number;
+    readRequests: number;
+    writeRequests: number;
+    deleteRequests: number;
+    listenerRequests: number;
+    cachedRequests: number;
+    failedRequests: number;
+    averageDuration: number;
 }
-

package/src/firestore/index.ts

@@ -1,17 +1,6 @@
 /**
  * React Native Firestore Module
  * Domain-Driven Design (DDD) Architecture
- *
- * This is the SINGLE SOURCE OF TRUTH for all Firestore operations.
- * ALL imports from the Firestore module MUST go through this file.
- *
- * Architecture:
- * - domain: Errors, Constants, Entities, Services
- * - infrastructure: Firestore client, BaseRepository, utilities
- * - utils: Date utilities, timestamp conversion, query builders
- *
- * This module is designed to be used across hundreds of apps.
- * It provides a consistent interface for Firestore operations.
  */
 
 // =============================================================================
@@ -98,16 +87,6 @@ export {
   createDocumentMapper,
 } from './utils/document-mapper.helper';
 
-// =============================================================================
-// UTILS - Quota Error Detection
-// =============================================================================
-
-export {
-  isQuotaError,
-  isRetryableError,
-  getQuotaErrorMessage,
-} from './utils/quota-error-detector.util';
-
 // =============================================================================
 // UTILS - Path Resolver
 // =============================================================================
@@ -148,6 +127,16 @@ export type {
 
 export { QuotaCalculator } from './domain/services/QuotaCalculator';
 
+// =============================================================================
+// UTILS - Quota Error Detection
+// =============================================================================
+
+export {
+  isQuotaError,
+  isRetryableError,
+  getQuotaErrorMessage,
+} from './utils/quota-error-detector.util';
+
 // =============================================================================
 // INFRASTRUCTURE LAYER - Middleware
 // =============================================================================
@@ -166,11 +155,6 @@ export {
 // INFRASTRUCTURE LAYER - Services
 // =============================================================================
 
-export {
-  QuotaMonitorService,
-  quotaMonitorService,
-} from './infrastructure/services/QuotaMonitorService';
-
 export {
   RequestLoggerService,
   requestLoggerService,

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

@@ -3,163 +3,101 @@
  * Tracks Firestore operations for quota monitoring
  */
 
-import { quotaMonitorService } from '../services/QuotaMonitorService';
-import { requestLoggerService } from '../services/RequestLoggerService';
-import type { RequestType } from '../../domain/entities/RequestLog';
+declare const __DEV__: boolean;
 
-interface TrackedOperation {
-  type: RequestType;
-  collection: string;
-  documentId?: string;
-  count: number;
-  cached?: boolean;
+interface OperationInfo {
+    type: 'read' | 'write' | 'delete';
+    collection: string;
+    count: number;
+    cached: boolean;
 }
 
 export class QuotaTrackingMiddleware {
-  /**
-   * Track a read operation
-   */
-  trackRead(collection: string, count: number = 1, cached: boolean = false): void {
-    quotaMonitorService.incrementRead(count);
-    requestLoggerService.logRequest({
-      type: 'read',
-      collection,
-      success: true,
-      cached,
-    });
-  }
+    private readCount = 0;
+    private writeCount = 0;
+    private deleteCount = 0;
 
-  /**
-   * Track a write operation
-   */
-  trackWrite(
-    collection: string,
-    documentId?: string,
-    count: number = 1,
-  ): void {
-    quotaMonitorService.incrementWrite(count);
-    requestLoggerService.logRequest({
-      type: 'write',
-      collection,
-      documentId,
-      success: true,
-      cached: false,
-    });
-  }
+    /**
+     * Track a Firestore operation
+     */
+    async trackOperation<T>(
+        info: OperationInfo,
+        operation: () => Promise<T>
+    ): Promise<T> {
+        const result = await operation();
 
-  /**
-   * Track a delete operation
-   */
-  trackDelete(
-    collection: string,
-    documentId?: string,
-    count: number = 1,
-  ): void {
-    quotaMonitorService.incrementDelete(count);
-    requestLoggerService.logRequest({
-      type: 'delete',
-      collection,
-      documentId,
-      success: true,
-      cached: false,
-    });
-  }
+        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 a listener operation
-   */
-  trackListener(collection: string, documentId?: string): void {
-    requestLoggerService.logRequest({
-      type: 'listener',
-      collection,
-      documentId,
-      success: true,
-      cached: false,
-    });
-  }
+        if (__DEV__) {
+            console.log(`[QuotaTracking] ${info.type}: ${info.collection} (${info.count})`);
+        }
 
-  /**
-   * Track a failed operation
-   */
-  trackError(
-    type: RequestType,
-    collection: string,
-    error: string,
-    documentId?: string,
-  ): void {
-    requestLoggerService.logRequest({
-      type,
-      collection,
-      documentId,
-      success: false,
-      error,
-      cached: false,
-    });
-  }
+        return result;
+    }
 
-  /**
-   * Track operation with timing
-   */
-  async trackOperation<T>(
-    operation: TrackedOperation,
-    operationFn: () => Promise<T>,
-  ): Promise<T> {
-    const startTime = Date.now();
+    /**
+     * Track read operation
+     */
+    trackRead(collection: string, count: number = 1, cached: boolean = false): void {
+        if (!cached) {
+            this.readCount += count;
+        }
+        if (__DEV__) {
+            console.log(`[QuotaTracking] read: ${collection} (${count})`);
+        }
+    }
 
-    try {
-      const result = await operationFn();
-      const duration = Date.now() - startTime;
+    /**
+     * Track write operation
+     */
+    trackWrite(collection: string, _documentId?: string, count: number = 1): void {
+        this.writeCount += count;
+        if (__DEV__) {
+            console.log(`[QuotaTracking] write: ${collection} (${count})`);
+        }
+    }
 
-      if (operation.type === 'read') {
-        quotaMonitorService.incrementRead(operation.count);
-        requestLoggerService.logRequest({
-          type: 'read',
-          collection: operation.collection,
-          documentId: operation.documentId,
-          success: true,
-          cached: operation.cached || false,
-          duration,
-        });
-      } else if (operation.type === 'write') {
-        quotaMonitorService.incrementWrite(operation.count);
-        requestLoggerService.logRequest({
-          type: 'write',
-          collection: operation.collection,
-          documentId: operation.documentId,
-          success: true,
-          cached: false,
-          duration,
-        });
-      } else if (operation.type === 'delete') {
-        quotaMonitorService.incrementDelete(operation.count);
-        requestLoggerService.logRequest({
-          type: 'delete',
-          collection: operation.collection,
-          documentId: operation.documentId,
-          success: true,
-          cached: false,
-          duration,
-        });
-      }
+    /**
+     * Track delete operation
+     */
+    trackDelete(collection: string, _documentId?: string, count: number = 1): void {
+        this.deleteCount += count;
+        if (__DEV__) {
+            console.log(`[QuotaTracking] delete: ${collection} (${count})`);
+        }
+    }
 
-      return result;
-    } catch (error) {
-      const duration = Date.now() - startTime;
-      const errorMessage = error instanceof Error ? error.message : 'Unknown error';
-      requestLoggerService.logRequest({
-        type: operation.type,
-        collection: operation.collection,
-        documentId: operation.documentId,
-        success: false,
-        error: errorMessage,
-        cached: false,
-        duration,
-      });
+    /**
+     * Get current counts
+     */
+    getCounts(): { reads: number; writes: number; deletes: number } {
+        return {
+            reads: this.readCount,
+            writes: this.writeCount,
+            deletes: this.deleteCount,
+        };
+    }
 
-      throw error;
+    /**
+     * Reset counts
+     */
+    reset(): void {
+        this.readCount = 0;
+        this.writeCount = 0;
+        this.deleteCount = 0;
     }
-  }
 }
 
 export const quotaTrackingMiddleware = new QuotaTrackingMiddleware();
-

package/src/firestore/utils/quota-error-detector.util.ts

@@ -1,100 +1,59 @@
 /**
- * Quota Error Detector Utility
- * Single Responsibility: Detect Firebase quota errors
- *
- * Firebase quota limits:
- * - Free tier: 50K reads/day, 20K writes/day, 20K deletes/day
- * - Blaze plan: Pay as you go, higher limits
- *
- * Quota errors are NOT retryable - quota won't increase by retrying
+ * Quota Error Detection Utilities
  */
 
+const QUOTA_ERROR_CODES = [
+    'resource-exhausted',
+    'quota-exceeded',
+    'RESOURCE_EXHAUSTED',
+];
+
+const QUOTA_ERROR_MESSAGES = [
+    'quota',
+    'exceeded',
+    'limit',
+    'too many requests',
+];
+
 /**
- * Check if error is a Firebase quota error
- * Quota errors indicate daily read/write/delete limits are exceeded
- *
- * @param error - Error object to check
- * @returns true if error is a quota error
+ * Check if error is a Firestore quota error
  */
 export function isQuotaError(error: unknown): boolean {
-  if (!error || typeof error !== "object") {
-    return false;
-  }
+    if (!error) return false;
 
-  const firebaseError = error as { code?: string; message?: string; name?: string };
+    const errorObj = error as Record<string, unknown>;
+    const code = errorObj.code as string | undefined;
+    const message = errorObj.message as string | undefined;
 
-  // Check error code
-  if (firebaseError.code === "resource-exhausted") {
-    return true;
-  }
+    if (code && QUOTA_ERROR_CODES.some((c) => code.includes(c))) {
+        return true;
+    }
 
-  // Check error message
-  const errorMessage = firebaseError.message?.toLowerCase() || "";
-  if (
-    errorMessage.includes("quota") ||
-    errorMessage.includes("quota exceeded") ||
-    errorMessage.includes("resource-exhausted") ||
-    errorMessage.includes("daily limit")
-  ) {
-    return true;
-  }
+    if (message) {
+        const lowerMessage = message.toLowerCase();
+        return QUOTA_ERROR_MESSAGES.some((m) => lowerMessage.includes(m));
+    }
 
-  // Check error name
-  const errorName = firebaseError.name?.toLowerCase() || "";
-  if (errorName.includes("quota") || errorName.includes("resource-exhausted")) {
-    return true;
-  }
-
-  return false;
+    return false;
 }
 
 /**
  * Check if error is retryable
- * Quota errors are NOT retryable
- *
- * @param error - Error object to check
- * @returns true if error is retryable
  */
 export function isRetryableError(error: unknown): boolean {
-  // Quota errors are NOT retryable
-  if (isQuotaError(error)) {
-    return false;
-  }
+    if (!error) return false;
 
-  if (!error || typeof error !== "object") {
-    return false;
-  }
-
-  const firebaseError = error as { code?: string; message?: string };
-
-  // Firestore transaction conflicts are retryable
-  if (firebaseError.code === "failed-precondition") {
-    return true;
-  }
+    const errorObj = error as Record<string, unknown>;
+    const code = errorObj.code as string | undefined;
 
-  // Network errors are retryable
-  if (
-    firebaseError.code === "unavailable" ||
-    firebaseError.code === "deadline-exceeded"
-  ) {
-    return true;
-  }
+    const retryableCodes = ['unavailable', 'deadline-exceeded', 'aborted'];
 
-  // Timeout errors are retryable
-  const errorMessage = firebaseError.message?.toLowerCase() || "";
-  if (errorMessage.includes("timeout")) {
-    return true;
-  }
-
-  return false;
+    return code ? retryableCodes.some((c) => code.includes(c)) : false;
 }
 
 /**
  * Get user-friendly quota error message
- *
- * @returns User-friendly error message
  */
 export function getQuotaErrorMessage(): string {
-  return "Firebase quota exceeded. Please try again later or upgrade your Firebase plan.";
+    return 'Daily quota exceeded. Please try again tomorrow or upgrade your plan.';
 }
-

package/src/storage/deleter.ts

@@ -0,0 +1,80 @@
+/**
+ * Firebase Storage Deleter
+ * Handles image deletion from Firebase Storage
+ */
+
+import { getStorage, ref, deleteObject } from "firebase/storage";
+import { getFirebaseApp } from "../infrastructure/config/FirebaseClient";
+import type { DeleteResult } from "./types";
+
+declare const __DEV__: boolean;
+
+/**
+ * Extract storage path from Firebase download URL
+ */
+function extractStoragePath(downloadUrl: string): string | null {
+    if (!downloadUrl.startsWith("https://")) {
+        return downloadUrl;
+    }
+
+    try {
+        const urlObj = new URL(downloadUrl);
+        const pathMatch = urlObj.pathname.match(/\/o\/(.+)/);
+
+        if (!pathMatch) {
+            return null;
+        }
+
+        return decodeURIComponent(pathMatch[1]);
+    } catch {
+        return null;
+    }
+}
+
+function getStorageInstance() {
+    const app = getFirebaseApp();
+    return app ? getStorage(app) : null;
+}
+
+/**
+ * Delete image from Firebase Storage
+ * Accepts either a download URL or storage path
+ */
+export async function deleteStorageFile(
+    downloadUrlOrPath: string
+): Promise<DeleteResult> {
+    if (__DEV__) {
+        console.log("[StorageDeleter] Deleting", { url: downloadUrlOrPath });
+    }
+
+    const storagePath = extractStoragePath(downloadUrlOrPath);
+
+    if (!storagePath) {
+        if (__DEV__) {
+            console.error("[StorageDeleter] Invalid URL", {
+                url: downloadUrlOrPath,
+            });
+        }
+        return { success: false, storagePath: downloadUrlOrPath };
+    }
+
+    try {
+        const storage = getStorageInstance();
+        if (!storage) {
+            throw new Error("Firebase Storage not initialized");
+        }
+
+        const storageRef = ref(storage, storagePath);
+        await deleteObject(storageRef);
+
+        if (__DEV__) {
+            console.log("[StorageDeleter] Deleted successfully", {
+                storagePath,
+            });
+        }
+
+        return { success: true, storagePath };
+    } catch {
+        return { success: false, storagePath };
+    }
+}

package/src/storage/index.ts

@@ -1 +1,7 @@
-export * from "./uploader";
+/**
+ * Firebase Storage Module
+ */
+
+export type { UploadResult, UploadOptions, DeleteResult } from "./types";
+export { uploadBase64Image, uploadFile, getMimeType } from "./uploader";
+export { deleteStorageFile } from "./deleter";

package/src/storage/types.ts

@@ -0,0 +1,19 @@
+/**
+ * Firebase Storage Types
+ * Shared types for storage operations
+ */
+
+export interface UploadResult {
+    downloadUrl: string;
+    storagePath: string;
+}
+
+export interface UploadOptions {
+    mimeType?: string;
+    customMetadata?: Record<string, string>;
+}
+
+export interface DeleteResult {
+    success: boolean;
+    storagePath: string;
+}

package/src/storage/uploader.ts

@@ -11,20 +11,10 @@ import {
     type UploadMetadata,
 } from "firebase/storage";
 import { getFirebaseApp } from "../infrastructure/config/FirebaseClient";
+import type { UploadResult, UploadOptions } from "./types";
 
 declare const __DEV__: boolean;
 
-export interface UploadResult {
-    downloadUrl: string;
-    storagePath: string;
-    metadata?: any;
-}
-
-export interface UploadOptions {
-    mimeType?: string;
-    metadata?: any;
-}
-
 /**
  * Extract MIME type from base64 data URL or return default
  */
@@ -79,16 +69,22 @@ export async function uploadBase64Image(
 
     const metadata: UploadMetadata = {
         contentType: mimeType,
-        customMetadata: options?.metadata,
+        customMetadata: options?.customMetadata,
     };
 
-    const snapshot = await uploadBytes(storageRef, blob, metadata);
+    await uploadBytes(storageRef, blob, metadata);
     const downloadUrl = await getDownloadURL(storageRef);
 
+    if (__DEV__) {
+        console.log("[StorageUploader] Upload complete", {
+            storagePath,
+            downloadUrl,
+        });
+    }
+
     return {
         downloadUrl,
         storagePath,
-        metadata: snapshot.metadata,
     };
 }
 
@@ -118,15 +114,21 @@ export async function uploadFile(
 
     const metadata: UploadMetadata = {
         contentType: options?.mimeType ?? "image/jpeg",
-        customMetadata: options?.metadata,
+        customMetadata: options?.customMetadata,
     };
 
-    const snapshot = await uploadBytes(storageRef, blob, metadata);
+    await uploadBytes(storageRef, blob, metadata);
     const downloadUrl = await getDownloadURL(storageRef);
 
+    if (__DEV__) {
+        console.log("[StorageUploader] Upload complete", {
+            storagePath,
+            downloadUrl,
+        });
+    }
+
     return {
         downloadUrl,
         storagePath,
-        metadata: snapshot.metadata,
     };
 }

package/src/firestore/infrastructure/services/QuotaMonitorService.ts

@@ -1,108 +0,0 @@
-/**
- * Quota Monitor Service
- * Infrastructure service for monitoring Firestore quota usage
- */
-
-import type { QuotaMetrics, QuotaLimits, QuotaStatus } from '../../domain/entities/QuotaMetrics';
-import { QuotaCalculator } from '../../domain/services/QuotaCalculator';
-
-export class QuotaMonitorService {
-  private metrics: QuotaMetrics = {
-    readCount: 0,
-    writeCount: 0,
-    deleteCount: 0,
-    timestamp: Date.now(),
-  };
-
-  private limits: QuotaLimits = QuotaCalculator.getDefaultLimits();
-  private listeners: Set<(status: QuotaStatus) => void> = new Set();
-
-  /**
-   * Set quota limits
-   */
-  setLimits(limits: Partial<QuotaLimits>): void {
-    this.limits = { ...this.limits, ...limits };
-  }
-
-  /**
-   * Increment read count
-   */
-  incrementRead(count: number = 1): void {
-    this.metrics.readCount += count;
-    this.notifyListeners();
-  }
-
-  /**
-   * Increment write count
-   */
-  incrementWrite(count: number = 1): void {
-    this.metrics.writeCount += count;
-    this.notifyListeners();
-  }
-
-  /**
-   * Increment delete count
-   */
-  incrementDelete(count: number = 1): void {
-    this.metrics.deleteCount += count;
-    this.notifyListeners();
-  }
-
-  /**
-   * Get current metrics
-   */
-  getMetrics(): QuotaMetrics {
-    return { ...this.metrics };
-  }
-
-  /**
-   * Get current status
-   */
-  getStatus(): QuotaStatus {
-    return QuotaCalculator.calculateStatus(this.metrics, this.limits);
-  }
-
-  /**
-   * Reset metrics
-   */
-  resetMetrics(): void {
-    this.metrics = {
-      readCount: 0,
-      writeCount: 0,
-      deleteCount: 0,
-      timestamp: Date.now(),
-    };
-    this.notifyListeners();
-  }
-
-  /**
-   * Add status change listener
-   */
-  addListener(listener: (status: QuotaStatus) => void): () => void {
-    this.listeners.add(listener);
-    return () => {
-      this.listeners.delete(listener);
-    };
-  }
-
-  /**
-   * Notify all listeners
-   */
-  private notifyListeners(): void {
-    const status = this.getStatus();
-    this.listeners.forEach((listener) => {
-      try {
-        listener(status);
-      } catch (error) {
-        /* eslint-disable-next-line no-console */
-        if (__DEV__) {
-          /* eslint-disable-next-line no-console */
-          console.error('[QuotaMonitor] Listener error:', error);
-        }
-      }
-    });
-  }
-}
-
-export const quotaMonitorService = new QuotaMonitorService();
-