@onairos/react-native 3.0.24 → 3.0.26

package/src/services/platformAuthService.ts

@@ -17,8 +17,7 @@ const PLATFORM_AUTH_CONFIG: Record<string, PlatformAuthConfig> = {
     color: '#E1306C',
   },
   youtube: {
-    hasNativeSDK: true, // YouTube uses Google Sign-In SDK
-    nativeSDKPackage: '@react-native-google-signin/google-signin',
+    hasNativeSDK: false, // Changed to false to use OAuth flow through proxy
     authEndpoint: 'https://api2.onairos.uk/youtube/authorize',
     color: '#FF0000',
   },
@@ -64,57 +63,79 @@ export const getPlatformColor = (platform: string): string => {
 };
 
 /**
- * Initiates the OAuth flow for a platform
+ * Initiates the OAuth flow for a platform using Onairos proxy
  * @param platform The platform to authenticate with
- * @param username The username to associate with the authentication
- * @returns A Promise that resolves to the OAuth URL to open in a WebView or null if using native SDK
+ * @param userEmail The authenticated user's email (not random username)
+ * @returns A Promise that resolves to the OAuth URL to open in a WebView
  */
-export const initiateOAuth = async (platform: string, username: string): Promise<string | null> => {
+export const initiateOAuth = async (platform: string, userEmail: string): Promise<string | null> => {
   try {
     // Check if the platform is supported
     if (!PLATFORM_AUTH_CONFIG[platform]) {
       throw new Error(`Unsupported platform: ${platform}`);
     }
 
-    // Check if platform has a native SDK
-    if (PLATFORM_AUTH_CONFIG[platform].hasNativeSDK) {
-      // Return null to indicate that we should use the native SDK
-      return null;
-    }
+    console.log(`Initiating OAuth for ${platform} with user: ${userEmail}`);
 
-    // Prepare the request body
-    const jsonData = {
+    // Prepare the request body according to Onairos proxy schema
+    const requestBody = {
       session: {
-        username: username || 'anonymous',
+        username: userEmail || 'anonymous@example.com',
+        platform: platform,
+        timestamp: new Date().toISOString(),
       },
     };
 
-    // Make the request to get the OAuth URL
+    console.log(`Making request to: ${PLATFORM_AUTH_CONFIG[platform].authEndpoint}`);
+    console.log('Request body:', JSON.stringify(requestBody, null, 2));
+
+    // Make the request to get the OAuth URL from Onairos proxy
     const response = await fetch(PLATFORM_AUTH_CONFIG[platform].authEndpoint, {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
+        'Accept': 'application/json',
       },
-      body: JSON.stringify(jsonData),
+      body: JSON.stringify(requestBody),
     });
 
+    console.log(`Response status: ${response.status}`);
+    console.log(`Response headers:`, response.headers);
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      console.error(`HTTP error! status: ${response.status}, body: ${errorText}`);
+      throw new Error(`HTTP error! status: ${response.status} - ${errorText}`);
+    }
+
     // Parse the response
     const data = await response.json();
+    console.log(`OAuth response for ${platform}:`, data);
     
-    // Check if the response contains the OAuth URL
-    if (platform === 'reddit' && data.redditURL) {
-      return data.redditURL;
+    // Check for platform-specific response keys according to schema
+    let oauthUrl: string | null = null;
+    
+    if (platform === 'youtube' && data.youtubeURL) {
+      oauthUrl = data.youtubeURL;
+    } else if (platform === 'reddit' && data.redditURL) {
+      oauthUrl = data.redditURL;
     } else if (platform === 'pinterest' && data.pinterestURL) {
-      return data.pinterestURL;
-    } else if (platform === 'youtube' && data.youtubeURL) {
-      return data.youtubeURL;
+      oauthUrl = data.pinterestURL;
     } else if (platform === 'email' && data.emailURL) {
-      return data.emailURL;
+      oauthUrl = data.emailURL;
+    } else if (platform === 'instagram' && data.instagramURL) {
+      oauthUrl = data.instagramURL;
     } else if (data.url) {
-      return data.url;
+      // Generic fallback
+      oauthUrl = data.url;
+    }
+
+    if (!oauthUrl) {
+      throw new Error(`No OAuth URL found in response for ${platform}. Response: ${JSON.stringify(data)}`);
     }
 
-    throw new Error(`No OAuth URL found in response for ${platform}`);
+    console.log(`Successfully received OAuth URL for ${platform}: ${oauthUrl}`);
+    return oauthUrl;
   } catch (error) {
     console.error(`Error initiating OAuth for ${platform}:`, error);
     throw error;
@@ -128,18 +149,9 @@ export const initiateOAuth = async (platform: string, username: string): Promise
  */
 export const initiateNativeAuth = async (platform: string): Promise<boolean> => {
   try {
-    // Currently only YouTube (Google Sign-In) is supported
-    if (platform === 'youtube') {
-      // This is a placeholder for the actual implementation
-      // In a real implementation, you would import and use the Google Sign-In SDK
-      console.log('Initiating native Google Sign-In for YouTube');
-      
-      // Simulate a successful authentication
-      // In a real implementation, this would be the result of the Google Sign-In flow
-      return true;
-    }
-    
-    throw new Error(`Native authentication not supported for ${platform}`);
+    // Currently no platforms use native SDK - all go through Onairos proxy
+    console.log(`Native authentication not available for ${platform}, use OAuth flow instead`);
+    return false;
   } catch (error) {
     console.error(`Error initiating native auth for ${platform}:`, error);
     throw error;
@@ -153,11 +165,16 @@ export const initiateNativeAuth = async (platform: string): Promise<boolean> =>
  */
 export const handleOAuthCallback = (url: string): string | null => {
   try {
+    console.log('Handling OAuth callback URL:', url);
+    
     // Parse the URL
     const parsedUrl = new URL(url);
     
     // Extract the authorization code
-    return parsedUrl.searchParams.get('code');
+    const code = parsedUrl.searchParams.get('code');
+    console.log('Extracted authorization code:', code);
+    
+    return code;
   } catch (error) {
     console.error('Error handling OAuth callback:', error);
     return null;
@@ -170,6 +187,60 @@ export const handleOAuthCallback = (url: string): string | null => {
  * @returns True if the URL is an OAuth callback
  */
 export const isOAuthCallback = (url: string): boolean => {
-  // Check if the URL starts with our redirect URI
-  return url.startsWith('onairosanime://auth/');
+  // Updated to use correct deep link scheme
+  const isCallback = url.startsWith('onairosevents://auth/callback') || 
+                    url.includes('/callback') || 
+                    url.includes('code=') ||
+                    url.includes('onairos.uk/Home');
+  
+  console.log(`Checking if URL is OAuth callback: ${url} -> ${isCallback}`);
+  return isCallback;
+};
+
+/**
+ * Detects if OAuth flow has completed successfully based on URL patterns
+ * @param url The current URL in the WebView
+ * @param platform The platform being authenticated
+ * @returns True if the OAuth flow has completed successfully
+ */
+export const isOAuthSuccess = (url: string, platform: string): boolean => {
+  console.log(`Checking OAuth success for ${platform} with URL: ${url}`);
+  
+  // Check for final redirect to Onairos home page (indicates proxy has processed the callback)
+  if (url.includes('onairos.uk/Home')) {
+    console.log('Detected final redirect to onairos.uk/Home - OAuth success');
+    return true;
+  }
+  
+  // Platform-specific success patterns
+  switch (platform) {
+    case 'youtube':
+      // YouTube/Google OAuth success patterns
+      return url.includes('accounts.google.com/o/oauth2/approval') ||
+             url.includes('consent.google.com/ml/save') ||
+             url.includes('myaccount.google.com');
+             
+    case 'reddit':
+      // Reddit OAuth success patterns
+      return url.includes('/api/v1/authorize?done=true') ||
+             url.includes('reddit.com/api/v1/authorize/compact');
+             
+    case 'pinterest':
+      // Pinterest OAuth success patterns
+      return url.includes('/oauth/success') ||
+             url.includes('/oauth/complete');
+             
+    case 'instagram':
+      // Instagram OAuth success patterns
+      return url.includes('/oauth/authorize/?response_type=code') ||
+             url.includes('instagram.com/oauth/authorize');
+             
+    case 'email':
+      // Email verification success patterns
+      return url.includes('/email/verify/success') ||
+             url.includes('/email/confirmed');
+             
+    default:
+      return false;
+  }
 };