@onairos/react-native 3.0.71 → 3.0.72

package/src/services/apiKeyService.ts

@@ -0,0 +1,325 @@
+import type { OnairosConfig, ApiKeyValidationResult } from '../types';
+
+/**
+ * API Key Service for Onairos React Native SDK
+ * 
+ * This service handles API key validation, management, and authentication
+ * following standard SDK patterns for secure API key handling.
+ * 
+ * How it works:
+ * 1. Initialize with API key and configuration
+ * 2. Validate API key with the Onairos backend
+ * 3. Cache validation results for performance
+ * 4. Include API key in all authenticated requests
+ * 5. Handle API key errors gracefully with developer-friendly messages
+ */
+
+// Global configuration state
+let globalConfig: OnairosConfig | null = null;
+let validationCache: Map<string, { result: ApiKeyValidationResult; timestamp: number }> = new Map();
+let isInitialized = false;
+
+// Cache duration (5 minutes)
+const CACHE_DURATION = 5 * 60 * 1000;
+
+// API endpoints for different environments
+const API_ENDPOINTS = {
+  production: 'https://api2.onairos.uk',
+  staging: 'https://staging-api.onairos.uk',
+  development: 'https://dev-api.onairos.uk',
+};
+
+/**
+ * Initialize the SDK with API key and configuration
+ * @param config API configuration including API key
+ */
+export const initializeApiKey = async (config: OnairosConfig): Promise<void> => {
+  try {
+    console.log('🔑 Initializing Onairos SDK with API key...');
+    
+    if (!config.apiKey) {
+      throw new Error('API key is required for SDK initialization');
+    }
+
+    if (config.apiKey.length < 32) {
+      throw new Error('Invalid API key format. API key must be at least 32 characters long.');
+    }
+
+    // Set global configuration
+    globalConfig = {
+      apiKey: config.apiKey,
+      environment: config.environment || 'production',
+      enableLogging: config.enableLogging !== false, // Default to true
+      timeout: config.timeout || 30000,
+      retryAttempts: config.retryAttempts || 3,
+    };
+
+    if (globalConfig.enableLogging) {
+      console.log('📝 SDK Configuration:', {
+        environment: globalConfig.environment,
+        timeout: globalConfig.timeout,
+        retryAttempts: globalConfig.retryAttempts,
+        apiKeyPrefix: config.apiKey.substring(0, 8) + '...',
+        enableLogging: globalConfig.enableLogging,
+      });
+    }
+
+    // Validate the API key
+    const validation = await validateApiKey(config.apiKey);
+    
+    if (!validation.isValid) {
+      throw new Error(`API key validation failed: ${validation.error}`);
+    }
+
+    isInitialized = true;
+    
+    if (globalConfig.enableLogging) {
+      console.log('✅ Onairos SDK initialized successfully');
+      if (validation.permissions) {
+        console.log('🔐 API Key Permissions:', validation.permissions);
+      }
+      if (validation.rateLimits) {
+        console.log('⏱️ Rate Limits:', validation.rateLimits);
+      }
+    }
+  } catch (error) {
+    console.error('❌ Failed to initialize Onairos SDK:', error);
+    isInitialized = false;
+    throw error;
+  }
+};
+
+/**
+ * Validate an API key with the Onairos backend
+ * @param apiKey The API key to validate
+ * @returns Validation result with permissions and rate limits
+ */
+export const validateApiKey = async (apiKey: string): Promise<ApiKeyValidationResult> => {
+  try {
+    console.log('🔍 Validating API key...');
+    
+    // Check cache first
+    const cached = validationCache.get(apiKey);
+    if (cached && Date.now() - cached.timestamp < CACHE_DURATION) {
+      if (globalConfig?.enableLogging) {
+        console.log('📋 Using cached API key validation result');
+      }
+      return cached.result;
+    }
+
+    const environment = globalConfig?.environment || 'production';
+    const baseUrl = API_ENDPOINTS[environment];
+    const timeout = globalConfig?.timeout || 30000;
+
+    // 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',
+        },
+        body: JSON.stringify({
+          environment,
+          sdk_version: '3.0.71',
+          platform: 'react-native',
+        }),
+        signal: controller.signal,
+      });
+
+      clearTimeout(timeoutId);
+
+      const data = await response.json();
+
+      if (response.ok && data.success) {
+        const result: ApiKeyValidationResult = {
+          isValid: true,
+          permissions: data.permissions || [],
+          rateLimits: data.rateLimits || null,
+        };
+
+        // Cache the successful result
+        validationCache.set(apiKey, {
+          result,
+          timestamp: Date.now(),
+        });
+
+        if (globalConfig?.enableLogging) {
+          console.log('✅ API key validation successful');
+        }
+
+        return result;
+      } else {
+        const errorMessage = data.error || `HTTP ${response.status}: ${response.statusText}`;
+        
+        const result: ApiKeyValidationResult = {
+          isValid: false,
+          error: errorMessage,
+        };
+
+        // Don't cache failed results
+        if (globalConfig?.enableLogging) {
+          console.error('❌ API key validation failed:', errorMessage);
+        }
+
+        return result;
+      }
+    } catch (fetchError) {
+      clearTimeout(timeoutId);
+      
+      if (fetchError.name === 'AbortError') {
+        const errorMessage = 'API key validation timeout';
+        console.error('⏱️ API key validation timeout');
+        return { isValid: false, error: errorMessage };
+      }
+      
+      const errorMessage = `Network error during API key validation: ${fetchError.message}`;
+      console.error('🌐 Network error during API key validation:', fetchError);
+      return { isValid: false, error: errorMessage };
+    }
+  } catch (error) {
+    const errorMessage = `API key validation error: ${error.message}`;
+    console.error('❌ API key validation error:', error);
+    return { isValid: false, error: errorMessage };
+  }
+};
+
+/**
+ * Get the current API configuration
+ * @returns Current API configuration or null if not initialized
+ */
+export const getApiConfig = (): OnairosConfig | null => {
+  return globalConfig;
+};
+
+/**
+ * Get the current API key
+ * @returns Current API key or null if not initialized
+ */
+export const getApiKey = (): string | null => {
+  return globalConfig?.apiKey || null;
+};
+
+/**
+ * Check if the SDK is properly initialized
+ * @returns True if initialized with valid API key
+ */
+export const isApiKeyInitialized = (): boolean => {
+  return isInitialized && globalConfig !== null;
+};
+
+/**
+ * Get authenticated headers for API requests
+ * @returns Headers object with Authorization and other required headers
+ */
+export const getAuthHeaders = (): Record<string, string> => {
+  if (!globalConfig?.apiKey) {
+    throw new Error('SDK not initialized. Call initializeApiKey() first.');
+  }
+
+  return {
+    'Content-Type': 'application/json',
+    'Authorization': `Bearer ${globalConfig.apiKey}`,
+    'User-Agent': 'OnairosReactNative/3.0.71',
+    'X-SDK-Version': '3.0.71',
+    'X-SDK-Environment': globalConfig.environment || 'production',
+  };
+};
+
+/**
+ * Make an authenticated API request
+ * @param endpoint The API endpoint (relative to base URL)
+ * @param options Fetch options
+ * @returns Response promise
+ */
+export const makeAuthenticatedRequest = async (
+  endpoint: string,
+  options: RequestInit = {}
+): Promise<Response> => {
+  if (!isApiKeyInitialized()) {
+    throw new Error('SDK not initialized. Call initializeApiKey() first.');
+  }
+
+  const config = getApiConfig()!;
+  const baseUrl = API_ENDPOINTS[config.environment || 'production'];
+  const url = `${baseUrl}${endpoint.startsWith('/') ? '' : '/'}${endpoint}`;
+
+  // Merge authentication headers
+  const headers = {
+    ...getAuthHeaders(),
+    ...(options.headers || {}),
+  };
+
+  // Add timeout
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => controller.abort(), config.timeout || 30000);
+
+  try {
+    if (config.enableLogging) {
+      console.log(`🌐 Making authenticated request to: ${endpoint}`);
+    }
+
+    const response = await fetch(url, {
+      ...options,
+      headers,
+      signal: controller.signal,
+    });
+
+    clearTimeout(timeoutId);
+
+    if (config.enableLogging) {
+      console.log(`📡 Response status: ${response.status} for ${endpoint}`);
+    }
+
+    // Handle API key errors
+    if (response.status === 401) {
+      console.error('❌ API key authentication failed. Please check your API key.');
+      throw new Error('Invalid or expired API key');
+    }
+
+    if (response.status === 403) {
+      console.error('❌ API key permissions insufficient for this operation.');
+      throw new Error('Insufficient API key permissions');
+    }
+
+    if (response.status === 429) {
+      console.error('❌ API rate limit exceeded. Please try again later.');
+      throw new Error('Rate limit exceeded');
+    }
+
+    return response;
+  } catch (error) {
+    clearTimeout(timeoutId);
+    
+    if (error.name === 'AbortError') {
+      console.error('⏱️ Request timeout for:', endpoint);
+      throw new Error('Request timeout');
+    }
+    
+    throw error;
+  }
+};
+
+/**
+ * Clear the API key validation cache
+ */
+export const clearValidationCache = (): void => {
+  validationCache.clear();
+  if (globalConfig?.enableLogging) {
+    console.log('🗑️ API key validation cache cleared');
+  }
+};
+
+/**
+ * Reset the SDK initialization state
+ */
+export const resetApiKeyService = (): void => {
+  globalConfig = null;
+  isInitialized = false;
+  clearValidationCache();
+  console.log('🔄 API key service reset');
+};