@umituz/react-native-firebase 1.13.51 → 1.13.53

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-firebase",
-  "version": "1.13.51",
+  "version": "1.13.53",
   "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",
@@ -50,7 +50,8 @@
     "firebase-admin": "^13.6.0",
     "react": "19.1.0",
     "react-native": "0.81.5",
-    "typescript": "~5.9.2"
+    "typescript": "~5.9.2",
+    "zustand": "^5.0.3"
   },
   "optionalDependencies": {
     "firebase-admin": "^13.0.2"

package/src/auth/index.ts

@@ -51,7 +51,6 @@ export {
   isCurrentUserAuthenticated,
   isCurrentUserAnonymous,
   verifyUserId,
-  getSafeUserId,
   isValidUser,
 } from './infrastructure/services/auth-utils.service';
 

package/src/auth/infrastructure/services/auth-utils.service.ts

@@ -8,13 +8,6 @@
 import type { Auth, User } from 'firebase/auth';
 import { getFirebaseAuth } from '../config/FirebaseAuthClient';
 
-/**
- * Check if user is anonymous
- */
-function isAnonymousUser(user: User): boolean {
-  return user.isAnonymous === true;
-}
-
 /**
  * Auth check result interface
  */
@@ -28,9 +21,10 @@ export interface AuthCheckResult {
 /**
  * Check authentication state
  * Returns comprehensive auth state information
+ * Optimized: Single traversal of auth state
  */
 export function checkAuthState(auth: Auth | null): AuthCheckResult {
-  if (!auth) {
+  if (!auth || !auth.currentUser) {
     return {
       isAuthenticated: false,
       isAnonymous: false,
@@ -40,19 +34,9 @@ export function checkAuthState(auth: Auth | null): AuthCheckResult {
   }
 
   const currentUser = auth.currentUser;
-
-  if (!currentUser) {
-    return {
-      isAuthenticated: false,
-      isAnonymous: false,
-      currentUser: null,
-      userId: null,
-    };
-  }
-
   return {
     isAuthenticated: true,
-    isAnonymous: isAnonymousUser(currentUser),
+    isAnonymous: currentUser.isAnonymous === true,
     currentUser,
     userId: currentUser.uid,
   };
@@ -62,28 +46,28 @@ export function checkAuthState(auth: Auth | null): AuthCheckResult {
  * Check if user is authenticated (including anonymous)
  */
 export function isAuthenticated(auth: Auth | null): boolean {
-  return checkAuthState(auth).isAuthenticated;
+  return auth?.currentUser?.uid !== null && auth?.currentUser?.uid !== undefined;
 }
 
 /**
  * Check if user is anonymous
  */
 export function isAnonymous(auth: Auth | null): boolean {
-  return checkAuthState(auth).isAnonymous;
+  return auth?.currentUser?.isAnonymous === true;
 }
 
 /**
  * Get current user ID (null if not authenticated)
  */
 export function getCurrentUserId(auth: Auth | null): string | null {
-  return checkAuthState(auth).userId;
+  return auth?.currentUser?.uid ?? null;
 }
 
 /**
  * Get current user (null if not authenticated)
  */
 export function getCurrentUser(auth: Auth | null): User | null {
-  return checkAuthState(auth).currentUser;
+  return auth?.currentUser ?? null;
 }
 
 /**
@@ -91,8 +75,7 @@ export function getCurrentUser(auth: Auth | null): User | null {
  * Convenience function that uses getFirebaseAuth()
  */
 export function getCurrentUserIdFromGlobal(): string | null {
-  const auth = getFirebaseAuth();
-  return getCurrentUserId(auth);
+  return getCurrentUserId(getFirebaseAuth());
 }
 
 /**
@@ -100,8 +83,7 @@ export function getCurrentUserIdFromGlobal(): string | null {
  * Convenience function that uses getFirebaseAuth()
  */
 export function getCurrentUserFromGlobal(): User | null {
-  const auth = getFirebaseAuth();
-  return getCurrentUser(auth);
+  return getCurrentUser(getFirebaseAuth());
 }
 
 /**
@@ -109,8 +91,7 @@ export function getCurrentUserFromGlobal(): User | null {
  * Convenience function that uses getFirebaseAuth()
  */
 export function isCurrentUserAuthenticated(): boolean {
-  const auth = getFirebaseAuth();
-  return isAuthenticated(auth);
+  return isAuthenticated(getFirebaseAuth());
 }
 
 /**
@@ -118,45 +99,23 @@ export function isCurrentUserAuthenticated(): boolean {
  * Convenience function that uses getFirebaseAuth()
  */
 export function isCurrentUserAnonymous(): boolean {
-  const auth = getFirebaseAuth();
-  return isAnonymous(auth);
+  return isAnonymous(getFirebaseAuth());
 }
 
 /**
  * Verify userId matches current authenticated user
  */
 export function verifyUserId(auth: Auth | null, userId: string): boolean {
-  if (!auth || !userId) {
-    return false;
-  }
-
-  try {
-    const state = checkAuthState(auth);
-    return state.isAuthenticated && state.userId === userId;
-  } catch {
+  if (!userId) {
     return false;
   }
-}
-
-/**
- * Get safe user ID (null if not authenticated)
- */
-export function getSafeUserId(auth: Auth | null): string | null {
-  if (!auth) {
-    return null;
-  }
-
-  try {
-    return getCurrentUserId(auth);
-  } catch {
-    return null;
-  }
+  return auth?.currentUser?.uid === userId;
 }
 
 /**
  * Check if user exists and is valid
  */
 export function isValidUser(user: User | null | undefined): user is User {
-  return user !== null && user !== undefined && typeof user.uid === 'string' && user.uid.length > 0;
+  return user?.uid !== undefined && user.uid.length > 0;
 }
 

package/src/domain/guards/firebase-error.guard.ts

@@ -0,0 +1,116 @@
+/**
+ * Firebase Error Type Guards
+ * Single Responsibility: Provide type-safe error checking utilities
+ *
+ * Provides type guards for Firebase errors to ensure type safety
+ * when handling errors from Firebase SDK operations.
+ */
+
+import type { FirestoreError } from 'firebase/firestore';
+import type { AuthError } from 'firebase/auth';
+
+/**
+ * Check if error is a Firebase Firestore error
+ */
+export function isFirestoreError(error: unknown): error is FirestoreError {
+  return (
+    typeof error === 'object' &&
+    error !== null &&
+    'code' in error &&
+    'message' in error
+  );
+}
+
+/**
+ * Check if error is a Firebase Auth error
+ */
+export function isAuthError(error: unknown): error is AuthError {
+  return (
+    typeof error === 'object' &&
+    error !== null &&
+    'code' in error &&
+    'message' in error
+  );
+}
+
+/**
+ * Check if error is a network error
+ */
+export function isNetworkError(error: unknown): boolean {
+  if (!isFirestoreError(error) && !isAuthError(error)) {
+    return false;
+  }
+
+  const code = (error as FirestoreError | AuthError).code;
+  return (
+    code === 'unavailable' ||
+    code === 'network-request-failed' ||
+    code === 'timeout'
+  );
+}
+
+/**
+ * Check if error is a permission denied error
+ */
+export function isPermissionDeniedError(error: unknown): boolean {
+  if (!isFirestoreError(error) && !isAuthError(error)) {
+    return false;
+  }
+
+  const code = (error as FirestoreError | AuthError).code;
+  return code === 'permission-denied' || code === 'unauthorized';
+}
+
+/**
+ * Check if error is a not found error
+ */
+export function isNotFoundError(error: unknown): boolean {
+  if (!isFirestoreError(error)) {
+    return false;
+  }
+
+  return (error as FirestoreError).code === 'not-found';
+}
+
+/**
+ * Check if error is a quota exceeded error
+ */
+export function isQuotaExceededError(error: unknown): boolean {
+  if (!isFirestoreError(error)) {
+    return false;
+  }
+
+  return (error as FirestoreError).code === 'resource-exhausted';
+}
+
+/**
+ * Get safe error message
+ * Returns error message or unknown error message
+ */
+export function getSafeErrorMessage(error: unknown): string {
+  if (isFirestoreError(error) || isAuthError(error)) {
+    return error.message;
+  }
+
+  if (error instanceof Error) {
+    return error.message;
+  }
+
+  if (typeof error === 'string') {
+    return error;
+  }
+
+  return 'An unknown error occurred';
+}
+
+/**
+ * Get safe error code
+ * Returns error code or unknown error code
+ */
+export function getSafeErrorCode(error: unknown): string {
+  if (isFirestoreError(error) || isAuthError(error)) {
+    return error.code;
+  }
+
+  return 'unknown';
+}

package/src/index.ts

@@ -44,6 +44,12 @@ export type {
   ServiceInitializationResult,
 } from './infrastructure/config/FirebaseClient';
 
+// =============================================================================
+// TYPE GUARDS
+// =============================================================================
+
+export * from './domain/guards/firebase-error.guard';
+
 // =============================================================================
 // AUTH MODULE
 // =============================================================================

package/src/storage/deleter.ts

@@ -1,6 +1,6 @@
 /**
  * Firebase Storage Deleter
- * Handles image deletion from Firebase Storage
+ * Handles single and batch deletion from Firebase Storage
  */
 
 import { getStorage, ref, deleteObject } from "firebase/storage";
@@ -9,6 +9,14 @@ import type { DeleteResult } from "./types";
 
 declare const __DEV__: boolean;
 
+/**
+ * Batch delete result interface
+ */
+export interface BatchDeleteResult {
+    successful: string[];
+    failed: Array<{ path: string; error: string }>;
+}
+
 /**
  * Extract storage path from Firebase download URL
  */
@@ -74,7 +82,66 @@ export async function deleteStorageFile(
         }
 
         return { success: true, storagePath };
-    } catch {
+    } catch (error) {
+        if (__DEV__) {
+            console.error("[StorageDeleter] Delete failed", {
+                storagePath,
+                error,
+            });
+        }
         return { success: false, storagePath };
     }
 }
+
+/**
+ * Delete multiple files from Firebase Storage
+ * Processes deletions in parallel for better performance
+ *
+ * @param urlsOrPaths - Array of download URLs or storage paths
+ * @returns Batch delete result with successful and failed deletions
+ */
+export async function deleteStorageFiles(
+    urlsOrPaths: string[]
+): Promise<BatchDeleteResult> {
+    if (__DEV__) {
+        console.log("[StorageDeleter] Batch delete", { count: urlsOrPaths.length });
+    }
+
+    const storage = getStorageInstance();
+    if (!storage) {
+        return {
+            successful: [],
+            failed: urlsOrPaths.map((path) => ({
+                path,
+                error: "Firebase Storage not initialized",
+            })),
+        };
+    }
+
+    const results = await Promise.allSettled(
+        urlsOrPaths.map((urlOrPath) => deleteStorageFile(urlOrPath))
+    );
+
+    const successful: string[] = [];
+    const failed: Array<{ path: string; error: string }> = [];
+
+    results.forEach((result, index) => {
+        if (result.status === "fulfilled" && result.value.success) {
+            successful.push(result.value.storagePath);
+        } else {
+            const errorMessage = result.status === "rejected"
+                ? String((result.reason as any)?.message ?? "Unknown error")
+                : "Delete operation failed";
+            failed.push({ path: urlsOrPaths[index]!, error: errorMessage });
+        }
+    });
+
+    if (__DEV__) {
+        console.log("[StorageDeleter] Batch delete complete", {
+            successful: successful.length,
+            failed: failed.length,
+        });
+    }
+
+    return { successful, failed };
+}

package/src/storage/index.ts

@@ -3,5 +3,6 @@
  */
 
 export type { UploadResult, UploadOptions, DeleteResult } from "./types";
+export type { BatchDeleteResult } from "./deleter";
 export { uploadBase64Image, uploadFile, getMimeType } from "./uploader";
-export { deleteStorageFile } from "./deleter";
+export { deleteStorageFile, deleteStorageFiles } from "./deleter";