@umituz/react-native-firebase 2.5.1 → 2.6.1

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/error-handlers/error-messages.ts

@@ -13,6 +13,11 @@ export const ERROR_MESSAGES = {
     INVALID_CREDENTIALS: 'Invalid credentials provided',
     USER_CHANGED: 'User changed during operation',
     OPERATION_IN_PROGRESS: 'Operation already in progress',
+    USER_NOT_FOUND: 'User not found',
+    EMAIL_ALREADY_IN_USE: 'Email is already in use',
+    TOO_MANY_REQUESTS: 'Too many requests. Please try again later',
+    USER_DISABLED: 'This account has been disabled',
+    GENERIC_ERROR: 'Authentication error occurred',
   },
   FIRESTORE: {
     NOT_INITIALIZED: 'Firestore is not initialized',
@@ -25,6 +30,12 @@ export const ERROR_MESSAGES = {
     PERMISSION_DENIED: 'Permission denied',
     TRANSACTION_FAILED: 'Transaction failed',
     NETWORK_ERROR: 'Network error occurred',
+    NOT_FOUND: 'Document not found',
+    UNAVAILABLE: 'Firestore service is unavailable',
+    GENERIC_ERROR: 'Firestore error occurred',
+  },
+  STORAGE: {
+    GENERIC_ERROR: 'Storage error occurred',
   },
   REPOSITORY: {
     DESTROYED: 'Repository has been destroyed',

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';

package/src/shared/infrastructure/base/ErrorHandler.ts

@@ -0,0 +1,189 @@
+/**
+ * Error Handler Base Class
+ * Single Responsibility: Centralized error handling and conversion
+ *
+ * Eliminates try-catch duplication across 9+ files.
+ * Provides standardized error-to-ErrorInfo conversion.
+ * Integrates with existing Result pattern.
+ *
+ * Max lines: 150 (enforced for maintainability)
+ */
+
+import type { ErrorInfo } from '../../domain/utils';
+import { toErrorInfo, successResult, type Result } from '../../domain/utils';
+import { isCancelledError, isQuotaError, isRetryableError } from '../../domain/utils/error-handlers/error-checkers';
+import { ERROR_MESSAGES } from '../../domain/utils/error-handlers/error-messages';
+
+/**
+ * Error handler options
+ */
+export interface ErrorHandlerOptions {
+  /** Default error code if none can be extracted */
+  defaultErrorCode?: string;
+  /** Custom error message mapper */
+  errorMapper?: (error: unknown) => string | null;
+  /** Enable detailed logging in development */
+  enableDevLogging?: boolean;
+}
+
+/**
+ * Base class for error handling
+ * Provides centralized error conversion and handling
+ */
+export class ErrorHandler {
+  private readonly options: ErrorHandlerOptions;
+
+  constructor(options: ErrorHandlerOptions = {}) {
+    this.options = {
+      defaultErrorCode: 'unknown/error',
+      enableDevLogging: __DEV__,
+      ...options,
+    };
+  }
+
+  /**
+   * Wrap an async operation with standardized error handling
+   * Eliminates try-catch duplication across services
+   */
+  async handleAsync<T>(
+    operation: () => Promise<T>,
+    errorCode: string = this.options.defaultErrorCode || 'unknown/error'
+  ): Promise<Result<T>> {
+    try {
+      const result = await operation();
+      return successResult(result);
+    } catch (error) {
+      if (this.options.enableDevLogging) {
+        console.error(`[ErrorHandler] Operation failed: ${errorCode}`, error);
+      }
+      return { success: false, error: toErrorInfo(error, errorCode) };
+    }
+  }
+
+  /**
+   * Wrap a synchronous operation with standardized error handling
+   */
+  handle<T>(
+    operation: () => T,
+    errorCode: string = this.options.defaultErrorCode || 'unknown/error'
+  ): Result<T> {
+    try {
+      const result = operation();
+      return successResult(result);
+    } catch (error) {
+      if (this.options.enableDevLogging) {
+        console.error(`[ErrorHandler] Operation failed: ${errorCode}`, error);
+      }
+      return { success: false, error: toErrorInfo(error, errorCode) };
+    }
+  }
+
+  /**
+   * Convert error to ErrorInfo with optional custom code
+   */
+  toErrorInfo(error: unknown, code?: string): ErrorInfo {
+    // Try custom error mapper first
+    if (this.options.errorMapper) {
+      const customMessage = this.options.errorMapper(error);
+      if (customMessage) {
+        return {
+          code: code || this.options.defaultErrorCode || 'unknown/error',
+          message: customMessage,
+        };
+      }
+    }
+
+    // Use standard conversion
+    return toErrorInfo(error, code || this.options.defaultErrorCode);
+  }
+
+  /**
+   * Check if error is a cancelled operation
+   */
+  isCancelledError(error: unknown): boolean {
+    return isCancelledError(error);
+  }
+
+  /**
+   * Check if error is a quota error
+   */
+  isQuotaError(error: unknown): boolean {
+    return isQuotaError(error);
+  }
+
+  /**
+   * Check if error is retryable
+   */
+  isRetryableError(error: unknown): boolean {
+    return isRetryableError(error);
+  }
+
+  /**
+   * Get user-friendly error message
+   * Maps error codes to user-friendly messages
+   */
+  getUserMessage(error: ErrorInfo): string {
+    // Check if it's a known error category
+    if (error.code.startsWith('auth/')) {
+      return this.getAuthUserMessage(error.code);
+    }
+    if (error.code.startsWith('firestore/')) {
+      return this.getFirestoreUserMessage(error.code);
+    }
+    if (error.code.startsWith('storage/')) {
+      return ERROR_MESSAGES.STORAGE.GENERIC_ERROR;
+    }
+
+    return error.message || ERROR_MESSAGES.GENERAL.UNKNOWN;
+  }
+
+  /**
+   * Get user-friendly auth error message
+   */
+  private getAuthUserMessage(code: string): string {
+    // Map common auth error codes to user-friendly messages
+    const authMessages: Record<string, string> = {
+      'auth/user-not-found': ERROR_MESSAGES.AUTH.USER_NOT_FOUND,
+      'auth/wrong-password': ERROR_MESSAGES.AUTH.INVALID_CREDENTIALS,
+      'auth/email-already-in-use': ERROR_MESSAGES.AUTH.EMAIL_ALREADY_IN_USE,
+      'auth/invalid-email': ERROR_MESSAGES.AUTH.INVALID_EMAIL,
+      'auth/weak-password': ERROR_MESSAGES.AUTH.WEAK_PASSWORD,
+      'auth/too-many-requests': ERROR_MESSAGES.AUTH.TOO_MANY_REQUESTS,
+      'auth/user-disabled': ERROR_MESSAGES.AUTH.USER_DISABLED,
+    };
+
+    return authMessages[code] || ERROR_MESSAGES.AUTH.GENERIC_ERROR;
+  }
+
+  /**
+   * Get user-friendly firestore error message
+   */
+  private getFirestoreUserMessage(code: string): string {
+    const firestoreMessages: Record<string, string> = {
+      'firestore/permission-denied': ERROR_MESSAGES.FIRESTORE.PERMISSION_DENIED,
+      'firestore/not-found': ERROR_MESSAGES.FIRESTORE.NOT_FOUND,
+      'firestore/unavailable': ERROR_MESSAGES.FIRESTORE.UNAVAILABLE,
+    };
+
+    return firestoreMessages[code] || ERROR_MESSAGES.FIRESTORE.GENERIC_ERROR;
+  }
+
+  /**
+   * Create a failure result from error code
+   */
+  failureFrom(code: string, message?: string): Result {
+    return {
+      success: false,
+      error: {
+        code,
+        message: message || ERROR_MESSAGES.GENERAL.UNKNOWN,
+      },
+    };
+  }
+}
+
+/**
+ * Default error handler instance
+ * Can be used across the application
+ */
+export const defaultErrorHandler = new ErrorHandler();