@onairos/react-native 3.1.16 → 3.1.18

package/src/utils/retryHelper.ts

@@ -1,275 +1,275 @@
-/**
- * 🔄 Retry Helper Utility
- * 
- * Provides robust retry logic with exponential backoff for network operations.
- * Used throughout the Onairos SDK for handling transient failures gracefully.
- */
-
-export interface RetryOptions {
-  /** Maximum number of retry attempts */
-  maxRetries: number;
-  /** Base delay between retries in milliseconds */
-  baseDelay: number;
-  /** Maximum delay between retries in milliseconds */
-  maxDelay: number;
-  /** Whether to use exponential backoff */
-  exponentialBackoff: boolean;
-  /** Function to determine if an error should trigger a retry */
-  shouldRetry?: (error: any, attempt: number) => boolean;
-  /** Function called before each retry attempt */
-  onRetry?: (error: any, attempt: number, nextDelay: number) => void;
-  /** Enable logging of retry attempts */
-  enableLogging: boolean;
-}
-
-export interface RetryResult<T> {
-  success: boolean;
-  data?: T;
-  error?: Error;
-  attempts: number;
-  totalDuration: number;
-}
-
-/**
- * Default retry options for the Onairos SDK
- */
-export const DEFAULT_RETRY_OPTIONS: RetryOptions = {
-  maxRetries: 3,
-  baseDelay: 1000,
-  maxDelay: 5000,
-  exponentialBackoff: true,
-  enableLogging: false,
-  shouldRetry: (error: any, attempt: number) => {
-    // Don't retry client errors (4xx) except for 408 (timeout) and 429 (rate limit)
-    if (error.status >= 400 && error.status < 500 && error.status !== 408 && error.status !== 429) {
-      return false;
-    }
-    
-    // Retry network errors, timeouts, and server errors (5xx)
-    if (error.name === 'AbortError' || 
-        error.message.includes('Network request failed') ||
-        error.message.includes('fetch') ||
-        error.message.includes('ENOTFOUND') ||
-        error.message.includes('timeout') ||
-        (error.status >= 500)) {
-      return true;
-    }
-    
-    // Retry JSON parse errors (likely server issues)
-    if (error.message.includes('JSON Parse error') || error.message.includes('Unexpected character')) {
-      return true;
-    }
-    
-    return false;
-  }
-};
-
-/**
- * Execute a function with retry logic and exponential backoff
- * @param fn Function to execute (should return a Promise)
- * @param options Retry configuration options
- * @returns Promise with retry result
- */
-export async function withRetry<T>(
-  fn: () => Promise<T>,
-  options: Partial<RetryOptions> = {}
-): Promise<RetryResult<T>> {
-  const config = { ...DEFAULT_RETRY_OPTIONS, ...options };
-  const startTime = Date.now();
-  let lastError: Error | null = null;
-
-  for (let attempt = 1; attempt <= config.maxRetries + 1; attempt++) {
-    try {
-      if (config.enableLogging && attempt > 1) {
-        console.log(`🔄 Retry attempt ${attempt}/${config.maxRetries + 1}`);
-      }
-
-      const result = await fn();
-      
-      return {
-        success: true,
-        data: result,
-        attempts: attempt,
-        totalDuration: Date.now() - startTime
-      };
-
-    } catch (error: any) {
-      lastError = error;
-      
-      // Check if we should retry this error
-      const shouldRetryError = config.shouldRetry ? config.shouldRetry(error, attempt) : true;
-      
-      // If this is the last attempt or we shouldn't retry, throw the error
-      if (attempt > config.maxRetries || !shouldRetryError) {
-        if (config.enableLogging) {
-          console.error(`❌ All retry attempts exhausted or error not retryable: ${error.message}`);
-        }
-        break;
-      }
-
-      // Calculate delay for next attempt
-      let delay = config.baseDelay;
-      if (config.exponentialBackoff) {
-        delay = Math.min(config.baseDelay * Math.pow(2, attempt - 1), config.maxDelay);
-      }
-
-      // Add some jitter to prevent thundering herd
-      const jitter = Math.random() * 0.1 * delay;
-      delay = Math.floor(delay + jitter);
-
-      if (config.onRetry) {
-        config.onRetry(error, attempt, delay);
-      }
-
-      if (config.enableLogging) {
-        console.log(`⏳ Waiting ${delay}ms before retry (attempt ${attempt}/${config.maxRetries + 1})`);
-      }
-
-      // Wait before next attempt
-      await new Promise<void>(resolve => setTimeout(() => resolve(), delay));
-    }
-  }
-
-  return {
-    success: false,
-    error: lastError || new Error('Unknown error'),
-    attempts: config.maxRetries + 1,
-    totalDuration: Date.now() - startTime
-  };
-}
-
-/**
- * Retry configuration for API calls
- */
-export const API_RETRY_OPTIONS: Partial<RetryOptions> = {
-  maxRetries: 3,
-  baseDelay: 1000,
-  maxDelay: 5000,
-  exponentialBackoff: true,
-  shouldRetry: (error: any, attempt: number) => {
-    // Enhanced retry logic for API calls
-    
-    // Never retry authentication errors (401) or permission errors (403)
-    if (error.status === 401 || error.status === 403) {
-      return false;
-    }
-    
-    // Never retry bad request errors (400) or not found (404) unless it's a specific case
-    if (error.status === 400 || (error.status === 404 && !error.message.includes('validation endpoint'))) {
-      return false;
-    }
-    
-    // Retry rate limiting (429) with longer delays
-    if (error.status === 429) {
-      return attempt <= 2; // Limit retries for rate limiting
-    }
-    
-    // Retry server errors (5xx)
-    if (error.status >= 500) {
-      return true;
-    }
-    
-    // Retry timeout and network errors
-    if (error.name === 'AbortError' || 
-        error.message.includes('timeout') ||
-        error.message.includes('Network request failed') ||
-        error.message.includes('fetch') ||
-        error.message.includes('ENOTFOUND')) {
-      return true;
-    }
-    
-    // Retry JSON parse errors (server returning HTML instead of JSON)
-    if (error.message.includes('JSON Parse error') || 
-        error.message.includes('Unexpected character') ||
-        error.message.includes('HTML page instead of JSON')) {
-      return true;
-    }
-    
-    return false;
-  },
-  onRetry: (error: any, attempt: number, delay: number) => {
-    console.warn(`⚠️ API call failed (attempt ${attempt}), retrying in ${delay}ms: ${error.message}`);
-  }
-};
-
-/**
- * Specialized retry for network/connectivity issues
- */
-export const NETWORK_RETRY_OPTIONS: Partial<RetryOptions> = {
-  maxRetries: 2,
-  baseDelay: 2000,
-  maxDelay: 8000,
-  exponentialBackoff: true,
-  shouldRetry: (error: any, attempt: number) => {
-    // Only retry actual network/connectivity issues
-    return error.message.includes('Network request failed') ||
-           error.message.includes('ENOTFOUND') ||
-           error.message.includes('DNS') ||
-           error.name === 'AbortError';
-  }
-};
-
-/**
- * Create a retry wrapper for fetch requests
- * @param url Request URL
- * @param options Fetch options
- * @param retryOptions Retry configuration
- * @returns Promise with fetch response
- */
-export async function fetchWithRetry(
-  url: string, 
-  options: RequestInit = {}, 
-  retryOptions: Partial<RetryOptions> = API_RETRY_OPTIONS
-): Promise<Response> {
-  const result = await withRetry(
-    () => fetch(url, options),
-    retryOptions
-  );
-
-  if (!result.success) {
-    throw result.error;
-  }
-
-  return result.data!;
-}
-
-/**
- * Health check function with retry for testing connectivity
- * @param url URL to check
- * @param timeout Timeout in milliseconds
- * @returns Promise indicating if the service is reachable
- */
-export async function healthCheck(
-  url: string, 
-  timeout: number = 5000
-): Promise<{ reachable: boolean; status?: number; error?: string; duration: number }> {
-  const startTime = Date.now();
-  
-  try {
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), timeout);
-    
-    const response = await fetch(url, {
-      method: 'GET',
-      signal: controller.signal,
-      headers: {
-        'User-Agent': 'OnairosReactNative/HealthCheck'
-      }
-    });
-    
-    clearTimeout(timeoutId);
-    
-    return {
-      reachable: true,
-      status: response.status,
-      duration: Date.now() - startTime
-    };
-    
-  } catch (error: any) {
-    return {
-      reachable: false,
-      error: error.message,
-      duration: Date.now() - startTime
-    };
-  }
+/**
+ * 🔄 Retry Helper Utility
+ * 
+ * Provides robust retry logic with exponential backoff for network operations.
+ * Used throughout the Onairos SDK for handling transient failures gracefully.
+ */
+
+export interface RetryOptions {
+  /** Maximum number of retry attempts */
+  maxRetries: number;
+  /** Base delay between retries in milliseconds */
+  baseDelay: number;
+  /** Maximum delay between retries in milliseconds */
+  maxDelay: number;
+  /** Whether to use exponential backoff */
+  exponentialBackoff: boolean;
+  /** Function to determine if an error should trigger a retry */
+  shouldRetry?: (error: any, attempt: number) => boolean;
+  /** Function called before each retry attempt */
+  onRetry?: (error: any, attempt: number, nextDelay: number) => void;
+  /** Enable logging of retry attempts */
+  enableLogging: boolean;
+}
+
+export interface RetryResult<T> {
+  success: boolean;
+  data?: T;
+  error?: Error;
+  attempts: number;
+  totalDuration: number;
+}
+
+/**
+ * Default retry options for the Onairos SDK
+ */
+export const DEFAULT_RETRY_OPTIONS: RetryOptions = {
+  maxRetries: 3,
+  baseDelay: 1000,
+  maxDelay: 5000,
+  exponentialBackoff: true,
+  enableLogging: false,
+  shouldRetry: (error: any, attempt: number) => {
+    // Don't retry client errors (4xx) except for 408 (timeout) and 429 (rate limit)
+    if (error.status >= 400 && error.status < 500 && error.status !== 408 && error.status !== 429) {
+      return false;
+    }
+    
+    // Retry network errors, timeouts, and server errors (5xx)
+    if (error.name === 'AbortError' || 
+        error.message.includes('Network request failed') ||
+        error.message.includes('fetch') ||
+        error.message.includes('ENOTFOUND') ||
+        error.message.includes('timeout') ||
+        (error.status >= 500)) {
+      return true;
+    }
+    
+    // Retry JSON parse errors (likely server issues)
+    if (error.message.includes('JSON Parse error') || error.message.includes('Unexpected character')) {
+      return true;
+    }
+    
+    return false;
+  }
+};
+
+/**
+ * Execute a function with retry logic and exponential backoff
+ * @param fn Function to execute (should return a Promise)
+ * @param options Retry configuration options
+ * @returns Promise with retry result
+ */
+export async function withRetry<T>(
+  fn: () => Promise<T>,
+  options: Partial<RetryOptions> = {}
+): Promise<RetryResult<T>> {
+  const config = { ...DEFAULT_RETRY_OPTIONS, ...options };
+  const startTime = Date.now();
+  let lastError: Error | null = null;
+
+  for (let attempt = 1; attempt <= config.maxRetries + 1; attempt++) {
+    try {
+      if (config.enableLogging && attempt > 1) {
+        console.log(`🔄 Retry attempt ${attempt}/${config.maxRetries + 1}`);
+      }
+
+      const result = await fn();
+      
+      return {
+        success: true,
+        data: result,
+        attempts: attempt,
+        totalDuration: Date.now() - startTime
+      };
+
+    } catch (error: any) {
+      lastError = error;
+      
+      // Check if we should retry this error
+      const shouldRetryError = config.shouldRetry ? config.shouldRetry(error, attempt) : true;
+      
+      // If this is the last attempt or we shouldn't retry, throw the error
+      if (attempt > config.maxRetries || !shouldRetryError) {
+        if (config.enableLogging) {
+          console.error(`❌ All retry attempts exhausted or error not retryable: ${error.message}`);
+        }
+        break;
+      }
+
+      // Calculate delay for next attempt
+      let delay = config.baseDelay;
+      if (config.exponentialBackoff) {
+        delay = Math.min(config.baseDelay * Math.pow(2, attempt - 1), config.maxDelay);
+      }
+
+      // Add some jitter to prevent thundering herd
+      const jitter = Math.random() * 0.1 * delay;
+      delay = Math.floor(delay + jitter);
+
+      if (config.onRetry) {
+        config.onRetry(error, attempt, delay);
+      }
+
+      if (config.enableLogging) {
+        console.log(`⏳ Waiting ${delay}ms before retry (attempt ${attempt}/${config.maxRetries + 1})`);
+      }
+
+      // Wait before next attempt
+      await new Promise<void>(resolve => setTimeout(() => resolve(), delay));
+    }
+  }
+
+  return {
+    success: false,
+    error: lastError || new Error('Unknown error'),
+    attempts: config.maxRetries + 1,
+    totalDuration: Date.now() - startTime
+  };
+}
+
+/**
+ * Retry configuration for API calls
+ */
+export const API_RETRY_OPTIONS: Partial<RetryOptions> = {
+  maxRetries: 3,
+  baseDelay: 1000,
+  maxDelay: 5000,
+  exponentialBackoff: true,
+  shouldRetry: (error: any, attempt: number) => {
+    // Enhanced retry logic for API calls
+    
+    // Never retry authentication errors (401) or permission errors (403)
+    if (error.status === 401 || error.status === 403) {
+      return false;
+    }
+    
+    // Never retry bad request errors (400) or not found (404) unless it's a specific case
+    if (error.status === 400 || (error.status === 404 && !error.message.includes('validation endpoint'))) {
+      return false;
+    }
+    
+    // Retry rate limiting (429) with longer delays
+    if (error.status === 429) {
+      return attempt <= 2; // Limit retries for rate limiting
+    }
+    
+    // Retry server errors (5xx)
+    if (error.status >= 500) {
+      return true;
+    }
+    
+    // Retry timeout and network errors
+    if (error.name === 'AbortError' || 
+        error.message.includes('timeout') ||
+        error.message.includes('Network request failed') ||
+        error.message.includes('fetch') ||
+        error.message.includes('ENOTFOUND')) {
+      return true;
+    }
+    
+    // Retry JSON parse errors (server returning HTML instead of JSON)
+    if (error.message.includes('JSON Parse error') || 
+        error.message.includes('Unexpected character') ||
+        error.message.includes('HTML page instead of JSON')) {
+      return true;
+    }
+    
+    return false;
+  },
+  onRetry: (error: any, attempt: number, delay: number) => {
+    console.warn(`⚠️ API call failed (attempt ${attempt}), retrying in ${delay}ms: ${error.message}`);
+  }
+};
+
+/**
+ * Specialized retry for network/connectivity issues
+ */
+export const NETWORK_RETRY_OPTIONS: Partial<RetryOptions> = {
+  maxRetries: 2,
+  baseDelay: 2000,
+  maxDelay: 8000,
+  exponentialBackoff: true,
+  shouldRetry: (error: any, attempt: number) => {
+    // Only retry actual network/connectivity issues
+    return error.message.includes('Network request failed') ||
+           error.message.includes('ENOTFOUND') ||
+           error.message.includes('DNS') ||
+           error.name === 'AbortError';
+  }
+};
+
+/**
+ * Create a retry wrapper for fetch requests
+ * @param url Request URL
+ * @param options Fetch options
+ * @param retryOptions Retry configuration
+ * @returns Promise with fetch response
+ */
+export async function fetchWithRetry(
+  url: string, 
+  options: RequestInit = {}, 
+  retryOptions: Partial<RetryOptions> = API_RETRY_OPTIONS
+): Promise<Response> {
+  const result = await withRetry(
+    () => fetch(url, options),
+    retryOptions
+  );
+
+  if (!result.success) {
+    throw result.error;
+  }
+
+  return result.data!;
+}
+
+/**
+ * Health check function with retry for testing connectivity
+ * @param url URL to check
+ * @param timeout Timeout in milliseconds
+ * @returns Promise indicating if the service is reachable
+ */
+export async function healthCheck(
+  url: string, 
+  timeout: number = 5000
+): Promise<{ reachable: boolean; status?: number; error?: string; duration: number }> {
+  const startTime = Date.now();
+  
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    
+    const response = await fetch(url, {
+      method: 'GET',
+      signal: controller.signal,
+      headers: {
+        'User-Agent': 'OnairosReactNative/HealthCheck'
+      }
+    });
+    
+    clearTimeout(timeoutId);
+    
+    return {
+      reachable: true,
+      status: response.status,
+      duration: Date.now() - startTime
+    };
+    
+  } catch (error: any) {
+    return {
+      reachable: false,
+      error: error.message,
+      duration: Date.now() - startTime
+    };
+  }
 }