@onairos/react-native 3.1.9 → 3.1.12

package/src/services/apiKeyService.ts

@@ -89,7 +89,17 @@ export const initializeApiKey = async (config: OnairosConfig): Promise<void> =>
     const validation = await validateApiKey(config.apiKey);
     
     if (!validation.isValid) {
-      throw new Error(`API key validation failed: ${validation.error}`);
+      // If it's a network error or JSON parse error, warn but don't fail initialization
+      // Use defensive error checking to prevent compilation issues
+      const errorMessage = validation.error || '';
+      if (errorMessage.includes('Network error') || 
+          errorMessage.includes('JSON Parse error') || 
+          errorMessage.includes('API validation endpoint returned')) {
+        console.warn('⚠️ API key validation failed due to network/server issues, continuing in offline mode:', validation.error);
+        console.warn('📝 SDK will function with limited validation. Ensure your API key is valid for production use.');
+      } else {
+        throw new Error(`API key validation failed: ${validation.error}`);
+      }
     }
 
     // Try to load existing JWT token
@@ -195,82 +205,192 @@ export const validateApiKey = async (apiKey: string): Promise<ApiKeyValidationRe
     const environment = globalConfig?.environment || 'production';
     const baseUrl = API_ENDPOINTS[environment];
     const timeout = globalConfig?.timeout || 30000;
+    const maxRetries = globalConfig?.retryAttempts || 3;
 
-    // Create abort controller for timeout
-    const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), timeout);
-
-    try {
-      const response = await fetch(`${baseUrl}/auth/validate-key`, {
-        method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          'Authorization': `Bearer ${apiKey}`,
-          'User-Agent': 'OnairosReactNative/1.0',
-          'X-API-Key-Type': keyType,
-        },
-        body: JSON.stringify({
-          environment,
-          sdk_version: '3.0.72',
-          platform: 'react-native',
-          keyType,
-          timestamp: new Date().toISOString(),
-        }),
-        signal: controller.signal,
-      });
+    // Retry logic for network failures
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      // Create abort controller for timeout
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
 
-      clearTimeout(timeoutId);
+      try {
+        if (globalConfig?.enableLogging && attempt > 1) {
+          console.log(`🔄 Retry attempt ${attempt}/${maxRetries} for API key validation`);
+        }
 
-      const data = await response.json();
+        const response = await fetch(`${baseUrl}/auth/validate-key`, {
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'Authorization': `Bearer ${apiKey}`,
+            'User-Agent': 'OnairosReactNative/3.1.11',
+            'X-API-Key-Type': keyType,
+            'X-SDK-Platform': 'react-native',
+            'X-Retry-Attempt': attempt.toString(),
+          },
+          body: JSON.stringify({
+            environment,
+            sdk_version: '3.1.11',
+            platform: 'react-native',
+            keyType,
+            timestamp: new Date().toISOString(),
+            attempt,
+          }),
+          signal: controller.signal,
+        });
 
-      if (response.ok && data.success) {
-        const result: ApiKeyValidationResult = {
-          isValid: true,
-          permissions: data.permissions || [],
-          rateLimits: data.rateLimits || null,
-          keyType: keyType,
-        };
+        clearTimeout(timeoutId);
 
-        // Cache the successful result
-        validationCache.set(apiKey, {
-          result,
-          timestamp: Date.now(),
-        });
+        // First check if we got a valid response
+        if (!response) {
+          throw new Error('No response received from server');
+        }
 
-        if (globalConfig?.enableLogging) {
-          console.log('✅ API key validation successful');
+        // Check if response is actually JSON before trying to parse
+        const contentType = response.headers.get('content-type');
+        const isJsonResponse = contentType && contentType.includes('application/json');
+        
+        if (!isJsonResponse) {
+          const textContent = await response.text();
+          const previewText = textContent.substring(0, 200);
+          
+          console.error('❌ API endpoint returned non-JSON response:', {
+            status: response.status,
+            statusText: response.statusText,
+            contentType: contentType || 'unknown',
+            preview: previewText,
+            url: `${baseUrl}/auth/validate-key`,
+            attempt: attempt
+          });
+          
+          // Handle specific error cases
+          if (response.status === 404) {
+            throw new Error(`API validation endpoint not found (404). The endpoint ${baseUrl}/auth/validate-key may not exist or be configured correctly.`);
+          } else if (response.status === 500) {
+            throw new Error(`Server error (500). The Onairos backend is experiencing issues.`);
+          } else if (response.status === 502 || response.status === 503) {
+            throw new Error(`Service unavailable (${response.status}). The Onairos backend may be temporarily down.`);
+          } else if (textContent.includes('<html') || textContent.includes('<!DOCTYPE')) {
+            throw new Error(`Server returned HTML page instead of JSON API response. This often indicates a routing issue or server misconfiguration.`);
+          } else {
+            throw new Error(`API validation endpoint returned ${response.status} - ${response.statusText}. Expected JSON but got ${contentType || 'unknown content type'}.`);
+          }
         }
 
-        return result;
-      } else {
-        const errorMessage = data.error || `HTTP ${response.status}: ${response.statusText}`;
+        // Parse JSON response
+        let data;
+        try {
+          data = await response.json();
+        } catch (jsonError) {
+          console.error('❌ Failed to parse JSON response:', {
+            error: jsonError.message,
+            status: response.status,
+            contentType,
+            attempt: attempt
+          });
+          throw new Error(`Failed to parse server response as JSON: ${jsonError.message}`);
+        }
+
+        // Handle successful response
+        if (response.ok && data.success) {
+          const result: ApiKeyValidationResult = {
+            isValid: true,
+            permissions: data.permissions || [],
+            rateLimits: data.rateLimits || null,
+            keyType: keyType,
+          };
+
+          // Cache the successful result
+          validationCache.set(apiKey, {
+            result,
+            timestamp: Date.now(),
+          });
+
+          if (globalConfig?.enableLogging) {
+            console.log('✅ API key validation successful');
+          }
+
+          return result;
+        } else {
+          // Handle API errors (invalid key, etc.)
+          const errorMessage = data.error || data.message || `HTTP ${response.status}: ${response.statusText}`;
+          
+          const result: ApiKeyValidationResult = {
+            isValid: false,
+            error: errorMessage,
+            keyType: keyType,
+          };
+
+          // For client errors (4xx), don't retry
+          if (response.status >= 400 && response.status < 500) {
+            if (globalConfig?.enableLogging) {
+              console.error('❌ API key validation failed (client error):', errorMessage);
+            }
+            return result;
+          }
+
+          // For server errors (5xx), retry
+          throw new Error(errorMessage);
+        }
+
+      } catch (fetchError: any) {
+        clearTimeout(timeoutId);
         
-        const result: ApiKeyValidationResult = {
-          isValid: false,
-          error: errorMessage,
-          keyType: keyType,
-        };
-
-        // Don't cache failed results
-        if (globalConfig?.enableLogging) {
-          console.error('❌ API key validation failed:', errorMessage);
+        if (fetchError.name === 'AbortError') {
+          const errorMessage = `API key validation timeout (${timeout}ms)`;
+          console.error('⏱️ API key validation timeout');
+          
+          if (attempt === maxRetries) {
+            return { isValid: false, error: errorMessage, keyType: keyType };
+          }
+          continue; // Retry timeout errors
         }
+        
+        // Enhanced error message based on error type
+        let errorMessage = `Network error during API key validation: ${fetchError.message}`;
+        
+        // Add specific guidance for common errors
+        if (fetchError.message.includes('JSON Parse error') || fetchError.message.includes('Unexpected character')) {
+          errorMessage = `Server returned invalid JSON response. This usually indicates the API endpoint returned HTML instead of JSON (often a 404 or server error page). ${fetchError.message}`;
+        } else if (fetchError.message.includes('Network request failed') || fetchError.message.includes('fetch')) {
+          errorMessage = `Network connectivity issue. Please check internet connection and verify the Onairos API is accessible. ${fetchError.message}`;
+        } else if (fetchError.message.includes('DNS') || fetchError.message.includes('ENOTFOUND')) {
+          errorMessage = `DNS resolution failed for ${baseUrl}. Please check network settings and domain accessibility. ${fetchError.message}`;
+        }
+        
+        console.error('🌐 Network error during API key validation:', {
+          error: fetchError,
+          endpoint: `${baseUrl}/auth/validate-key`,
+          attempt: attempt,
+          maxRetries: maxRetries,
+          retryable: attempt < maxRetries
+        });
 
-        return result;
-      }
-    } catch (fetchError: any) {
-      clearTimeout(timeoutId);
-      
-      if (fetchError.name === 'AbortError') {
-        const errorMessage = 'API key validation timeout';
-        console.error('⏱️ API key validation timeout');
-        return { isValid: false, error: errorMessage, keyType: keyType };
+        // If this is the last attempt, return the error
+        if (attempt === maxRetries) {
+          return { 
+            isValid: false, 
+            error: errorMessage, 
+            keyType: keyType 
+          };
+        }
+
+                 // Wait before retrying (exponential backoff)
+         const backoffDelay = Math.min(1000 * Math.pow(2, attempt - 1), 5000);
+         if (globalConfig?.enableLogging) {
+           console.log(`⏳ Waiting ${backoffDelay}ms before retry...`);
+         }
+         await new Promise<void>(resolve => setTimeout(() => resolve(), backoffDelay));
       }
-      
-      const errorMessage = `Network error during API key validation: ${fetchError.message}`;
-      console.error('🌐 Network error during API key validation:', fetchError);
-      return { isValid: false, error: errorMessage, keyType: keyType };
     }
+
+    // This should never be reached, but just in case
+    return { 
+      isValid: false, 
+      error: 'All retry attempts exhausted', 
+      keyType: keyType 
+    };
+
   } catch (error: any) {
     const errorMessage = `API key validation error: ${error.message}`;
     console.error('❌ API key validation error:', error);
@@ -511,8 +631,8 @@ export const getAuthHeaders = (): Record<string, string> => {
   return {
     'Content-Type': 'application/json',
     'Authorization': `Bearer ${globalConfig.apiKey}`,
-    'User-Agent': 'OnairosReactNative/3.0.72',
-    'X-SDK-Version': '3.0.72',
+    'User-Agent': 'OnairosReactNative/3.1.11',
+    'X-SDK-Version': '3.1.11',
     'X-SDK-Environment': globalConfig.environment || 'production',
     'X-API-Key-Type': keyType,
     'X-Timestamp': new Date().toISOString(),
@@ -534,7 +654,7 @@ export const getDeveloperAuthHeaders = (): Record<string, string> => {
     'Content-Type': 'application/json',
     'Authorization': `Bearer ${globalConfig.apiKey}`,
     'User-Agent': 'OnairosSDK/1.0.0',
-    'X-SDK-Version': '3.0.72',
+    'X-SDK-Version': '3.1.11',
     'X-SDK-Environment': globalConfig.environment || 'production',
     'X-API-Key-Type': keyType,
     'X-Timestamp': new Date().toISOString(),
@@ -554,7 +674,7 @@ export const getUserAuthHeaders = (): Record<string, string> => {
     'Content-Type': 'application/json',
     'Authorization': `Bearer ${userToken}`,
     'User-Agent': 'OnairosSDK/1.0.0',
-    'X-SDK-Version': '3.0.72',
+    'X-SDK-Version': '3.1.11',
     'X-SDK-Environment': globalConfig?.environment || 'production',
   };
 };

package/src/utils/retryHelper.ts

@@ -0,0 +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
+    };
+  }
+}