@umituz/react-native-firebase 2.4.100 → 2.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umituz/react-native-firebase",
-  "version": "2.4.100",
+  "version": "2.6.0",
   "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/domains/firestore/index.ts

@@ -59,61 +59,6 @@ export type {
 } from './types/pagination.types';
 export { EMPTY_PAGINATED_RESULT } from './types/pagination.types';
 
-// Domain Constants
-export {
-  FREE_TIER_LIMITS,
-  QUOTA_THRESHOLDS,
-  calculateQuotaUsage,
-  isQuotaThresholdReached,
-  getRemainingQuota,
-} from './domain/constants/QuotaLimits';
-
-// Domain Entities
-export type {
-  QuotaMetrics,
-  QuotaLimits,
-  QuotaStatus,
-} from './domain/entities/QuotaMetrics';
-export type {
-  RequestLog,
-  RequestStats,
-  RequestType,
-} from './domain/entities/RequestLog';
-
-// Domain Services
-export { QuotaCalculator } from './domain/services/QuotaCalculator';
-
-// Quota Error Detection
-export {
-  isQuotaError,
-  isRetryableError,
-} from '../../shared/domain/utils/error-handlers/error-checkers';
-export {
-  getQuotaErrorMessage,
-} from '../../shared/domain/utils/error-handlers/error-messages';
-
-// Middleware
-export {
-  QueryDeduplicationMiddleware,
-  queryDeduplicationMiddleware,
-  syncDeduplicationWithQuota,
-  useDeduplicationWithQuota,
-} from './infrastructure/middleware/QueryDeduplicationMiddleware';
-export type {
-  QueryDeduplicationConfig,
-  DeduplicationStatistics,
-} from './infrastructure/middleware/QueryDeduplicationMiddleware';
-export {
-  QuotaTrackingMiddleware,
-  quotaTrackingMiddleware,
-} from './infrastructure/middleware/QuotaTrackingMiddleware';
-
-// Services
-export {
-  RequestLoggerService,
-  requestLoggerService,
-} from './infrastructure/services/RequestLoggerService';
-
 // Firestore Helper Utilities
 export {
   withFirestore,
@@ -150,13 +95,21 @@ export {
 export { useFirestoreQuery } from './presentation/hooks/useFirestoreQuery';
 export { useFirestoreMutation } from './presentation/hooks/useFirestoreMutation';
 export { useFirestoreSnapshot } from './presentation/hooks/useFirestoreSnapshot';
-export { useSmartFirestoreSnapshot, useSmartListenerControl } from './presentation/hooks/useSmartFirestoreSnapshot';
-export { createFirestoreKeys } from './presentation/query-keys/createFirestoreKeys';
 
 export type { UseFirestoreQueryOptions } from './presentation/hooks/useFirestoreQuery';
 export type { UseFirestoreMutationOptions } from './presentation/hooks/useFirestoreMutation';
 export type { UseFirestoreSnapshotOptions } from './presentation/hooks/useFirestoreSnapshot';
-export type { UseSmartFirestoreSnapshotOptions, BackgroundStrategy } from './presentation/hooks/useSmartFirestoreSnapshot';
+
+// Re-export commonly used Firebase Firestore types
+export type {
+  Timestamp,
+  DocumentSnapshot,
+  QuerySnapshot,
+  DocumentReference,
+  CollectionReference,
+  Query,
+  Transaction,
+} from 'firebase/firestore';
 
 // Firebase types are available from the 'firebase' package directly
 // Import them in your app: import { Timestamp } from 'firebase/firestore';

package/src/domains/firestore/infrastructure/repositories/BasePaginatedRepository.ts

@@ -43,11 +43,9 @@ export abstract class BasePaginatedRepository extends BaseQueryRepository {
 
     const collectionRef = collection(db, collectionName);
     let q: import("firebase/firestore").Query<DocumentData>;
-    let cursorKey = 'start';
 
     // Handle cursor-based pagination
     if (helper.hasCursor(params) && params?.cursor) {
-      cursorKey = params.cursor;
 
       // FIX: Validate cursor and throw error instead of silent failure
       validateCursorOrThrow(params.cursor);
@@ -77,17 +75,13 @@ export abstract class BasePaginatedRepository extends BaseQueryRepository {
       );
     }
 
-    // Generate a unique key for deduplication (after cursor is resolved)
-    const uniqueKey = `${collectionName}_list_${orderByField}_${orderDirection}_${fetchLimit}_${cursorKey}`;
-
     return this.executeQuery(
       collectionName,
       async () => {
         const snapshot = await getDocs(q);
         return snapshot.docs;
       },
-      false,
-      uniqueKey
+      false
     );
   }
 

package/src/domains/firestore/infrastructure/repositories/BaseQueryRepository.ts

@@ -1,44 +1,18 @@
-/**
- * Base Repository - Query Operations
- *
- * Provides query and tracking operations for Firestore repositories.
- * Extends BaseRepository with query-specific functionality.
- */
-
-import { queryDeduplicationMiddleware } from "../middleware/QueryDeduplicationMiddleware";
-import { BaseRepository } from "./BaseRepository";
+import { BaseRepository } from './BaseRepository';
 
 export abstract class BaseQueryRepository extends BaseRepository {
-  /**
-   * Execute query with deduplication and quota tracking
-   * Prevents duplicate queries and tracks quota usage
-   */
   protected async executeQuery<T>(
     collection: string,
     queryFn: () => Promise<T>,
-    cached: boolean = false,
-    uniqueKey?: string
+    cached: boolean = false
   ): Promise<T> {
-    const safeKey = uniqueKey || `${collection}_query`;
-
-    const queryKey = {
-      collection,
-      filters: safeKey,
-      limit: undefined,
-      orderBy: undefined,
-    };
-
-    return queryDeduplicationMiddleware.deduplicate(queryKey, async () => {
-      const result = await queryFn();
+    const result = await queryFn();
 
-      // Optimize: Only calculate count if tracking is needed
-      // Check if quota tracking is enabled before computing array length
-      if (!cached) {
-        const count = Array.isArray(result) ? result.length : 1;
-        this.trackRead(collection, count, cached);
-      }
+    if (!cached) {
+      const count = Array.isArray(result) ? result.length : 1;
+      this.trackRead(collection, count, cached);
+    }
 
-      return result;
-    });
+    return result;
   }
 }

package/src/domains/firestore/infrastructure/repositories/BaseRepository.ts

@@ -10,9 +10,6 @@
 
 import type { Firestore, CollectionReference, DocumentReference, DocumentData } from 'firebase/firestore';
 import { getFirestore, collection, doc } from 'firebase/firestore';
-import { isQuotaError as checkQuotaError } from '../../../../shared/domain/utils/error-handlers/error-checkers';
-import { ERROR_MESSAGES } from '../../../../shared/domain/utils/error-handlers/error-messages';
-import { quotaTrackingMiddleware } from '../middleware/QuotaTrackingMiddleware';
 
 enum RepositoryState {
   ACTIVE = 'active',
@@ -49,11 +46,11 @@ export abstract class BaseRepository implements IPathResolver {
    */
   protected getDbOrThrow(): Firestore {
     if (this.state === RepositoryState.DESTROYED) {
-      throw new Error(ERROR_MESSAGES.REPOSITORY.DESTROYED);
+      throw new Error('Repository is destroyed');
     }
     const db = getFirestore();
     if (!db) {
-      throw new Error(ERROR_MESSAGES.FIRESTORE.NOT_INITIALIZED);
+      throw new Error('Firestore is not initialized');
     }
     return db;
   }
@@ -107,55 +104,19 @@ export abstract class BaseRepository implements IPathResolver {
   protected async executeOperation<T>(
     operation: () => Promise<T>
   ): Promise<T> {
-    try {
-      return await operation();
-    } catch (error) {
-      if (checkQuotaError(error)) {
-        throw new Error(ERROR_MESSAGES.FIRESTORE.QUOTA_EXCEEDED);
-      }
-      throw error;
-    }
+    return await operation();
   }
 
-  /**
-   * Track read operation for quota monitoring
-   *
-   * @param collection - Collection name
-   * @param count - Number of documents read
-   * @param cached - Whether the result is from cache
-   */
-  protected trackRead(
-    collection: string,
-    count: number = 1,
-    cached: boolean = false,
-  ): void {
-    quotaTrackingMiddleware.trackRead(collection, count, cached);
+  protected trackRead(_collection: string, _count: number = 1, _cached: boolean = false): void {
+    // Quota tracking removed - use Firebase console for monitoring
   }
 
-  /**
-   * Track write operation for quota monitoring
-   *
-   * @param collection - Collection name
-   * @param count - Number of documents written
-   */
-  protected trackWrite(
-    collection: string,
-    count: number = 1,
-  ): void {
-    quotaTrackingMiddleware.trackWrite(collection, count);
+  protected trackWrite(_collection: string, _count: number = 1): void {
+    // Quota tracking removed - use Firebase console for monitoring
   }
 
-  /**
-   * Track delete operation for quota monitoring
-   *
-   * @param collection - Collection name
-   * @param count - Number of documents deleted
-   */
-  protected trackDelete(
-    collection: string,
-    count: number = 1,
-  ): void {
-    quotaTrackingMiddleware.trackDelete(collection, count);
+  protected trackDelete(_collection: string, _count: number = 1): void {
+    // Quota tracking removed - use Firebase console for monitoring
   }
 
   /**

package/src/domains/firestore/presentation/hooks/index.ts

@@ -12,13 +12,3 @@ export {
   useFirestoreSnapshot,
   type UseFirestoreSnapshotOptions,
 } from './useFirestoreSnapshot';
-
-export {
-  useSmartFirestoreSnapshot,
-  useSmartListenerControl,
-} from './useSmartFirestoreSnapshot';
-
-export type {
-  UseSmartFirestoreSnapshotOptions,
-  BackgroundStrategy,
-} from './useSmartFirestoreSnapshot';

package/src/shared/domain/utils/calculation.util.ts

@@ -1,24 +1,7 @@
 /**
  * Calculation Utilities
- * Common mathematical operations used across the codebase
- * Optimized for performance with minimal allocations
  */
 
-/**
- * Safely calculates percentage (0-1 range)
- * Optimized: Guards against division by zero
- *
- * @param current - Current value
- * @param limit - Maximum value
- * @returns Percentage between 0 and 1
- *
- * @example
- * ```typescript
- * const percentage = calculatePercentage(750, 1000); // 0.75
- * const percentage = calculatePercentage(1200, 1000); // 1.0 (capped)
- * const percentage = calculatePercentage(0, 1000); // 0.0
- * ```
- */
 export function calculatePercentage(current: number, limit: number): number {
   if (limit <= 0) return 0;
   if (current <= 0) return 0;
@@ -26,327 +9,56 @@ export function calculatePercentage(current: number, limit: number): number {
   return current / limit;
 }
 
-/**
- * Calculates remaining quota
- * Optimized: Single Math.max call
- *
- * @param current - Current usage
- * @param limit - Maximum limit
- * @returns Remaining amount (minimum 0)
- *
- * @example
- * ```typescript
- * const remaining = calculateRemaining(250, 1000); // 750
- * const remaining = calculateRemaining(1200, 1000); // 0 (capped)
- * ```
- */
 export function calculateRemaining(current: number, limit: number): number {
   return Math.max(0, limit - current);
 }
 
-/**
- * Safe floor with minimum value
- * Optimized: Single comparison
- *
- * @param value - Value to floor
- * @param min - Minimum allowed value
- * @returns Floored value, at least min
- *
- * @example
- * ```typescript
- * const result = safeFloor(5.7, 1); // 5
- * const result = safeFloor(0.3, 1); // 1 (min enforced)
- * const result = safeFloor(-2.5, 0); // 0 (min enforced)
- * ```
- */
 export function safeFloor(value: number, min: number): number {
   const floored = Math.floor(value);
   return floored < min ? min : floored;
 }
 
-/**
- * Safe ceil with maximum value
- * Optimized: Single comparison
- *
- * @param value - Value to ceil
- * @param max - Maximum allowed value
- * @returns Ceiled value, at most max
- *
- * @example
- * ```typescript
- * const result = safeCeil(5.2, 10); // 6
- * const result = safeCeil(9.8, 10); // 10 (max enforced)
- * const result = safeCeil(12.1, 10); // 10 (max enforced)
- * ```
- */
-export function safeCeil(value: number, max: number): number {
-  const ceiled = Math.ceil(value);
-  return ceiled > max ? max : ceiled;
-}
-
-/**
- * Clamp value between min and max
- * Optimized: Efficient without branching
- *
- * @param value - Value to clamp
- * @param min - Minimum value
- * @param max - Maximum value
- * @returns Clamped value
- *
- * @example
- * ```typescript
- * const result = clamp(5, 0, 10); // 5
- * const result = clamp(-5, 0, 10); // 0
- * const result = clamp(15, 0, 10); // 10
- * ```
- */
-export function clamp(value: number, min: number, max: number): number {
-  return Math.max(min, Math.min(value, max));
-}
-
-/**
- * Calculate milliseconds between two dates
- * Optimized: Direct subtraction without Date object creation
- *
- * @param date1 - First date (timestamp or Date)
- * @param date2 - Second date (timestamp or Date)
- * @returns Difference in milliseconds (date1 - date2)
- *
- * @example
- * ```typescript
- * const diff = diffMs(Date.now(), Date.now() - 3600000); // 3600000
- * ```
- */
 export function diffMs(date1: number | Date, date2: number | Date): number {
-  const ms1 = typeof date1 === 'number' ? date1 : date1.getTime();
-  const ms2 = typeof date2 === 'number' ? date2 : date2.getTime();
-  return ms1 - ms2;
+  const d1 = typeof date1 === 'number' ? date1 : date1.getTime();
+  const d2 = typeof date2 === 'number' ? date2 : date2.getTime();
+  return Math.abs(d1 - d2);
 }
 
-/**
- * Calculate minutes difference between two dates
- * Optimized: Single Math.floor call
- *
- * @param date1 - First date
- * @param date2 - Second date
- * @returns Difference in minutes (floored)
- *
- * @example
- * ```typescript
- * const diff = diffMinutes(Date.now(), Date.now() - 180000); // 3
- * ```
- */
 export function diffMinutes(date1: number | Date, date2: number | Date): number {
-  const msDiff = diffMs(date1, date2);
-  return Math.floor(msDiff / 60_000);
+  return Math.floor(diffMs(date1, date2) / 60000);
 }
 
-/**
- * Calculate hours difference between two dates
- * Optimized: Single Math.floor call
- *
- * @param date1 - First date
- * @param date2 - Second date
- * @returns Difference in hours (floored)
- *
- * @example
- * ```typescript
- * const diff = diffHours(Date.now(), Date.now() - 7200000); // 2
- * ```
- */
 export function diffHours(date1: number | Date, date2: number | Date): number {
-  const minsDiff = diffMinutes(date1, date2);
-  return Math.floor(minsDiff / 60);
+  return Math.floor(diffMs(date1, date2) / 3600000);
 }
 
-/**
- * Calculate days difference between two dates
- * Optimized: Single Math.floor call
- *
- * @param date1 - First date
- * @param date2 - Second date
- * @returns Difference in days (floored)
- *
- * @example
- * ```typescript
- * const diff = diffDays(Date.now(), Date.now() - 172800000); // 2
- * ```
- */
 export function diffDays(date1: number | Date, date2: number | Date): number {
-  const hoursDiff = diffHours(date1, date2);
-  return Math.floor(hoursDiff / 24);
+  return Math.floor(diffMs(date1, date2) / 86400000);
 }
 
-/**
- * Safe array slice with bounds checking
- * Optimized: Prevents negative indices and out-of-bounds
- *
- * @param array - Array to slice
- * @param start - Start index (inclusive)
- * @param end - End index (exclusive)
- * @returns Sliced array
- *
- * @example
- * ```typescript
- * const items = [1, 2, 3, 4, 5];
- * const sliced = safeSlice(items, 1, 3); // [2, 3]
- * const sliced = safeSlice(items, -5, 10); // [1, 2, 3, 4, 5] (bounds checked)
- * ```
- */
-export function safeSlice<T>(array: T[], start: number, end?: number): T[] {
-  const len = array.length;
-
-  // Clamp start index
-  const safeStart = start < 0 ? 0 : (start >= len ? len : start);
-
-  // Clamp end index
-  const safeEnd = end === undefined
-    ? len
-    : (end < 0 ? 0 : (end >= len ? len : end));
-
-  // Only slice if valid range
-  if (safeStart >= safeEnd) {
-    return [];
+export function chunkArray<T>(array: readonly T[], chunkSize: number): T[][] {
+  if (chunkSize <= 0) return [];
+  const result: T[][] = [];
+  for (let i = 0; i < array.length; i += chunkSize) {
+    result.push(array.slice(i, i + chunkSize) as T[]);
   }
+  return result;
+}
 
-  return array.slice(safeStart, safeEnd);
+export function safeSlice<T>(array: T[], start: number, end?: number): T[] {
+  if (start < 0) return array.slice(0, end);
+  if (start >= array.length) return [];
+  return array.slice(start, end);
 }
 
-/**
- * Calculate fetch limit for pagination (pageLimit + 1)
- * Optimized: Simple addition
- *
- * @param pageLimit - Requested page size
- * @returns Fetch limit (pageLimit + 1 for hasMore detection)
- *
- * @example
- * ```typescript
- * const fetchLimit = getFetchLimit(10); // 11
- * ```
- */
 export function getFetchLimit(pageLimit: number): number {
   return pageLimit + 1;
 }
 
-/**
- * Calculate if hasMore based on items length and page limit
- * Optimized: Direct comparison
- *
- * @param itemsLength - Total items fetched
- * @param pageLimit - Requested page size
- * @returns true if there are more items
- *
- * @example
- * ```typescript
- * const hasMore = hasMore(11, 10); // true
- * const hasMore = hasMore(10, 10); // false
- * ```
- */
 export function hasMore(itemsLength: number, pageLimit: number): boolean {
   return itemsLength > pageLimit;
 }
 
-/**
- * Calculate result items count (min of itemsLength and pageLimit)
- * Optimized: Single Math.min call
- *
- * @param itemsLength - Total items fetched
- * @param pageLimit - Requested page size
- * @returns Number of items to return
- *
- * @example
- * ```typescript
- * const count = getResultCount(11, 10); // 10
- * const count = getResultCount(8, 10); // 8
- * ```
- */
 export function getResultCount(itemsLength: number, pageLimit: number): number {
   return Math.min(itemsLength, pageLimit);
 }
-
-/**
- * Chunk array into smaller arrays
- * Optimized: Pre-allocated chunks when size is known
- *
- * @param array - Array to chunk
- * @param chunkSize - Size of each chunk
- * @returns Array of chunks
- *
- * @example
- * ```typescript
- * const chunks = chunkArray([1, 2, 3, 4, 5], 2); // [[1, 2], [3, 4], [5]]
- * ```
- */
-export function chunkArray<T>(array: readonly T[], chunkSize: number): T[][] {
-  if (chunkSize <= 0) {
-    throw new Error('chunkSize must be greater than 0');
-  }
-
-  const chunks: T[][] = [];
-  const len = array.length;
-
-  for (let i = 0; i < len; i += chunkSize) {
-    const end = Math.min(i + chunkSize, len);
-    chunks.push(array.slice(i, end) as T[]);
-  }
-
-  return chunks;
-}
-
-/**
- * Sum array of numbers
- * Optimized: Direct for-loop (faster than reduce)
- *
- * @param numbers - Array of numbers to sum
- * @returns Sum of all numbers
- *
- * @example
- * ```typescript
- * const sum = sumArray([1, 2, 3, 4, 5]); // 15
- * ```
- */
-export function sumArray(numbers: number[]): number {
-  let sum = 0;
-  for (let i = 0; i < numbers.length; i++) {
-    const num = numbers[i];
-    if (num !== undefined && num !== null) {
-      sum += num;
-    }
-  }
-  return sum;
-}
-
-/**
- * Average of array of numbers
- * Optimized: Single-pass calculation
- *
- * @param numbers - Array of numbers
- * @returns Average value
- *
- * @example
- * ```typescript
- * const avg = averageArray([1, 2, 3, 4, 5]); // 3
- * ```
- */
-export function averageArray(numbers: number[]): number {
-  if (numbers.length === 0) return 0;
-  return sumArray(numbers) / numbers.length;
-}
-
-/**
- * Round to decimal places
- * Optimized: Efficient rounding without string conversion
- *
- * @param value - Value to round
- * @param decimals - Number of decimal places
- * @returns Rounded value
- *
- * @example
- * ```typescript
- * const rounded = roundToDecimals(3.14159, 2); // 3.14
- * ```
- */
-export function roundToDecimals(value: number, decimals: number): number {
-  const multiplier = Math.pow(10, decimals);
-  return Math.round(value * multiplier) / multiplier;
-}

package/src/shared/domain/utils/index.ts

@@ -37,8 +37,6 @@ export {
   calculatePercentage,
   calculateRemaining,
   safeFloor,
-  safeCeil,
-  clamp,
   diffMs,
   diffMinutes,
   diffHours,
@@ -48,7 +46,4 @@ export {
   hasMore,
   getResultCount,
   chunkArray,
-  sumArray,
-  averageArray,
-  roundToDecimals,
 } from './calculation.util';