@onairos/react-native 3.1.12 → 3.1.13

package/src/config/api.ts

@@ -0,0 +1,25 @@
+/**
+ * API Configuration for Onairos SDK
+ */
+
+export const API_CONFIG = {
+  BASE_URL: 'https://api.onairos.com',
+  ENDPOINTS: {
+    AUTH: '/auth',
+    USER: '/user',
+    CONNECTIONS: '/connections',
+    TRAINING: '/training',
+    OAUTH: '/oauth',
+  },
+  TIMEOUT: 30000,
+};
+
+export const getApiHeaders = () => ({
+  'Content-Type': 'application/json',
+  'Accept': 'application/json',
+});
+
+export const getAuthHeaders = (token?: string) => ({
+  ...getApiHeaders(),
+  ...(token && { 'Authorization': `Bearer ${token}` }),
+});

package/src/context/AuthContext.tsx

@@ -0,0 +1,393 @@
+import React, { createContext, useState, useEffect, useContext } from 'react';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import { User } from '../types/index';
+import { 
+  saveAuthToken, 
+  getAuthToken, 
+  removeAuthToken, 
+  verifyToken, 
+  getUserProfile, 
+  authenticateWithApple,
+  authenticateWithOnairos,
+  authenticateWithOnairosSignIn,
+  updateUserOnboardedStatus
+} from '../services/authService';
+import {
+  saveUserProgress,
+  saveAuthState,
+  getAuthState,
+  clearUserData,
+  getResumeTarget,
+  markStepCompleted,
+  updateLastScreen,
+  isReturningUser,
+  markEventPageReached,
+  hasEventAccessToken,
+  STORAGE_KEYS
+} from '../services/storageService';
+
+interface AuthContextType {
+  user: User | null;
+  isLoading: boolean;
+  hasCompletedOnboarding: boolean;
+  login: (userData: User) => void;
+  logout: () => void;
+  deleteAccount: () => Promise<void>;
+  completeOnboarding: (userData: Partial<User>) => void;
+  updateUser: (userData: Partial<User>) => void;
+  appleSignIn: (appleAuthData: any) => Promise<User>;
+  onairosSignIn: (onairosAuthData: { token: string; email: string }) => Promise<User>;
+  isAuthenticated: boolean;
+  updateOnboardedStatus: () => Promise<void>;
+  // New methods for progress tracking
+  getResumeTarget: () => Promise<{ screen: string; params?: any }>;
+  markStepCompleted: (step: string) => Promise<void>;
+  updateLastScreen: (screen: string, params?: any) => Promise<void>;
+  isReturningUser: () => Promise<boolean>;
+  // New methods for event access token
+  markEventPageReached: (eventData?: any) => Promise<void>;
+  hasEventAccessToken: () => Promise<boolean>;
+}
+
+const AuthContext = createContext<AuthContextType | undefined>(undefined);
+
+export const AuthProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => {
+  const [user, setUser] = useState<User | null>(null);
+  const [isLoading, setIsLoading] = useState(true);
+  const [hasCompletedOnboarding, setHasCompletedOnboarding] = useState(false);
+  const [isAuthenticated, setIsAuthenticated] = useState(false);
+
+  useEffect(() => {
+    // Check if user is already logged in
+    const loadStoredUser = async () => {
+      try {
+        // PRIORITY 1: Check if user has completed onboarding (for release mode reliability)
+        const hasEventToken = await hasEventAccessToken();
+        const storedUser = await AsyncStorage.getItem('user');
+        
+        if (hasEventToken && storedUser) {
+          console.log('🎯 Found event access token - user has completed onboarding, authentication confirmed');
+          setUser(JSON.parse(storedUser));
+          setIsAuthenticated(true);
+          setHasCompletedOnboarding(true);
+          setIsLoading(false);
+          return; // Skip network verification for completed users
+        }
+        
+        // PRIORITY 2: Check if we have a JWT token for users still in onboarding
+        const token = await getAuthToken();
+        
+        if (token) {
+          // For users with tokens but no completion token, try network verification
+          // but don't fail if network is unreachable (important for release mode)
+          let isValid = false;
+          try {
+            isValid = await verifyToken();
+          } catch (networkError) {
+            console.warn('🌐 Network verification failed, using local token validation:', networkError);
+            // In release mode, network might be slow/unreliable
+            // If we have a token and stored user, trust the local state
+            if (storedUser) {
+              console.log('💾 Network unreachable, trusting local authentication state');
+              isValid = true; // Trust local state when network fails
+            }
+          }
+          
+          if (isValid) {
+            // Token is valid (or we're trusting local state), get user data
+            if (storedUser) {
+              setUser(JSON.parse(storedUser));
+              setIsAuthenticated(true);
+            } else {
+              // If user data is not in AsyncStorage, try to fetch it
+              try {
+                const userData = await getUserProfile();
+                await AsyncStorage.setItem('user', JSON.stringify(userData));
+                setUser(userData);
+                setIsAuthenticated(true);
+                              } catch (profileError) {
+                  console.error('Failed to fetch user profile:', profileError);
+                  // Only remove token if we're sure it's invalid (not just network issues)
+                  const errorMessage = profileError instanceof Error ? profileError.message : String(profileError);
+                  if (errorMessage.includes('401') || errorMessage.includes('403')) {
+                    await removeAuthToken();
+                  } else {
+                    console.log('🌐 Profile fetch failed (likely network), keeping authentication state');
+                    // Create fallback user for offline scenarios
+                    if (token) {
+                      const fallbackUser = {
+                        id: 'offline_user',
+                        name: 'Onairos User',
+                        email: 'user@onairos.com',
+                        onboarded: false
+                      };
+                      await AsyncStorage.setItem('user', JSON.stringify(fallbackUser));
+                      setUser(fallbackUser);
+                      setIsAuthenticated(true);
+                    }
+                  }
+                }
+            }
+          } else {
+            // Token verification definitely failed - remove it
+            await removeAuthToken();
+          }
+        }
+        
+        const onboardingCompleted = await AsyncStorage.getItem('onboardingCompleted');
+        if (onboardingCompleted === 'true') {
+          setHasCompletedOnboarding(true);
+        }
+      } catch (error) {
+        console.error('Failed to load authentication state:', error);
+      } finally {
+        setIsLoading(false);
+      }
+    };
+
+    loadStoredUser();
+  }, []);
+
+  const login = async (userData: User) => {
+    try {
+      // Ensure onboarded is set to false for new users
+      const userWithOnboarded = {
+        ...userData,
+        onboarded: false // Always force camera flow for new logins
+      };
+      
+      await AsyncStorage.setItem('user', JSON.stringify(userWithOnboarded));
+      setUser(userWithOnboarded);
+      setIsAuthenticated(true);
+      
+      // Save auth state and mark authentication step as completed
+      await saveAuthState({
+        isAuthenticated: true,
+        authMethod: userData.email?.includes('apple') ? 'apple' : 'onairos',
+        hasValidToken: true,
+        userEmail: userData.email,
+        userName: userData.name
+      });
+      
+      await markStepCompleted('authentication');
+      
+      console.log('User logged in with onboarded=false:', userWithOnboarded);
+    } catch (error) {
+      console.error('Failed to save user data:', error);
+    }
+  };
+  
+  // Handle Apple Sign-In
+  const appleSignIn = async (appleAuthData: any): Promise<User> => {
+    try {
+      setIsLoading(true);
+      
+      // Call the API to authenticate with Apple
+      const authResponse = await authenticateWithApple(appleAuthData);
+      
+      // Save the JWT token
+      await saveAuthToken(authResponse.token);
+      
+      // CRITICAL: Save auth method as 'apple' for proper button logic
+      await AsyncStorage.setItem('auth_method', 'apple');
+      
+      // Save Onairos connection status from backend response
+      if (authResponse.onairos) {
+        await AsyncStorage.setItem('hasConnectedOnairos', authResponse.onairos.hasConnectedOnairos.toString());
+        if (authResponse.onairos.onairosUserId) {
+          await AsyncStorage.setItem('onairosUserId', authResponse.onairos.onairosUserId);
+        }
+        if (authResponse.onairos.lastConnectedAt) {
+          await AsyncStorage.setItem('lastConnectedAt', authResponse.onairos.lastConnectedAt);
+        }
+        console.log('🔗 Stored Onairos connection status:', authResponse.onairos.hasConnectedOnairos);
+      } else {
+        // Default to false if no Onairos info provided
+        await AsyncStorage.setItem('hasConnectedOnairos', 'false');
+        console.log('🔗 No Onairos connection info from backend, defaulting to false');
+      }
+      
+      // Create user object from response
+      const userData: User = {
+        id: authResponse.user.id,
+        name: authResponse.user.name || 'Onairos User',
+        email: authResponse.user.email,
+        profilePicture: authResponse.user.profilePicture,
+        onboarded: false // Default to false for new Apple sign-ins
+      };
+      
+      // Save user data to AsyncStorage and update state
+      await AsyncStorage.setItem('user', JSON.stringify(userData));
+      setUser(userData);
+      setIsAuthenticated(true);
+      
+      console.log('🍎 Apple sign-in completed - auth_method set to "apple"');
+      
+      return userData;
+    } catch (error) {
+      console.error('Apple sign-in failed:', error);
+      throw error;
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  // Handle Onairos Sign-In (similar to Apple)
+  const onairosSignIn = async (onairosAuthData: { token: string; email: string }): Promise<User> => {
+    try {
+      setIsLoading(true);
+      
+      // Call the API to authenticate with Onairos
+      const authResponse = await authenticateWithOnairos(onairosAuthData);
+      
+      // Save the JWT token
+      await saveAuthToken(authResponse.token);
+      
+      // CRITICAL: Save auth method as 'onairos' for proper button logic
+      await AsyncStorage.setItem('auth_method', 'onairos');
+      
+      // Create user object from response
+      const userData: User = {
+        id: authResponse.user.id,
+        name: authResponse.user.name || 'Onairos User',
+        email: authResponse.user.email,
+        profilePicture: authResponse.user.profilePicture,
+        onboarded: false // Default to false for new Onairos sign-ins
+      };
+      
+      // Save user data to AsyncStorage and update state
+      await AsyncStorage.setItem('user', JSON.stringify(userData));
+      setUser(userData);
+      setIsAuthenticated(true);
+      
+      console.log('🔑 Onairos sign-in completed - auth_method set to "onairos"');
+      
+      return userData;
+    } catch (error) {
+      console.error('Onairos sign-in failed:', error);
+      throw error;
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  const logout = async () => {
+    try {
+      // Clear all user data using the new storage service
+      await clearUserData();
+      setUser(null);
+      setIsAuthenticated(false);
+    } catch (error) {
+      console.error('Failed to remove user data:', error);
+    }
+  };
+
+  const completeOnboarding = async (userData: Partial<User>) => {
+    try {
+      // Update user data
+      const updatedUser = { ...user, ...userData };
+      await AsyncStorage.setItem('user', JSON.stringify(updatedUser));
+      setUser(updatedUser as User);
+      
+      // Update onboarded status on backend
+      await updateOnboardedStatus();
+    } catch (error) {
+      console.error('Failed to complete onboarding:', error);
+      throw error;
+    }
+  };
+
+  const updateUser = async (userData: Partial<User>) => {
+    try {
+      if (!user) return;
+      const updatedUser = { ...user, ...userData };
+      await AsyncStorage.setItem('user', JSON.stringify(updatedUser));
+      setUser(updatedUser);
+    } catch (error) {
+      console.error('Failed to update user data:', error);
+    }
+  };
+
+  // Update user onboarded status
+  const updateOnboardedStatus = async (): Promise<void> => {
+    try {
+      setIsLoading(true);
+      
+      // Call the API to update onboarded status
+      await updateUserOnboardedStatus();
+      
+      // Update local user data
+      if (user) {
+        const updatedUser = { ...user, onboarded: true };
+        await AsyncStorage.setItem('user', JSON.stringify(updatedUser));
+        setUser(updatedUser);
+      }
+    } catch (error) {
+      console.error('Failed to update onboarded status:', error);
+      throw error;
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  const deleteAccount = async () => {
+    try {
+      // In a real app, you would make an API call to delete the user account on the server
+      // For example: await api.deleteUser(user.id);
+      
+      // Remove user data from AsyncStorage
+      await AsyncStorage.removeItem('user');
+      
+      // Remove JWT token
+      await removeAuthToken();
+      
+      // Clear any other user-related data from AsyncStorage
+      await AsyncStorage.removeItem('onboardingCompleted');
+      
+      // Update state
+      setUser(null);
+      setIsAuthenticated(false);
+      setHasCompletedOnboarding(false);
+      
+      console.log('Account deleted successfully');
+    } catch (error) {
+      console.error('Failed to delete account:', error);
+      throw error;
+    }
+  };
+
+  return (
+    <AuthContext.Provider value={{ 
+      user, 
+      isLoading, 
+      hasCompletedOnboarding, 
+      login, 
+      logout,
+      deleteAccount,
+      completeOnboarding,
+      updateUser,
+      appleSignIn,
+      onairosSignIn,
+      isAuthenticated,
+      updateOnboardedStatus,
+      // Progress tracking methods
+      getResumeTarget,
+      markStepCompleted,
+      updateLastScreen,
+      isReturningUser,
+      // Event access token methods
+      markEventPageReached,
+      hasEventAccessToken
+    }}>
+      {children}
+    </AuthContext.Provider>
+  );
+};
+
+export const useAuth = (): AuthContextType => {
+  const context = useContext(AuthContext);
+  if (context === undefined) {
+    throw new Error('useAuth must be used within an AuthProvider');
+  }
+  return context;
+};

package/src/hooks/useConnectedAccounts.ts

@@ -0,0 +1,139 @@
+import { useState, useEffect, useCallback } from 'react';
+import { 
+  ConnectedAccount, 
+  getConnectedAccountsSmart,
+  // Keep legacy imports for any edge cases
+  getConnectedAccountsByUsername, 
+  getConnectedAccountsByEmail, 
+  getConnectedAccountsByUserId 
+} from '../services/connectedAccountsService';
+import { useAuth } from '../context/AuthContext';
+
+export interface UseConnectedAccountsReturn {
+  connectedAccounts: ConnectedAccount[];
+  isLoading: boolean;
+  error: string | null;
+  refreshAccounts: () => Promise<void>;
+  addAccount: (platform: string, username: string) => void;
+  removeAccount: (platform: string) => void;
+}
+
+export const useConnectedAccounts = (): UseConnectedAccountsReturn => {
+  const { user } = useAuth();
+  const [connectedAccounts, setConnectedAccounts] = useState<ConnectedAccount[]>([]);
+  const [isLoading, setIsLoading] = useState<boolean>(true);
+  const [error, setError] = useState<string | null>(null);
+
+  const fetchConnectedAccounts = useCallback(async () => {
+    if (!user) {
+      console.log('🔍 No user available for fetching connected accounts');
+      setIsLoading(false);
+      return;
+    }
+
+    try {
+      setIsLoading(true);
+      setError(null);
+      
+      console.log('🚀 [HOOK] Starting connected accounts fetch with new smart API...');
+      console.log('🚀 [HOOK] User info available:', {
+        email: user.email,
+        id: user.id,
+        name: user.name
+      });
+      
+      // Use the new smart API function - makes only ONE request with intelligent fallbacks
+      const accounts = await getConnectedAccountsSmart(
+        user.email,    // Primary identifier (email)
+        user.id,       // Secondary identifier (user ID)
+        user.name      // Tertiary identifier (username)
+      );
+      
+      console.log(`✅ [HOOK] Connected accounts loaded via smart API: ${accounts.length} accounts`);
+      setConnectedAccounts(accounts);
+      
+    } catch (err) {
+      console.error('❌ [HOOK] Error fetching connected accounts:', err);
+      setError('Failed to load connected accounts');
+    } finally {
+      setIsLoading(false);
+    }
+  }, [user]);
+
+  const refreshAccounts = useCallback(async () => {
+    console.log('🔄 [HOOK] Refreshing connected accounts...');
+    await fetchConnectedAccounts();
+  }, [fetchConnectedAccounts]);
+
+  const addAccount = useCallback((platform: string, username: string) => {
+    // Create a temporary URL for the account
+    const tempUrl = `https://${platform.toLowerCase()}.com/${username}`;
+    
+    const newAccount: ConnectedAccount = {
+      platform,
+      username,
+      url: tempUrl,
+    };
+    
+    setConnectedAccounts(prev => {
+      // Check if account already exists
+      const exists = prev.some(acc => 
+        acc.platform.toLowerCase() === platform.toLowerCase()
+      );
+      
+      if (exists) {
+        // Update existing account
+        return prev.map(acc => 
+          acc.platform.toLowerCase() === platform.toLowerCase() 
+            ? newAccount 
+            : acc
+        );
+      } else {
+        // Add new account
+        return [...prev, newAccount];
+      }
+    });
+    
+    console.log('✅ [HOOK] Account added locally:', newAccount);
+    
+    // TODO: In a real implementation, you would also send this to your backend
+    // Example:
+    // try {
+    //   await saveConnectedAccount(user.id, platform, username);
+    // } catch (error) {
+    //   console.error('Failed to save account to backend:', error);
+    //   // Optionally revert the local change
+    // }
+  }, []);
+
+  const removeAccount = useCallback((platform: string) => {
+    setConnectedAccounts(prev => 
+      prev.filter(acc => acc.platform.toLowerCase() !== platform.toLowerCase())
+    );
+    
+    console.log('✅ [HOOK] Account removed locally:', platform);
+    
+    // TODO: In a real implementation, you would also remove this from your backend
+    // Example:
+    // try {
+    //   await removeConnectedAccount(user.id, platform);
+    // } catch (error) {
+    //   console.error('Failed to remove account from backend:', error);
+    //   // Optionally revert the local change
+    // }
+  }, []);
+
+  // Fetch accounts when component mounts or user changes
+  useEffect(() => {
+    fetchConnectedAccounts();
+  }, [fetchConnectedAccounts]);
+
+  return {
+    connectedAccounts,
+    isLoading,
+    error,
+    refreshAccounts,
+    addAccount,
+    removeAccount,
+  };
+};