@umituz/react-native-firebase 1.13.20 → 1.13.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-firebase",
-  "version": "1.13.20",
+  "version": "1.13.22",
   "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/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/domain/entities/QuotaMetrics.ts

@@ -1,28 +0,0 @@
-/**
- * Quota Metrics Entity
- * Domain entity for tracking Firestore quota usage
- */
-
-export interface QuotaMetrics {
-  readCount: number;
-  writeCount: number;
-  deleteCount: number;
-  timestamp: number;
-}
-
-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/firestore/domain/entities/RequestLog.ts

@@ -1,30 +0,0 @@
-/**
- * Request Log Entity
- * Domain entity for tracking Firestore requests
- */
-
-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;
-}
-
-export interface RequestStats {
-  totalRequests: number;
-  readRequests: number;
-  writeRequests: number;
-  deleteRequests: number;
-  listenerRequests: number;
-  cachedRequests: number;
-  failedRequests: number;
-  averageDuration: number;
-}
-

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

@@ -1,165 +0,0 @@
-/**
- * Quota Tracking Middleware
- * Tracks Firestore operations for quota monitoring
- */
-
-import { quotaMonitorService } from '../services/QuotaMonitorService';
-import { requestLoggerService } from '../services/RequestLoggerService';
-import type { RequestType } from '../../domain/entities/RequestLog';
-
-interface TrackedOperation {
-  type: RequestType;
-  collection: string;
-  documentId?: 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,
-    });
-  }
-
-  /**
-   * 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 delete operation
-   */
-  trackDelete(
-    collection: string,
-    documentId?: string,
-    count: number = 1,
-  ): void {
-    quotaMonitorService.incrementDelete(count);
-    requestLoggerService.logRequest({
-      type: 'delete',
-      collection,
-      documentId,
-      success: true,
-      cached: false,
-    });
-  }
-
-  /**
-   * Track a listener operation
-   */
-  trackListener(collection: string, documentId?: string): void {
-    requestLoggerService.logRequest({
-      type: 'listener',
-      collection,
-      documentId,
-      success: true,
-      cached: false,
-    });
-  }
-
-  /**
-   * Track a failed operation
-   */
-  trackError(
-    type: RequestType,
-    collection: string,
-    error: string,
-    documentId?: string,
-  ): void {
-    requestLoggerService.logRequest({
-      type,
-      collection,
-      documentId,
-      success: false,
-      error,
-      cached: false,
-    });
-  }
-
-  /**
-   * Track operation with timing
-   */
-  async trackOperation<T>(
-    operation: TrackedOperation,
-    operationFn: () => Promise<T>,
-  ): Promise<T> {
-    const startTime = Date.now();
-
-    try {
-      const result = await operationFn();
-      const duration = Date.now() - startTime;
-
-      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,
-        });
-      }
-
-      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,
-      });
-
-      throw error;
-    }
-  }
-}
-
-export const quotaTrackingMiddleware = new QuotaTrackingMiddleware();
-

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

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

@@ -1,100 +0,0 @@
-/**
- * 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
- */
-
-/**
- * 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
- */
-export function isQuotaError(error: unknown): boolean {
-  if (!error || typeof error !== "object") {
-    return false;
-  }
-
-  const firebaseError = error as { code?: string; message?: string; name?: string };
-
-  // Check error code
-  if (firebaseError.code === "resource-exhausted") {
-    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;
-  }
-
-  // Check error name
-  const errorName = firebaseError.name?.toLowerCase() || "";
-  if (errorName.includes("quota") || errorName.includes("resource-exhausted")) {
-    return true;
-  }
-
-  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 || 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;
-  }
-
-  // Network errors are retryable
-  if (
-    firebaseError.code === "unavailable" ||
-    firebaseError.code === "deadline-exceeded"
-  ) {
-    return true;
-  }
-
-  // Timeout errors are retryable
-  const errorMessage = firebaseError.message?.toLowerCase() || "";
-  if (errorMessage.includes("timeout")) {
-    return true;
-  }
-
-  return 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.";
-}
-