@umituz/react-native-firebase 1.13.148 → 1.13.150

package/src/domain/utils/async-executor.util.ts

@@ -1,176 +1,23 @@
 /**
  * Async Operation Executor Utility
- * Centralized async operation execution with error handling
- * Eliminates code duplication across services
+ * Re-exports all async executors for backward compatibility
+ * @deprecated Import from specific executor files instead
  */
 
-import type { Result, FailureResult } from './result.util';
-import { failureResultFromError, successResult } from './result.util';
+// Error Converters
+export type { ErrorConverter } from './executors/error-converters.util';
+export { authErrorConverter, defaultErrorConverter } from './executors/error-converters.util';
 
-/**
- * Error converter function type
- * Converts unknown errors to ErrorInfo
- */
-export type ErrorConverter = (error: unknown) => { code: string; message: string };
-
-/**
- * Default error converter for auth operations
- */
-export function authErrorConverter(error: unknown): { code: string; message: string } {
-  if (error instanceof Error) {
-    return {
-      code: (error as { code?: string }).code ?? 'auth/failed',
-      message: error.message,
-    };
-  }
-  return {
-    code: 'auth/failed',
-    message: typeof error === 'string' ? error : 'Authentication failed',
-  };
-}
-
-/**
- * Default error converter for operations
- */
-export function defaultErrorConverter(
-  error: unknown,
-  defaultCode = 'operation/failed'
-): { code: string; message: string } {
-  if (error instanceof Error) {
-    return {
-      code: (error as { code?: string }).code ?? defaultCode,
-      message: error.message,
-    };
-  }
-  return {
-    code: defaultCode,
-    message: typeof error === 'string' ? error : 'Operation failed',
-  };
-}
-
-/**
- * Execute async operation with error handling
- * Returns Result type with success/failure
- */
-export async function executeOperation<T>(
-  operation: () => Promise<T>,
-  errorConverter?: ErrorConverter
-): Promise<Result<T>> {
-  try {
-    const data = await operation();
-    return successResult(data);
-  } catch (error) {
-    const converter = errorConverter ?? defaultErrorConverter;
-    return { success: false, error: converter(error) };
-  }
-}
-
-/**
- * Execute async operation with error handling and default code
- */
-export async function executeOperationWithCode<T>(
-  operation: () => Promise<T>,
-  defaultErrorCode = 'operation/failed'
-): Promise<Result<T>> {
-  return executeOperation(operation, (error) => defaultErrorConverter(error, defaultErrorCode));
-}
-
-/**
- * Execute async void operation
- * Useful for operations that don't return data
- */
-export async function executeVoidOperation(
-  operation: () => Promise<void>,
-  errorConverter?: ErrorConverter
-): Promise<Result<void>> {
-  return executeOperation(operation, errorConverter) as Promise<Result<void>>;
-}
-
-/**
- * Execute async operation with auth error handling
- */
-export async function executeAuthOperation<T>(
-  operation: () => Promise<T>
-): Promise<Result<T>> {
-  return executeOperation(operation, authErrorConverter);
-}
+// Basic Executors
+export {
+  executeOperation,
+  executeOperationWithCode,
+  executeVoidOperation,
+  executeAuthOperation,
+} from './executors/basic-executors.util';
 
-/**
- * Execute multiple operations in parallel
- * Returns success only if all operations succeed
- */
-export async function executeAll<T>(
-  ...operations: (() => Promise<Result<T>>)[]
-): Promise<Result<T[]>> {
-  try {
-    const results = await Promise.all(operations.map((op) => op()));
-    const failures = results.filter((r) => !r.success);
-    if (failures.length > 0) {
-      return failures[0] as FailureResult;
-    }
-    const data = results.map((r) => (r as { success: true; data: T }).data);
-    return successResult(data);
-  } catch (error) {
-    return failureResultFromError(error);
-  }
-}
+// Batch Executors
+export { executeAll, executeSequence } from './executors/batch-executors.util';
 
-/**
- * Execute operations in sequence, stopping at first failure
- */
-export async function executeSequence<T>(
-  ...operations: (() => Promise<Result<T>>)[]
-): Promise<Result<void>> {
-  for (const operation of operations) {
-    const result = await operation();
-    if (!result.success) {
-      return result as Result<void>;
-    }
-  }
-  return successResult();
-}
-
-/**
- * Execute operation with retry
- */
-export async function executeWithRetry<T>(
-  operation: () => Promise<T>,
-  maxRetries = 3,
-  delayMs = 1000
-): Promise<Result<T>> {
-  let lastError: unknown;
-  for (let i = 0; i <= maxRetries; i++) {
-    try {
-      const data = await operation();
-      return successResult(data);
-    } catch (error) {
-      lastError = error;
-      if (i < maxRetries) {
-        await new Promise((resolve) => setTimeout(resolve, delayMs * (i + 1)));
-      }
-    }
-  }
-  return failureResultFromError(lastError);
-}
-
-/**
- * Execute operation with timeout
- */
-export async function executeWithTimeout<T>(
-  operation: () => Promise<T>,
-  timeoutMs: number
-): Promise<Result<T>> {
-  return Promise.race([
-    executeOperation(operation),
-    new Promise<Result<T>>((resolve) =>
-      setTimeout(
-        () =>
-          resolve({
-            success: false,
-            error: { code: 'timeout', message: `Operation timed out after ${timeoutMs}ms` },
-          }),
-        timeoutMs
-      )
-    ),
-  ]);
-}
+// Advanced Executors
+export { executeWithRetry, executeWithTimeout } from './executors/advanced-executors.util';

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

@@ -1,178 +1,26 @@
 /**
  * Error Handler Utility
- * Centralized error handling utilities for Firebase operations
+ * Re-exports all error handling utilities for backward compatibility
+ * @deprecated Import from specific error-handler files instead
  */
 
-import { hasCodeProperty, hasMessageProperty, hasCodeAndMessageProperties } from './type-guards.util';
+// Error Converters
+export type { ErrorInfo } from './error-handlers/error-converters';
+export { toErrorInfo, toAuthErrorInfo } from './error-handlers/error-converters';
 
-/**
- * Standard error structure with code and message
- */
-export interface ErrorInfo {
-  code: string;
-  message: string;
-}
-
-/**
- * Quota error codes
- */
-const QUOTA_ERROR_CODES = [
-  'resource-exhausted',
-  'quota-exceeded',
-  'RESOURCE_EXHAUSTED',
-];
-
-/**
- * Quota error message patterns
- */
-const QUOTA_ERROR_MESSAGES = [
-  'quota exceeded',
-  'quota limit',
-  'daily limit',
-  'resource exhausted',
-  'too many requests',
-];
-
-/**
- * Retryable error codes
- */
-const RETRYABLE_ERROR_CODES = ['unavailable', 'deadline-exceeded', 'aborted'];
-
-/**
- * Convert unknown error to standard error info
- * Handles Error objects, strings, and unknown types
- */
-export function toErrorInfo(error: unknown): ErrorInfo {
-  if (error instanceof Error) {
-    return {
-      code: hasCodeProperty(error) ? error.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) {
-    return {
-      code: hasCodeProperty(error) && error.code ? error.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 info is a quota error
- */
-export function isQuotaErrorInfo(error: ErrorInfo): boolean {
-  return (
-    error.code === 'quota-exceeded' ||
-    error.code.includes('quota') ||
-    error.message.toLowerCase().includes('quota')
-  );
-}
-
-/**
- * Check if error info is a network error
- */
-export function isNetworkError(error: ErrorInfo): boolean {
-  return (
-    error.code.includes('network') ||
-    error.message.toLowerCase().includes('network')
-  );
-}
-
-/**
- * Check if error info is an authentication error
- */
-export function isAuthError(error: ErrorInfo): boolean {
-  return error.code.startsWith('auth/');
-}
-
-/**
- * Check if unknown error is a Firestore quota error
- * Enhanced type guard with proper error checking
- */
-export function isQuotaError(error: unknown): boolean {
-  if (!error || typeof error !== 'object') return false;
-
-  if (hasCodeProperty(error)) {
-    const code = error.code;
-    return QUOTA_ERROR_CODES.some(
-      (c) => code === c || code.endsWith(`/${c}`) || code.startsWith(`${c}/`)
-    );
-  }
+// Error Checkers
+export {
+  hasErrorCode,
+  isCancelledError,
+  isQuotaErrorInfo,
+  isNetworkError,
+  isAuthError,
+  isQuotaError,
+  isRetryableError,
+} from './error-handlers/error-checkers';
 
-  if (hasMessageProperty(error)) {
-    const message = error.message.toLowerCase();
-    return QUOTA_ERROR_MESSAGES.some((m) => {
-      const pattern = m.toLowerCase();
-      return (
-        message.includes(` ${pattern} `) ||
-        message.startsWith(`${pattern} `) ||
-        message.endsWith(` ${pattern}`) ||
-        message === pattern
-      );
-    });
-  }
-
-  return false;
-}
-
-/**
- * Check if error is retryable
- */
-export function isRetryableError(error: unknown): boolean {
-  if (!error || typeof error !== 'object') return false;
-
-  if (hasCodeProperty(error)) {
-    return RETRYABLE_ERROR_CODES.some((code) => error.code.includes(code));
-  }
-
-  return false;
-}
-
-/**
- * Get user-friendly quota error message
- */
-export function getQuotaErrorMessage(): string {
-  return 'Daily quota exceeded. Please try again tomorrow or upgrade your plan.';
-}
-
-/**
- * Get user-friendly retryable error message
- */
-export function getRetryableErrorMessage(): string {
-  return 'Temporary error occurred. Please try again.';
-}
+// Error Messages
+export { getQuotaErrorMessage, getRetryableErrorMessage } from './error-handlers/error-messages';
 
 // Re-export type guards for convenience
-export { hasCodeProperty, hasMessageProperty, hasCodeAndMessageProperties };
+export { hasCodeProperty, hasMessageProperty, hasCodeAndMessageProperties } from './type-guards.util';

package/src/domain/utils/error-handlers/error-checkers.ts

@@ -0,0 +1,120 @@
+/**
+ * Error Type Checkers
+ * Check error types and categories
+ */
+
+import type { ErrorInfo } from './error-converters';
+import { hasCodeProperty, hasMessageProperty } from '../type-guards.util';
+
+/**
+ * Quota error codes
+ */
+const QUOTA_ERROR_CODES = [
+  'resource-exhausted',
+  'quota-exceeded',
+  'RESOURCE_EXHAUSTED',
+];
+
+/**
+ * Quota error message patterns
+ */
+const QUOTA_ERROR_MESSAGES = [
+  'quota exceeded',
+  'quota limit',
+  'daily limit',
+  'resource exhausted',
+  'too many requests',
+];
+
+/**
+ * Retryable error codes
+ */
+const RETRYABLE_ERROR_CODES = ['unavailable', 'deadline-exceeded', 'aborted'];
+
+/**
+ * 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 info is a quota error
+ */
+export function isQuotaErrorInfo(error: ErrorInfo): boolean {
+  return (
+    error.code === 'quota-exceeded' ||
+    error.code.includes('quota') ||
+    error.message.toLowerCase().includes('quota')
+  );
+}
+
+/**
+ * Check if error info is a network error
+ */
+export function isNetworkError(error: ErrorInfo): boolean {
+  return (
+    error.code.includes('network') ||
+    error.message.toLowerCase().includes('network')
+  );
+}
+
+/**
+ * Check if error info is an authentication error
+ */
+export function isAuthError(error: ErrorInfo): boolean {
+  return error.code.startsWith('auth/');
+}
+
+/**
+ * Check if unknown error is a Firestore quota error
+ * Enhanced type guard with proper error checking
+ */
+export function isQuotaError(error: unknown): boolean {
+  if (!error || typeof error !== 'object') return false;
+
+  if (hasCodeProperty(error)) {
+    const code = error.code;
+    return QUOTA_ERROR_CODES.some(
+      (c) => code === c || code.endsWith(`/${c}`) || code.startsWith(`${c}/`)
+    );
+  }
+
+  if (hasMessageProperty(error)) {
+    const message = error.message.toLowerCase();
+    return QUOTA_ERROR_MESSAGES.some((m) => {
+      const pattern = m.toLowerCase();
+      return (
+        message.includes(` ${pattern} `) ||
+        message.startsWith(`${pattern} `) ||
+        message.endsWith(` ${pattern}`) ||
+        message === pattern
+      );
+    });
+  }
+
+  return false;
+}
+
+/**
+ * Check if error is retryable
+ */
+export function isRetryableError(error: unknown): boolean {
+  if (!error || typeof error !== 'object') return false;
+
+  if (hasCodeProperty(error)) {
+    return RETRYABLE_ERROR_CODES.some((code) => error.code.includes(code));
+  }
+
+  return false;
+}

package/src/domain/utils/error-handlers/error-converters.ts

@@ -0,0 +1,48 @@
+/**
+ * Error Converters
+ * Convert unknown errors to ErrorInfo
+ */
+
+import { hasCodeProperty } from '../type-guards.util';
+
+/**
+ * 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) {
+    return {
+      code: hasCodeProperty(error) ? error.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) {
+    return {
+      code: hasCodeProperty(error) && error.code ? error.code : 'auth/failed',
+      message: error.message,
+    };
+  }
+  return {
+    code: 'auth/failed',
+    message: typeof error === 'string' ? error : 'Unknown error',
+  };
+}

package/src/domain/utils/error-handlers/error-messages.ts

@@ -0,0 +1,18 @@
+/**
+ * Error Messages
+ * User-friendly error messages for common error types
+ */
+
+/**
+ * Get user-friendly quota error message
+ */
+export function getQuotaErrorMessage(): string {
+  return 'Daily quota exceeded. Please try again tomorrow or upgrade your plan.';
+}
+
+/**
+ * Get user-friendly retryable error message
+ */
+export function getRetryableErrorMessage(): string {
+  return 'Temporary error occurred. Please try again.';
+}

package/src/domain/utils/executors/advanced-executors.util.ts

@@ -0,0 +1,59 @@
+/**
+ * Advanced Async Executors
+ * Retry and timeout support for async operations
+ */
+
+import type { Result } from '../result.util';
+import { failureResultFromError, successResult } from '../result.util';
+import { executeOperation } from './basic-executors.util';
+
+/**
+ * Execute operation with retry
+ * @param operation - Operation to execute
+ * @param maxRetries - Maximum number of retries (default: 3)
+ * @param delayMs - Base delay between retries in milliseconds (default: 1000)
+ */
+export async function executeWithRetry<T>(
+  operation: () => Promise<T>,
+  maxRetries = 3,
+  delayMs = 1000
+): Promise<Result<T>> {
+  let lastError: unknown;
+  for (let i = 0; i <= maxRetries; i++) {
+    try {
+      const data = await operation();
+      return successResult(data);
+    } catch (error) {
+      lastError = error;
+      if (i < maxRetries) {
+        // Exponential backoff: delay * (attempt + 1)
+        await new Promise((resolve) => setTimeout(resolve, delayMs * (i + 1)));
+      }
+    }
+  }
+  return failureResultFromError(lastError);
+}
+
+/**
+ * Execute operation with timeout
+ * @param operation - Operation to execute
+ * @param timeoutMs - Timeout in milliseconds
+ */
+export async function executeWithTimeout<T>(
+  operation: () => Promise<T>,
+  timeoutMs: number
+): Promise<Result<T>> {
+  return Promise.race([
+    executeOperation(operation),
+    new Promise<Result<T>>((resolve) =>
+      setTimeout(
+        () =>
+          resolve({
+            success: false,
+            error: { code: 'timeout', message: `Operation timed out after ${timeoutMs}ms` },
+          }),
+        timeoutMs
+      )
+    ),
+  ]);
+}

package/src/domain/utils/executors/basic-executors.util.ts

@@ -0,0 +1,56 @@
+/**
+ * Basic Async Executors
+ * Core async operation execution with error handling
+ */
+
+import type { Result } from '../result.util';
+import { successResult } from '../result.util';
+import type { ErrorConverter } from './error-converters.util';
+import { authErrorConverter, defaultErrorConverter } from './error-converters.util';
+
+/**
+ * Execute async operation with error handling
+ * Returns Result type with success/failure
+ */
+export async function executeOperation<T>(
+  operation: () => Promise<T>,
+  errorConverter?: ErrorConverter
+): Promise<Result<T>> {
+  try {
+    const data = await operation();
+    return successResult(data);
+  } catch (error) {
+    const converter = errorConverter ?? defaultErrorConverter;
+    return { success: false, error: converter(error) };
+  }
+}
+
+/**
+ * Execute async operation with error handling and default code
+ */
+export async function executeOperationWithCode<T>(
+  operation: () => Promise<T>,
+  defaultErrorCode = 'operation/failed'
+): Promise<Result<T>> {
+  return executeOperation(operation, (error) => defaultErrorConverter(error, defaultErrorCode));
+}
+
+/**
+ * Execute async void operation
+ * Useful for operations that don't return data
+ */
+export async function executeVoidOperation(
+  operation: () => Promise<void>,
+  errorConverter?: ErrorConverter
+): Promise<Result<void>> {
+  return executeOperation(operation, errorConverter) as Promise<Result<void>>;
+}
+
+/**
+ * Execute async operation with auth error handling
+ */
+export async function executeAuthOperation<T>(
+  operation: () => Promise<T>
+): Promise<Result<T>> {
+  return executeOperation(operation, authErrorConverter);
+}