@onairos/react-native 3.1.11 → 3.1.13

package/src/hooks/useConnections.ts

@@ -1,163 +1,161 @@
 import { useState, useCallback } from 'react';
-import { Platform } from 'react-native';
-import { STORAGE_KEYS } from '../constants';
-import type { ConnectionStatus } from '../types';
+import { initiateOAuth, initiateNativeAuth, exchangeCodeForToken } from '../services/platformAuthService';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import { getOnairosUsername } from '../services/authService';
 
-// Create a mock storage for environments without Keychain access (like Expo Go)
-const mockConnectionStorage: Record<string, ConnectionStatus> = {};
-
-// Try to import Keychain, but provide fallbacks if not available
-let Keychain: any = null;
-try {
-  // This import might fail in Expo Go or environments without native modules
-  Keychain = require('react-native-keychain');
-} catch (error) {
-  console.warn('react-native-keychain module not available in useConnections, using mock storage');
+export interface ConnectionStatus {
+  [key: string]: {
+    userName: string;
+    connected: boolean;
+  };
 }
 
-// Check if Keychain is properly initialized and available
-const isKeychainAvailable = () => {
-  try {
-    return Keychain && typeof Keychain.getGenericPassword === 'function';
-  } catch (e) {
-    return false;
-  }
-};
-
 export const useConnections = () => {
+  const [connections, setConnections] = useState<ConnectionStatus>({});
   const [isConnecting, setIsConnecting] = useState(false);
 
-  const getConnectionStatus = useCallback(async (): Promise<ConnectionStatus> => {
+  /**
+   * Connect a platform using OAuth or native SDK
+   */
+  const connectPlatform = useCallback(async (platform: string, username: string): Promise<boolean> => {
     try {
-      if (isKeychainAvailable()) {
+      setIsConnecting(true);
+
+      // Determine if we should use native SDK or OAuth
+      const useNativeSDK = platform === 'youtube' || platform === 'instagram';
+
+      let success = false;
+      
+      if (useNativeSDK) {
+        // Use native SDK
+        success = await initiateNativeAuth(platform, username);
+      } else {
+        // For demo purposes, we'll simulate a successful connection
+        await new Promise(resolve => setTimeout(() => resolve(undefined), 1000));
+        success = true;
+      }
+      
+      if (success) {
+        // Update connections state locally
+        setConnections(prev => ({
+          ...prev,
+          [platform]: { userName: username, connected: true }
+        }));
+        
+        // Update user account info via API
         try {
-          const stored = await Keychain.getGenericPassword({
-            service: STORAGE_KEYS.connections
+          const token = await AsyncStorage.getItem('auth_token');
+          // Get the stored Onairos username for API calls
+          const storedUsername = await getOnairosUsername();
+          const apiUsername = storedUsername || username;
+          
+          console.log(`🔗 Using username for ${platform} API call:`, {
+            providedUsername: username,
+            storedUsername,
+            finalApiUsername: apiUsername
           });
-          if (stored && stored.password) {
-            const parsed = JSON.parse(stored.password);
-            // Validate the parsed data structure
-            if (parsed && typeof parsed === 'object') {
-              return parsed;
-            }
-          }
-        } catch (keychainError) {
-          console.warn('Keychain access failed, using fallback:', keychainError);
-          // Clear corrupted data
-          try {
-            await Keychain.resetGenericPassword({ service: STORAGE_KEYS.connections });
-          } catch (resetError) {
-            console.warn('Failed to reset keychain:', resetError);
+          
+          if (token) {
+            const response = await fetch('https://api2.onairos.uk/enoch/users/update', {
+              method: 'POST',
+              headers: {
+                'Content-Type': 'application/json',
+                'Authorization': token
+              },
+              body: JSON.stringify({
+                UpdateType: 'connection',
+                updateType: 'Add',
+                connection: platform,
+                username: apiUsername // Use stored Onairos username
+              })
+            });
+            
+            console.log(`Platform connection update response for ${platform}:`, response.status);
           }
+        } catch (apiError) {
+          console.warn(`Error updating user connections for ${platform}, but continuing:`, apiError);
+          // Continue even if the API call fails
         }
+        
+        return true;
       }
       
-      // Use in-memory mock storage if Keychain is not available or failed
-      const mockData = mockConnectionStorage[STORAGE_KEYS.connections] || {};
-      console.log('Using mock connection storage:', mockData);
-      return mockData;
-    } catch (error) {
-      console.error('Error getting connection status:', error);
-      
-      // Always return empty object as safe fallback
-      console.log('Returning empty connections due to error');
-      return {};
-    }
-  }, []);
-
-  const saveConnectionStatus = useCallback(async (status: ConnectionStatus) => {
-    try {
-      if (isKeychainAvailable()) {
-        await Keychain.setGenericPassword(
-          'connections',
-          JSON.stringify(status),
-          { service: STORAGE_KEYS.connections }
-        );
-      } else {
-        // Use in-memory mock storage if Keychain is not available
-        mockConnectionStorage[STORAGE_KEYS.connections] = status;
-      }
+      return false;
     } catch (error) {
-      console.error('Error saving connection status:', error);
-      // Save to mock storage as fallback
-      mockConnectionStorage[STORAGE_KEYS.connections] = status;
+      console.error(`Error connecting platform ${platform}:`, error);
+      return false;
+    } finally {
+      setIsConnecting(false);
     }
   }, []);
 
-  const connectPlatform = useCallback(async (platform: string) => {
-    setIsConnecting(true);
+  /**
+   * Disconnect a platform
+   */
+  const disconnectPlatform = useCallback(async (platform: string, username?: string): Promise<boolean> => {
     try {
-      console.log(`[Mock] Connecting to ${platform}`);
-      
-      // Simulate connection delay
-      await new Promise<void>((resolve) => {
-        setTimeout(() => resolve(), 1000);
+      // Update local state
+      setConnections(prev => {
+        const newConnections = { ...prev };
+        delete newConnections[platform];
+        return newConnections;
       });
       
-      const status = await getConnectionStatus();
-      status[platform] = {
-        userName: `Mock User (${platform})`,
-        connected: true
-      };
-      await saveConnectionStatus(status);
-      
-      console.log(`[Mock] Successfully connected to ${platform}`);
-    } catch (error) {
-      console.error(`Error connecting to ${platform}:`, error);
-      // In development, provide mock data even on error
-      if (__DEV__) {
-        const status = {
-          [platform]: {
-            userName: `Fallback User (${platform})`,
-            connected: true
-          }
-        };
-        await saveConnectionStatus(status);
-      } else {
-        throw error;
-      }
-    } finally {
-      setIsConnecting(false);
-    }
-  }, [getConnectionStatus, saveConnectionStatus]);
-
-  const disconnectPlatform = useCallback(async (platform: string) => {
-    try {
-      const status = await getConnectionStatus();
-      if (status && platform in status) {
-        delete status[platform];
-        await saveConnectionStatus(status);
-      }
-    } catch (error) {
-      console.error(`Error disconnecting ${platform}:`, error);
-      // Don't throw in development mode
-      if (!__DEV__) {
-        throw error;
+      // Update user account info via API
+      try {
+        const token = await AsyncStorage.getItem('auth_token');
+        // Get the stored Onairos username for API calls
+        const storedUsername = await getOnairosUsername();
+        const apiUsername = storedUsername || username || 'user';
+        
+        console.log(`🔗 Using username for ${platform} disconnect API call:`, {
+          providedUsername: username,
+          storedUsername,
+          finalApiUsername: apiUsername
+        });
+        
+        if (token) {
+          const response = await fetch('https://api2.onairos.uk/enoch/users/update', {
+            method: 'POST',
+            headers: {
+              'Content-Type': 'application/json',
+              'Authorization': token
+            },
+            body: JSON.stringify({
+              UpdateType: 'connection',
+              updateType: 'Remove',
+              connection: platform,
+              username: apiUsername // Use stored Onairos username
+            })
+          });
+          
+          console.log(`Platform disconnection update response for ${platform}:`, response.status);
+        }
+      } catch (apiError) {
+        console.warn(`Error updating user connections for ${platform}, but continuing:`, apiError);
+        // Continue even if the API call fails
       }
-    }
-  }, [getConnectionStatus, saveConnectionStatus]);
-
-  const handleOAuthCallback = useCallback(async (platform: string, data: any) => {
-    try {
-      console.log(`[Mock] Handling callback for ${platform}`);
-      const status = await getConnectionStatus();
-      status[platform] = {
-        userName: data.userName || `Mock User (${platform})`,
-        connected: true
-      };
-      await saveConnectionStatus(status);
+      
       return true;
     } catch (error) {
-      console.error('Error handling callback:', error);
+      console.error(`Error disconnecting platform ${platform}:`, error);
       return false;
     }
-  }, [getConnectionStatus, saveConnectionStatus]);
+  }, []);
+
+  /**
+   * Get current connection status
+   */
+  const getConnectionStatus = useCallback(async (): Promise<ConnectionStatus> => {
+    // In a real app, you might fetch this from storage or API
+    return connections;
+  }, [connections]);
 
   return {
-    isConnecting,
+    connections,
     connectPlatform,
     disconnectPlatform,
     getConnectionStatus,
-    handleOAuthCallback,
+    isConnecting
   };
-}; 
+};

package/src/hooks/useUserConnections.ts

@@ -0,0 +1,166 @@
+import { useState, useEffect, useCallback } from 'react';
+import { 
+  getUserConnections, 
+  getUserConnectionsByUsername, 
+  getUserConnectionsByUserId,
+  uploadProfilePicture,
+  Connection 
+} from '../services/userConnectionsService';
+import { getAuthToken } from '../services/authService';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+
+export interface UseUserConnectionsResult {
+  connections: Connection[];
+  isLoading: boolean;
+  error: string | null;
+  refreshConnections: () => Promise<void>;
+  getConnectionsByUsername: (username: string) => Promise<Connection[]>;
+  getConnectionsByUserId: (userId: string) => Promise<Connection[]>;
+  uploadUserProfilePicture: (imageData: string, fileType?: string) => Promise<boolean>;
+}
+
+export const useUserConnections = (): UseUserConnectionsResult => {
+  const [connections, setConnections] = useState<Connection[]>([]);
+  const [isLoading, setIsLoading] = useState<boolean>(true);
+  const [error, setError] = useState<string | null>(null);
+
+  /**
+   * Load connections from API with authentication validation
+   */
+  const loadConnections = useCallback(async () => {
+    try {
+      setIsLoading(true);
+      setError(null);
+      
+      // ✅ CRITICAL: Validate authentication before making API calls
+      const authToken = await getAuthToken();
+      
+      // Check for demo mode (reviewer bypass)
+      const reviewerToken = await AsyncStorage.getItem('onairos_jwt_token');
+      const isDemoMode = reviewerToken === 'reviewer-bypass-token';
+      
+      if (!authToken && !isDemoMode) {
+        console.warn('⚠️ [CONNECTIONS HOOK] No authentication token available for connections refresh');
+        console.warn('⚠️ [CONNECTIONS HOOK] Skipping API call to prevent unauthenticated requests');
+        setConnections([]);
+        setError('Authentication required for connections');
+        return;
+      }
+      
+      if (isDemoMode) {
+        console.log('🎯 [DEMO MODE] Reviewer bypass detected - skipping API call for demo');
+        // For demo mode, return empty connections - ResultsScreen will use fallback data
+        setConnections([]);
+        setError(null);
+        return;
+      }
+      
+      // At this point, authToken must be valid (not null) because we've checked both cases above
+      if (!authToken) {
+        console.error('❌ [CONNECTIONS HOOK] Unexpected null token after validation');
+        setConnections([]);
+        setError('Authentication error');
+        return;
+      }
+      
+      console.log('🔄 Loading user connections with authentication...');
+      console.log('🔑 [CONNECTIONS HOOK] Using auth token:', `${authToken.substring(0, 20)}...`);
+      
+      const fetchedConnections = await getUserConnections();
+      
+      setConnections(fetchedConnections);
+      console.log('✅ Connections loaded:', fetchedConnections.length);
+      
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : 'Failed to load connections';
+      console.error('❌ Error loading connections:', errorMessage);
+      setError(errorMessage);
+      
+      // Set empty array on error - screens will handle their own fallbacks
+      setConnections([]);
+      
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+
+  /**
+   * Refresh connections with authentication validation
+   */
+  const refreshConnections = useCallback(async () => {
+    console.log('🔄 [CONNECTIONS HOOK] Refreshing connections...');
+    await loadConnections();
+    console.log('✅ [CONNECTIONS HOOK] Connections refresh completed');
+  }, [loadConnections]);
+
+  /**
+   * Get connections by username with authentication validation
+   */
+  const getConnectionsByUsername = useCallback(async (username: string): Promise<Connection[]> => {
+    try {
+      // ✅ Validate authentication before making API calls
+      const authToken = await getAuthToken();
+      if (!authToken) {
+        console.warn('⚠️ [CONNECTIONS HOOK] No authentication token available for username connections');
+        return [];
+      }
+      
+      console.log('🔍 Fetching connections by username:', username);
+      console.log('🔑 [CONNECTIONS HOOK] Using auth token:', `${authToken.substring(0, 20)}...`);
+      return await getUserConnectionsByUsername(username);
+    } catch (error) {
+      console.error('❌ Error fetching connections by username:', error);
+      return [];
+    }
+  }, []);
+
+  /**
+   * Get connections by user ID with authentication validation
+   */
+  const getConnectionsByUserId = useCallback(async (userId: string): Promise<Connection[]> => {
+    try {
+      // ✅ Validate authentication before making API calls
+      const authToken = await getAuthToken();
+      if (!authToken) {
+        console.warn('⚠️ [CONNECTIONS HOOK] No authentication token available for user ID connections');
+        return [];
+      }
+      
+      console.log('🔍 Fetching connections by userId:', userId);
+      console.log('🔑 [CONNECTIONS HOOK] Using auth token:', `${authToken.substring(0, 20)}...`);
+      return await getUserConnectionsByUserId(userId);
+    } catch (error) {
+      console.error('❌ Error fetching connections by userId:', error);
+      return [];
+    }
+  }, []);
+
+  /**
+   * Upload profile picture
+   */
+  const uploadUserProfilePicture = useCallback(async (imageData: string, fileType: string = 'jpg'): Promise<boolean> => {
+    try {
+      console.log('📷 Uploading profile picture for user:');
+      const result = await uploadProfilePicture(imageData, fileType);
+      return result.success;
+    } catch (error) {
+      console.error('❌ Error uploading profile picture:', error);
+      return false;
+    }
+  }, []);
+
+  // Load connections on mount
+  useEffect(() => {
+    loadConnections();
+  }, [loadConnections]);
+
+  return {
+    connections,
+    isLoading,
+    error,
+    refreshConnections,
+    getConnectionsByUsername,
+    getConnectionsByUserId,
+    uploadUserProfilePicture
+  };
+}; 

package/src/index.ts

@@ -1,50 +1,95 @@
-/**
- * Onairos React Native SDK
- * A React Native implementation for Onairos personalized data integration
- * 
- * PUBLIC API - Only expose what developers need
- */
-
-// Essential Types Only
-export type {
-  OnairosButtonProps,
-  OnairosProps,
-  DataTier,
-  OnairosConfig,
-  TestModeOptions,
-} from './types';
-
-// Core Components
-export { OnairosButton } from './components/OnairosButton';
-export { Onairos } from './components/Onairos';
-
-// SDK Initialization
-export { 
-  initializeApiKey,
-  ADMIN_API_KEY,
-  extractUsernameFromJWT,
-  extractUserDataFromJWT,
-  decodeJWTPayload,
-} from './services/apiKeyService';
-
-// Authentication & PIN Management
-export {
-  // storePinAfterBiometric, // TODO: Commented out temporarily - biometric functionality disabled
-  getStoredJwtToken,
-  clearStoredTokens,
-  requestEmailVerification,
-  verifyEmailCode,
-  checkEmailVerificationStatus,
-} from './services/platformAuthService';
-
-// Programmatic Function (for custom buttons)
-export { executeOnairosFlow } from './utils/programmaticFlow';
-
-// Default export for convenience
-import { OnairosButton } from './components/OnairosButton';
-import { Onairos } from './components/Onairos';
-
-export default {
-  OnairosButton,
-  Onairos,
+/**
+ * Onairos React Native SDK v4.0.0
+ * A React Native implementation for Onairos personalized data integration
+ * 
+ * PUBLIC API - Complete redesigned UI and enhanced functionality
+ */
+
+// Essential Types
+export type {
+  OnairosButtonProps,
+  OnairosProps,
+  DataTier,
+  OnairosConfig,
+  TestModeOptions,
+  UniversalOnboardingProps,
+  ConnectionStatus,
+  PlatformConfig,
+} from './types';
+
+// Core Components - Redesigned UI
+export { OnairosButton } from './components/OnairosButton';
+export { Onairos } from './components/Onairos';
+export { UniversalOnboarding } from './components/UniversalOnboarding';
+
+// New UI Components - Complete Welcome Flow
+export { default as WelcomeScreen } from './components/WelcomeScreen';
+export { PrimaryButton } from './components/PrimaryButton';
+export { ModalSheet } from './components/ModalSheet';
+export { ModalHeader } from './components/ModalHeader';
+export { BrandMark } from './components/BrandMark';
+export { HeadingGroup } from './components/HeadingGroup';
+export { BodyText } from './components/BodyText';
+export { SignInStep } from './components/SignInStep';
+export { VerificationStep } from './components/VerificationStep';
+export { default as PlatformConnectorsStep } from './components/PlatformConnectorsStep';
+export { PersonalizationConsentScreen } from './components/PersonalizationConsentScreen';
+export { PinCreationScreen } from './components/PinCreationScreen';
+
+// Enhanced Hooks - Temporarily commented out for build
+// export { useConnections } from './hooks/useConnections';
+// export { useUserConnections } from './hooks/useUserConnections';
+// export { useConnectedAccounts } from './hooks/useConnectedAccounts';
+// export { useAuth } from './context/AuthContext';
+
+// Temporarily commented out components with missing dependencies
+export { default as PersonaImage } from './components/PersonaImage';
+// export { default as PlatformToggle } from './components/PlatformToggle';
+// export { default as PersonaLoadingScreen } from './components/PersonaLoadingScreen';
+
+// SDK Initialization & Services
+export { 
+  initializeApiKey,
+  ADMIN_API_KEY,
+  extractUsernameFromJWT,
+  extractUserDataFromJWT,
+  decodeJWTPayload,
+} from './services/apiKeyService';
+
+// Authentication & Enhanced Services - Temporarily limited for build
+export {
+  getOnairosUsername,
+} from './services/authService';
+
+export {
+  initiateOAuth,
+  initiateNativeAuth,
+  hasNativeSDK,
+  isOAuthCallback,
+} from './services/platformAuthService';
+
+export {
+  updateGoogleClientIds,
+} from './services/googleAuthService';
+
+// Enhanced API Client
+export { ApiClient } from './services/apiClient';
+
+// Programmatic Function (for custom buttons) - Temporarily commented out
+// export { executeOnairosFlow } from './utils/programmaticFlow';
+
+// Context Provider - Temporarily commented out for build
+// export { AuthProvider } from './context/AuthContext';
+
+// Default export for convenience
+import { OnairosButton } from './components/OnairosButton';
+import { Onairos } from './components/Onairos';
+import { UniversalOnboarding } from './components/UniversalOnboarding';
+import WelcomeScreen from './components/WelcomeScreen';
+
+export default {
+  OnairosButton,
+  Onairos,
+  UniversalOnboarding,
+  WelcomeScreen,
 };