@onairos/react-native 3.0.22 → 3.0.25

package/src/services/platformAuthService.ts

@@ -0,0 +1,241 @@
+import { Platform, Linking } from 'react-native';
+import { DEEP_LINK_CONFIG } from '../constants';
+
+// Define types for platform auth configuration
+interface PlatformAuthConfig {
+  hasNativeSDK: boolean;
+  nativeSDKPackage?: string;
+  authEndpoint: string;
+  color: string;
+}
+
+// Configuration for each platform's authentication
+const PLATFORM_AUTH_CONFIG: Record<string, PlatformAuthConfig> = {
+  instagram: {
+    hasNativeSDK: false, // Instagram doesn't have a public OAuth SDK for React Native
+    authEndpoint: 'https://api2.onairos.uk/instagram/authorize',
+    color: '#E1306C',
+  },
+  youtube: {
+    hasNativeSDK: false, // Changed to false to use OAuth flow through proxy
+    authEndpoint: 'https://api2.onairos.uk/youtube/authorize',
+    color: '#FF0000',
+  },
+  reddit: {
+    hasNativeSDK: false,
+    authEndpoint: 'https://api2.onairos.uk/reddit/authorize',
+    color: '#FF4500',
+  },
+  pinterest: {
+    hasNativeSDK: false,
+    authEndpoint: 'https://api2.onairos.uk/pinterest/authorize',
+    color: '#E60023',
+  },
+  email: {
+    hasNativeSDK: false,
+    authEndpoint: 'https://api2.onairos.uk/email/authorize',
+    color: '#4285F4',
+  },
+};
+
+/**
+ * Checks if a native SDK is available for the given platform
+ */
+export const hasNativeSDK = (platform: string): boolean => {
+  const config = PLATFORM_AUTH_CONFIG[platform];
+  return config?.hasNativeSDK || false;
+};
+
+/**
+ * Gets the auth endpoint URL for a platform
+ */
+export const getAuthEndpoint = (platform: string): string => {
+  const config = PLATFORM_AUTH_CONFIG[platform];
+  return config?.authEndpoint || '';
+};
+
+/**
+ * Gets the color associated with a platform
+ */
+export const getPlatformColor = (platform: string): string => {
+  const config = PLATFORM_AUTH_CONFIG[platform];
+  return config?.color || '#000000';
+};
+
+/**
+ * Initiates the OAuth flow for a platform using Onairos proxy
+ * @param platform The platform to authenticate with
+ * @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, userEmail: string): Promise<string | null> => {
+  try {
+    // Check if the platform is supported
+    if (!PLATFORM_AUTH_CONFIG[platform]) {
+      throw new Error(`Unsupported platform: ${platform}`);
+    }
+
+    console.log(`Initiating OAuth for ${platform} with user: ${userEmail}`);
+
+    // Prepare the request body according to Onairos proxy schema
+    const requestBody = {
+      session: {
+        username: userEmail || 'anonymous@example.com',
+        platform: platform,
+        timestamp: new Date().toISOString(),
+      },
+    };
+
+    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(requestBody),
+    });
+
+    if (!response.ok) {
+      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+
+    // Parse the response
+    const data = await response.json();
+    console.log(`OAuth response for ${platform}:`, data);
+    
+    // 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) {
+      oauthUrl = data.pinterestURL;
+    } else if (platform === 'email' && data.emailURL) {
+      oauthUrl = data.emailURL;
+    } else if (platform === 'instagram' && data.instagramURL) {
+      oauthUrl = data.instagramURL;
+    } else if (data.url) {
+      // Generic fallback
+      oauthUrl = data.url;
+    }
+
+    if (!oauthUrl) {
+      throw new Error(`No OAuth URL found in response for ${platform}. Response: ${JSON.stringify(data)}`);
+    }
+
+    console.log(`Successfully received OAuth URL for ${platform}: ${oauthUrl}`);
+    return oauthUrl;
+  } catch (error) {
+    console.error(`Error initiating OAuth for ${platform}:`, error);
+    throw error;
+  }
+};
+
+/**
+ * Initiates the native SDK authentication flow for a platform
+ * @param platform The platform to authenticate with
+ * @returns A Promise that resolves to the authentication result
+ */
+export const initiateNativeAuth = async (platform: string): Promise<boolean> => {
+  try {
+    // 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;
+  }
+};
+
+/**
+ * Handles the OAuth callback
+ * @param url The callback URL
+ * @returns The authorization code extracted from the URL
+ */
+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
+    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;
+  }
+};
+
+/**
+ * Checks if a URL is an OAuth callback
+ * @param url The URL to check
+ * @returns True if the URL is an OAuth callback
+ */
+export const isOAuthCallback = (url: string): boolean => {
+  // 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;
+  }
+};