@umituz/react-native-firebase 1.13.121 → 1.13.122

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-firebase",
-  "version": "1.13.121",
+  "version": "1.13.122",
   "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",

package/src/auth/infrastructure/services/account-deletion.service.ts

@@ -9,8 +9,8 @@ import {
   reauthenticateWithApple,
   reauthenticateWithPassword,
   reauthenticateWithGoogle,
-  toAuthError,
 } from "./reauthentication.service";
+import { toAuthErrorInfo } from "../../../domain/utils/error-handler.util";
 import type { AccountDeletionResult, AccountDeletionOptions } from "./reauthentication.types";
 
 export type { AccountDeletionResult, AccountDeletionOptions } from "./reauthentication.types";
@@ -34,7 +34,7 @@ export async function deleteCurrentUser(
     await deleteUser(user);
     return { success: true };
   } catch (error: unknown) {
-    const authErr = toAuthError(error);
+    const authErr = toAuthErrorInfo(error);
     if (authErr.code === "auth/requires-recent-login" && (options.autoReauthenticate || options.password || options.googleIdToken)) {
       const reauth = await attemptReauth(user, options);
       if (reauth) return reauth;
@@ -64,7 +64,7 @@ async function attemptReauth(user: User, options: AccountDeletionOptions): Promi
       await deleteUser(user);
       return { success: true };
     } catch (err: unknown) {
-      const authErr = toAuthError(err);
+      const authErr = toAuthErrorInfo(err);
       return { success: false, error: { ...authErr, requiresReauth: false } };
     }
   }
@@ -77,7 +77,7 @@ export async function deleteUserAccount(user: User | null): Promise<AccountDelet
     await deleteUser(user);
     return { success: true };
   } catch (error: unknown) {
-    const authErr = toAuthError(error);
+    const authErr = toAuthErrorInfo(error);
     return { success: false, error: { ...authErr, requiresReauth: authErr.code === "auth/requires-recent-login" } };
   }
 }

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

@@ -5,6 +5,7 @@
 
 import type { User, Auth } from 'firebase/auth';
 import { getFirebaseAuth } from '../config/FirebaseAuthClient';
+import { isValidString } from '../../../domain/utils/validation.util';
 
 export interface AuthCheckResult {
   isAuthenticated: boolean;
@@ -120,7 +121,7 @@ export function isValidUser(user: unknown): user is User {
     typeof user === 'object' &&
     user !== null &&
     'uid' in user &&
-    typeof user.uid === 'string'
+    isValidString(user.uid)
   );
 }
 

package/src/auth/infrastructure/services/reauthentication.service.ts

@@ -13,32 +13,19 @@ import {
 import * as AppleAuthentication from "expo-apple-authentication";
 import { Platform } from "react-native";
 import { generateNonce, hashNonce } from "./crypto.util";
-import type { 
-  ReauthenticationResult, 
-  AuthProviderType, 
-  ReauthCredentialResult 
+import { toAuthErrorInfo, isCancelledError } from "../../../domain/utils/error-handler.util";
+import type {
+  ReauthenticationResult,
+  AuthProviderType,
+  ReauthCredentialResult
 } from "./reauthentication.types";
 
-export type { 
-  ReauthenticationResult, 
-  AuthProviderType, 
-  ReauthCredentialResult 
+export type {
+  ReauthenticationResult,
+  AuthProviderType,
+  ReauthCredentialResult
 } from "./reauthentication.types";
 
-export function toAuthError(error: unknown): { code: string; message: string } {
-  if (error instanceof Error) {
-    const firebaseErr = error as { code?: string };
-    return {
-      code: firebaseErr.code || "auth/failed",
-      message: error.message,
-    };
-  }
-  return {
-    code: "auth/failed",
-    message: typeof error === 'string' ? error : "Unknown error",
-  };
-}
-
 export function getUserAuthProvider(user: User): AuthProviderType {
   if (user.isAnonymous) return "anonymous";
   const data = user.providerData;
@@ -54,7 +41,7 @@ export async function reauthenticateWithGoogle(user: User, idToken: string): Pro
     await reauthenticateWithCredential(user, GoogleAuthProvider.credential(idToken));
     return { success: true };
   } catch (error: unknown) {
-    const err = toAuthError(error);
+    const err = toAuthErrorInfo(error);
     return { success: false, error: err };
   }
 }
@@ -65,7 +52,7 @@ export async function reauthenticateWithPassword(user: User, pass: string): Prom
     await reauthenticateWithCredential(user, EmailAuthProvider.credential(user.email, pass));
     return { success: true };
   } catch (error: unknown) {
-    const err = toAuthError(error);
+    const err = toAuthErrorInfo(error);
     return { success: false, error: err };
   }
 }
@@ -73,7 +60,7 @@ export async function reauthenticateWithPassword(user: User, pass: string): Prom
 export async function getAppleReauthCredential(): Promise<ReauthCredentialResult> {
   if (Platform.OS !== "ios") return { success: false, error: { code: "auth/ios-only", message: "iOS only" } };
   try {
-    if (!(await AppleAuthentication.isAvailableAsync())) 
+    if (!(await AppleAuthentication.isAvailableAsync()))
       return { success: false, error: { code: "auth/unavailable", message: "Unavailable" } };
 
     const nonce = await generateNonce();
@@ -86,8 +73,8 @@ export async function getAppleReauthCredential(): Promise<ReauthCredentialResult
     if (!apple.identityToken) return { success: false, error: { code: "auth/no-token", message: "No token" } };
     return { success: true, credential: new OAuthProvider("apple.com").credential({ idToken: apple.identityToken, rawNonce: nonce }) };
   } catch (error: unknown) {
-    const err = toAuthError(error);
-    const code = err.message.includes("ERR_CANCELED") ? "auth/cancelled" : err.code;
+    const err = toAuthErrorInfo(error);
+    const code = isCancelledError(err) ? "auth/cancelled" : err.code;
     return { success: false, error: { code, message: err.message } };
   }
 }
@@ -99,7 +86,7 @@ export async function reauthenticateWithApple(user: User): Promise<Reauthenticat
     await reauthenticateWithCredential(user, res.credential);
     return { success: true };
   } catch (error: unknown) {
-    const err = toAuthError(error);
+    const err = toAuthErrorInfo(error);
     return { success: false, error: err };
   }
 }

package/src/domain/utils/error-handler.util.ts

@@ -0,0 +1,90 @@
+/**
+ * Error Handler Utility
+ * Centralized error handling utilities for Firebase operations
+ */
+
+/**
+ * Standard error structure with code and message
+ */
+export interface ErrorInfo {
+  code: string;
+  message: string;
+}
+
+/**
+ * Convert unknown error to standard error info
+ * Handles Error objects, strings, and unknown types
+ */
+export function toErrorInfo(error: unknown): ErrorInfo {
+  if (error instanceof Error) {
+    const firebaseErr = error as { code?: string };
+    return {
+      code: firebaseErr.code || 'unknown',
+      message: error.message,
+    };
+  }
+  return {
+    code: 'unknown',
+    message: typeof error === 'string' ? error : 'Unknown error',
+  };
+}
+
+/**
+ * Convert unknown error to auth error info
+ * Auth-specific error codes are prefixed with 'auth/'
+ */
+export function toAuthErrorInfo(error: unknown): ErrorInfo {
+  if (error instanceof Error) {
+    const firebaseErr = error as { code?: string };
+    return {
+      code: firebaseErr.code || 'auth/failed',
+      message: error.message,
+    };
+  }
+  return {
+    code: 'auth/failed',
+    message: typeof error === 'string' ? error : 'Unknown error',
+  };
+}
+
+/**
+ * Check if error info has a specific error code
+ */
+export function hasErrorCode(error: ErrorInfo, code: string): boolean {
+  return error.code === code;
+}
+
+/**
+ * Check if error is a cancelled/auth cancelled error
+ */
+export function isCancelledError(error: ErrorInfo): boolean {
+  return error.code === 'auth/cancelled' || error.message.includes('ERR_CANCELED');
+}
+
+/**
+ * Check if error is a quota exceeded error
+ */
+export function isQuotaError(error: ErrorInfo): boolean {
+  return (
+    error.code === 'quota-exceeded' ||
+    error.code.includes('quota') ||
+    error.message.toLowerCase().includes('quota')
+  );
+}
+
+/**
+ * Check if error is a network error
+ */
+export function isNetworkError(error: ErrorInfo): boolean {
+  return (
+    error.code.includes('network') ||
+    error.message.toLowerCase().includes('network')
+  );
+}
+
+/**
+ * Check if error is an authentication error
+ */
+export function isAuthError(error: ErrorInfo): boolean {
+  return error.code.startsWith('auth/');
+}

package/src/domain/utils/id-generator.util.ts

@@ -0,0 +1,50 @@
+/**
+ * ID Generator Utility
+ * Centralized ID generation utilities for unique identifiers
+ */
+
+/**
+ * Generate a unique ID using timestamp and random string
+ * Format: timestamp-randomstring
+ * @returns Unique identifier string
+ */
+export function generateUniqueId(): string {
+  return `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+}
+
+/**
+ * Generate a short random ID
+ * Useful for temporary identifiers where uniqueness within scope is sufficient
+ * @returns Random identifier string
+ */
+export function generateShortId(length: number = 8): string {
+  return Math.random().toString(36).substring(2, 2 + length);
+}
+
+/**
+ * Generate a UUID-like ID
+ * Format: xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx
+ * @returns UUID-like identifier string
+ */
+export function generateUUID(): string {
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+    const r = (Math.random() * 16) | 0;
+    const v = c === 'x' ? r : (r & 0x3) | 0x8;
+    return v.toString(16);
+  });
+}
+
+/**
+ * Generate a nanoid-like ID
+ * Uses URL-safe characters for better compatibility
+ * @param length - Length of the ID (default: 21)
+ * @returns URL-safe unique identifier string
+ */
+export function generateNanoId(length: number = 21): string {
+  const chars = 'ModuleSymbhasOwnPr-0123456789ABCDEFGHNRVfgctiUvz_KqYTJkLxpZXIjQW';
+  let result = '';
+  for (let i = 0; i < length; i++) {
+    result += chars.charAt(Math.floor(Math.random() * chars.length));
+  }
+  return result;
+}

package/src/domain/utils/validation.util.ts

@@ -0,0 +1,133 @@
+/**
+ * Validation Utility
+ * Centralized validation utilities for common patterns
+ */
+
+/**
+ * Check if a string is a valid non-empty value
+ */
+export function isValidString(value: unknown): value is string {
+  return typeof value === 'string' && value.trim().length > 0;
+}
+
+/**
+ * Check if a string is empty or whitespace only
+ */
+export function isEmptyString(value: unknown): boolean {
+  return typeof value === 'string' && value.trim().length === 0;
+}
+
+/**
+ * Validate Firebase API key format
+ * Firebase API keys typically start with "AIza" followed by 35 characters
+ */
+export function isValidFirebaseApiKey(apiKey: string): boolean {
+  if (!isValidString(apiKey)) {
+    return false;
+  }
+  const apiKeyPattern = /^AIza[0-9A-Za-z_-]{35}$/;
+  return apiKeyPattern.test(apiKey.trim());
+}
+
+/**
+ * Validate Firebase authDomain format
+ * Expected format: "projectId.firebaseapp.com" or "projectId.web.app"
+ */
+export function isValidFirebaseAuthDomain(authDomain: string): boolean {
+  if (!isValidString(authDomain)) {
+    return false;
+  }
+  const trimmed = authDomain.trim();
+  return (
+    trimmed.includes('.firebaseapp.com') ||
+    trimmed.includes('.web.app')
+  );
+}
+
+/**
+ * Validate Firebase projectId format
+ * Project IDs must be 6-30 characters, lowercase, alphanumeric, and may contain hyphens
+ */
+export function isValidFirebaseProjectId(projectId: string): boolean {
+  if (!isValidString(projectId)) {
+    return false;
+  }
+  const pattern = /^[a-z0-9][a-z0-9-]{4,28}[a-z0-9]$/;
+  return pattern.test(projectId.trim());
+}
+
+/**
+ * Validate URL format
+ */
+export function isValidUrl(url: string): boolean {
+  if (!isValidString(url)) {
+    return false;
+  }
+  try {
+    new URL(url.trim());
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Validate HTTPS URL
+ */
+export function isValidHttpsUrl(url: string): boolean {
+  if (!isValidString(url)) {
+    return false;
+  }
+  try {
+    const urlObj = new URL(url.trim());
+    return urlObj.protocol === 'https:';
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Validate email format
+ */
+export function isValidEmail(email: string): boolean {
+  if (!isValidString(email)) {
+    return false;
+  }
+  const emailPattern = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+  return emailPattern.test(email.trim());
+}
+
+/**
+ * Check if value is defined (not null or undefined)
+ */
+export function isDefined<T>(value: T | null | undefined): value is T {
+  return value !== null && value !== undefined;
+}
+
+/**
+ * Check if array is not empty
+ */
+export function isNonEmptyArray<T>(value: unknown): value is [T, ...T[]] {
+  return Array.isArray(value) && value.length > 0;
+}
+
+/**
+ * Check if number is in range
+ */
+export function isInRange(value: number, min: number, max: number): boolean {
+  return typeof value === 'number' && value >= min && value <= max;
+}
+
+/**
+ * Check if number is positive
+ */
+export function isPositive(value: number): boolean {
+  return typeof value === 'number' && value > 0;
+}
+
+/**
+ * Check if number is non-negative
+ */
+export function isNonNegative(value: number): boolean {
+  return typeof value === 'number' && value >= 0;
+}

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

@@ -3,116 +3,25 @@
  * Prevents duplicate Firestore queries within a short time window
  */
 
-interface PendingQuery {
-  promise: Promise<unknown>;
-  timestamp: number;
-}
+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';
 
-interface QueryKey {
-  collection: string;
-  filters: string;
-  limit?: number;
-  orderBy?: string;
-}
+const DEDUPLICATION_WINDOW_MS = 1000; // 1 second
+const CLEANUP_INTERVAL_MS = 5000; // 5 seconds
 
 export class QueryDeduplicationMiddleware {
-  private pendingQueries = new Map<string, PendingQuery>();
-  private readonly DEDUPLICATION_WINDOW_MS = 1000; // 1 second
-  private readonly CLEANUP_INTERVAL_MS = 5000; // 5 seconds
-  private cleanupTimer: ReturnType<typeof setInterval> | null = null;
-
-  constructor() {
-    this.startCleanupTimer();
-  }
-
-  /**
-   * Start cleanup timer to prevent memory leaks
-   */
-  private startCleanupTimer(): void {
-    if (this.cleanupTimer) {
-      clearInterval(this.cleanupTimer);
-    }
-
-    this.cleanupTimer = setInterval(() => {
-      try {
-        this.cleanupExpiredQueries();
-      } catch {
-        // Silently handle cleanup errors to prevent timer from causing issues
-        // Clear all queries if cleanup fails to prevent memory leak
-        this.pendingQueries.clear();
-      }
-    }, this.CLEANUP_INTERVAL_MS);
-  }
-
-  /**
-   * Clean up expired queries to prevent memory leaks
-   */
-  private cleanupExpiredQueries(): void {
-    const now = Date.now();
-    for (const [key, query] of this.pendingQueries.entries()) {
-      if (now - query.timestamp > this.DEDUPLICATION_WINDOW_MS) {
-        this.pendingQueries.delete(key);
-      }
-    }
-  }
-
-  /**
-   * Generate query key from query parameters
-   */
-  private generateQueryKey(key: QueryKey): string {
-    const parts = [
-      key.collection,
-      key.filters,
-      key.limit?.toString() || '',
-      key.orderBy || '',
-    ];
-    return parts.join('|');
-  }
-
-  /**
-   * Check if query is already pending
-   */
-  private isQueryPending(key: string): boolean {
-    const pending = this.pendingQueries.get(key);
-    if (!pending) return false;
-
-    const age = Date.now() - pending.timestamp;
-    if (age > this.DEDUPLICATION_WINDOW_MS) {
-      this.pendingQueries.delete(key);
-      return false;
-    }
-
-    return true;
-  }
-
-  /**
-   * Get pending query promise
-   */
-  private getPendingQuery(key: string): Promise<unknown> | null {
-    const pending = this.pendingQueries.get(key);
-    return pending ? pending.promise : null;
-  }
-
-  /**
-   * Add query to pending list with guaranteed cleanup
-   */
-  private addPendingQuery(key: string, promise: Promise<unknown>): void {
-    // Wrap the promise to ensure cleanup happens regardless of outcome
-    const wrappedPromise = promise
-      .catch((error) => {
-        // Re-throw to maintain original promise behavior
-        throw error;
-      })
-      .finally(() => {
-        // Guaranteed cleanup - runs for both resolve and reject
-        this.pendingQueries.delete(key);
-      });
-
-    // Store the wrapped promise with the finally handler attached
-    this.pendingQueries.set(key, {
-      promise: wrappedPromise,
-      timestamp: Date.now(),
+  private readonly queryManager: PendingQueryManager;
+  private readonly timerManager: TimerManager;
+
+  constructor(deduplicationWindowMs: number = DEDUPLICATION_WINDOW_MS) {
+    this.queryManager = new PendingQueryManager(deduplicationWindowMs);
+    this.timerManager = new TimerManager({
+      cleanupIntervalMs: CLEANUP_INTERVAL_MS,
+      onCleanup: () => this.queryManager.cleanup(),
     });
+    this.timerManager.start();
   }
 
   /**
@@ -122,17 +31,17 @@ export class QueryDeduplicationMiddleware {
     queryKey: QueryKey,
     queryFn: () => Promise<T>,
   ): Promise<T> {
-    const key = this.generateQueryKey(queryKey);
+    const key = generateQueryKey(queryKey);
 
-    if (this.isQueryPending(key)) {
-      const pendingPromise = this.getPendingQuery(key);
+    if (this.queryManager.isPending(key)) {
+      const pendingPromise = this.queryManager.get(key);
       if (pendingPromise) {
         return pendingPromise as Promise<T>;
       }
     }
 
     const promise = queryFn();
-    this.addPendingQuery(key, promise);
+    this.queryManager.add(key, promise);
 
     return promise;
   }
@@ -141,27 +50,27 @@ export class QueryDeduplicationMiddleware {
    * Clear all pending queries
    */
   clear(): void {
-    this.pendingQueries.clear();
+    this.queryManager.clear();
   }
 
   /**
    * Destroy middleware and cleanup resources
    */
   destroy(): void {
-    if (this.cleanupTimer) {
-      clearInterval(this.cleanupTimer);
-      this.cleanupTimer = null;
-    }
-    this.pendingQueries.clear();
+    this.timerManager.destroy();
+    this.queryManager.clear();
   }
 
   /**
    * Get pending queries count
    */
   getPendingCount(): number {
-    return this.pendingQueries.size;
+    return this.queryManager.size();
   }
 }
 
 export const queryDeduplicationMiddleware = new QueryDeduplicationMiddleware();
 
+// Re-export types for convenience
+export type { QueryKey };
+

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

@@ -4,6 +4,7 @@
  */
 
 import type { RequestLog, RequestStats, RequestType } from '../../domain/entities/RequestLog';
+import { generateUniqueId } from '../../../domain/utils/id-generator.util';
 
 export class RequestLoggerService {
   private logs: RequestLog[] = [];
@@ -16,7 +17,7 @@ export class RequestLoggerService {
   logRequest(log: Omit<RequestLog, 'id' | 'timestamp'>): void {
     const fullLog: RequestLog = {
       ...log,
-      id: this.generateId(),
+      id: generateUniqueId(),
       timestamp: Date.now(),
     };
 
@@ -92,13 +93,6 @@ export class RequestLoggerService {
     };
   }
 
-  /**
-   * Generate unique ID
-   */
-  private generateId(): string {
-    return `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
-  }
-
   /**
    * Notify all listeners
    */

package/src/firestore/utils/deduplication/index.ts

@@ -0,0 +1,13 @@
+/**
+ * Deduplication Utilities
+ * Utilities for query deduplication
+ */
+
+export { TimerManager } from './timer-manager.util';
+export type { TimerManagerOptions } from './timer-manager.util';
+
+export { generateQueryKey, createQueryKey } from './query-key-generator.util';
+export type { QueryKey } from './query-key-generator.util';
+
+export { PendingQueryManager } from './pending-query-manager.util';
+export type { PendingQuery } from './pending-query-manager.util';