@propel-nsl/propel-react-native-sdk 1.0.0

package/src/SDKApp.tsx

@@ -0,0 +1,540 @@
+/**
+ * SDK App Component
+ * 
+ * Main React Native component that wraps the SDK functionality.
+ * This is the root component registered with AppRegistry.
+ */
+
+import React, { useEffect, useState } from 'react';
+import { CommonActions, NavigationContainer, useNavigationContainerRef } from '@react-navigation/native';
+import { Provider } from 'react-redux';
+import { SafeAreaProvider } from 'react-native-safe-area-context';
+import { GestureHandlerRootView } from 'react-native-gesture-handler';
+import { Linking, Platform } from 'react-native';
+import Toast from 'react-native-toast-message';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+
+import { store } from './redux/store';
+import SDKNavigator from './navigation/SDKNavigator';
+import { sdkBridge } from './bridge';
+import { SDKParams } from './types';
+import { toastConfig } from 'src-app/components/ToastConfig';
+import ENV, { setApiUrl } from 'src-app/config/env';
+import { SDKProvider } from './contexts/SDKContext';
+import { clearAllAuthState, sdkAuthRequest, sdkAuthSuccess, sdkAuthFailure } from 'src-app/redux/authSlice';
+import { sdkAuthApi } from 'src-app/services';
+import { setSDKCredentials, clearSDKCredentials } from 'src-app/services/sdkCredentials';
+
+// Helper to detect if deep link is for RedemptionHistory
+const isDeepLinkToRedemptionHistory = (params: any): boolean => {
+  if (!params) return false;
+  
+  const checkValue = (val: any): boolean => {
+    if (!val || typeof val !== 'string') return false;
+    const normalized = val.trim().toLowerCase();
+    return (
+      normalized === 'transaction-history' ||
+      normalized === 'transaction_history' ||
+      normalized === 'transactionhistory' ||
+      normalized === 'redemption-history' ||
+      normalized === 'redemption_history' ||
+      normalized === 'redemptionhistory' ||
+      normalized === 'redeem-history' ||
+      normalized === 'redeemhistory'
+    );
+  };
+  
+  return (
+    checkValue(params.screen) ||
+    checkValue(params.route) ||
+    checkValue(params.initialRoute) ||
+    checkValue(params.path) ||
+    checkValue(params.url) ||
+    checkValue(params.customParams?.screen) ||
+    checkValue(params.customParams?.route)
+  );
+};
+
+// Helper to detect if deep link is for Redeem screen
+const isDeepLinkToRedeem = (params: any): boolean => {
+  if (!params) return false;
+  
+  const checkValue = (val: any): boolean => {
+    if (!val || typeof val !== 'string') return false;
+    const normalized = val.trim().toLowerCase();
+    return (
+      normalized === 'redeem' ||
+      normalized === 'redeem-screen' ||
+      normalized === 'redeem_screen' ||
+      normalized === 'redeemscreen'
+    );
+  };
+  
+  return (
+    checkValue(params.screen) ||
+    checkValue(params.route) ||
+    checkValue(params.initialRoute) ||
+    checkValue(params.path) ||
+    checkValue(params.url) ||
+    checkValue(params.customParams?.screen) ||
+    checkValue(params.customParams?.route)
+  );
+};
+
+const SDKApp: React.FC<any> = (props) => {
+  const [initialParams, setInitialParams] = useState<SDKParams | null>(null);
+  const [isReady, setIsReady] = useState(false);
+  const initialPropsRef = React.useRef<any>(props);
+  const navigationRef = useNavigationContainerRef();
+  const pendingNavigationRef = React.useRef<(() => void) | null>(null);
+  
+  // Unique key to force NavigationContainer remount and reset navigation state
+  // This ensures fresh navigation state each time SDK is opened
+  const [navigationKey] = useState(() => `sdk-nav-${Date.now()}`);
+  
+  // Determine initial route based on deep link in initialParams (from bridge)
+  // IMPORTANT: Use initialParams (loaded from bridge) NOT props (which may be stale)
+  const deepLinkToRedemptionHistory = React.useMemo(
+    () => initialParams ? isDeepLinkToRedemptionHistory(initialParams) : false,
+    [initialParams] // Re-evaluate when initialParams changes
+  );
+  
+  const deepLinkToRedeem = React.useMemo(
+    () => initialParams ? isDeepLinkToRedeem(initialParams) : false,
+    [initialParams] // Re-evaluate when initialParams changes
+  );
+  
+
+  // State to track if authentication is complete for deep link navigation
+  const [isAuthenticated, setIsAuthenticated] = useState(false);
+  const pendingDeepLinkRef = React.useRef<{ target: string; from?: string } | null>(null);
+  // Track if deep link has already been handled to prevent duplicate calls
+  const deepLinkHandledRef = React.useRef(false);
+
+  // Authenticate SDK and store token - returns true if successful
+  const authenticateSDK = React.useCallback(async (): Promise<boolean> => {
+    console.log('🔐 authenticateSDK: Starting SDK authentication...');
+    try {
+      store.dispatch(sdkAuthRequest({}));
+      const response = await sdkAuthApi();
+      console.log('🔐 authenticateSDK: Response received:', response.data);
+
+      if (response.data?.status === true && response.data?.session?.token) {
+        const token = response.data.session.token;
+        await AsyncStorage.setItem('accessToken', token);
+        console.log('🔐 authenticateSDK: Token stored successfully');
+        store.dispatch(sdkAuthSuccess(response.data));
+        setIsAuthenticated(true);
+        return true;
+      } else {
+        const errorMsg = response.data?.message || 'SDK authentication failed';
+        console.log('🔐 authenticateSDK: Auth failed -', errorMsg);
+        store.dispatch(sdkAuthFailure(errorMsg));
+        return false;
+      }
+    } catch (error: any) {
+      console.log('🔐 authenticateSDK: Error -', error?.response?.data || error?.message);
+      store.dispatch(
+        sdkAuthFailure(
+          error?.response?.data?.message || error?.message || 'SDK authentication failed'
+        )
+      );
+      return false;
+    }
+  }, []);
+
+  const navigateToTransactionHistory = React.useCallback(
+    (from?: string) => {
+      console.log('🚀 navigateToTransactionHistory called, from=', from);
+      
+      const doNavigate = () => {
+        console.log('🚀 doNavigate executing - navigating to RedemptionHistory');
+        // Navigate to RedemptionHistory hidden tab
+        navigationRef.dispatch(
+          CommonActions.navigate({
+            name: 'MainTabs',
+            params: {
+              screen: 'RedemptionHistory',
+              params: {
+                from: from || 'DeepLink',
+                exitToHost: from === 'HostApp' ? true : undefined,
+              },
+            },
+          })
+        );
+        console.log('🚀 Navigation to RedemptionHistory completed');
+      };
+
+      const isNavReady = navigationRef.isReady();
+      console.log('🚀 navigationRef.isReady()=', isNavReady);
+
+      if (!isNavReady) {
+        console.log('🚀 Navigation not ready, storing in pendingNavigationRef');
+        pendingNavigationRef.current = doNavigate;
+        return;
+      }
+
+      doNavigate();
+    },
+    [navigationRef]
+  );
+
+  const navigateToRedemptionHistory = React.useCallback(
+    (from?: string) => {
+      const doNavigate = () => {
+        // Navigate to RedemptionHistory hidden tab
+        navigationRef.dispatch(
+          CommonActions.navigate({
+            name: 'MainTabs',
+            params: {
+              screen: 'RedemptionHistory',
+              params: { from: from || 'DeepLink' },
+            },
+          })
+        );
+      };
+
+      if (!navigationRef.isReady()) {
+        pendingNavigationRef.current = doNavigate;
+        return;
+      }
+
+      doNavigate();
+    },
+    [navigationRef]
+  );
+
+  const navigateToRedeem = React.useCallback(
+    (from?: string) => {
+      console.log('🚀 navigateToRedeem called, from=', from);
+      
+      const doNavigate = () => {
+        console.log('🚀 doNavigate executing - navigating to Redeem tab');
+        // Navigate to Redeem tab
+        navigationRef.dispatch(
+          CommonActions.navigate({
+            name: 'MainTabs',
+            params: { screen: 'Redeem' },
+          })
+        );
+        console.log('🚀 Navigation to Redeem completed');
+      };
+
+      const isNavReady = navigationRef.isReady();
+      console.log('🚀 navigationRef.isReady()=', isNavReady);
+
+      if (!isNavReady) {
+        console.log('🚀 Navigation not ready, storing in pendingNavigationRef');
+        pendingNavigationRef.current = doNavigate;
+        return;
+      }
+
+      doNavigate();
+    },
+    [navigationRef]
+  );
+
+  // Authenticate first, then navigate to deep link target
+  const authenticateAndNavigate = React.useCallback(
+    async (target: string, from?: string) => {
+      console.log('🔐 authenticateAndNavigate: target=', target, 'from=', from);
+      
+      const authSuccess = await authenticateSDK();
+      
+      if (!authSuccess) {
+        console.log('🔐 authenticateAndNavigate: Auth failed, cannot navigate');
+        return;
+      }
+
+      console.log('🔐 authenticateAndNavigate: Auth successful, proceeding to navigate');
+      
+      // Navigate based on target
+      if (target === 'RedemptionHistory') {
+        navigateToTransactionHistory(from);
+      } else if (target === 'Redeem') {
+        navigateToRedeem(from);
+      }
+    },
+    [authenticateSDK, navigateToTransactionHistory, navigateToRedeem]
+  );
+
+  const maybeHandleRedeemHistoryIntent = React.useCallback(
+    (intent?: any) => {
+      if (!intent) return;
+
+      const raw =
+        typeof intent === 'string'
+          ? intent
+          : intent?.url || intent?.path || intent?.route || intent?.screen || intent?.initialRoute;
+
+
+      if (!raw || typeof raw !== 'string') return;
+
+      const normalized = raw.trim().toLowerCase();
+      // Accept both full URLs (propelsdk://redeem-history) and plain route tokens.
+      const path = normalized
+        .replace(/^[a-z][a-z0-9+.-]*:\/\//, '')
+        .split('?')[0]
+        .split('#')[0];
+
+      const lastSegment = path.split('/').filter(Boolean).pop() || '';
+
+      const isRedemptionHistory =
+        normalized === 'redeem history' ||
+        normalized === 'redemption history' ||
+        normalized === 'redemptionhistory' ||
+        normalized === 'redemption_history' ||
+        lastSegment === 'redemptionhistory' ||
+        lastSegment === 'redemption_history' ||
+        lastSegment === 'redemption-history' ||
+        lastSegment === 'redeem-history' ||
+        lastSegment === 'redeemhistory';
+
+      const isTransactionHistory =
+        normalized === 'transaction history' ||
+        normalized === 'transactionhistory' ||
+        normalized === 'transaction_history' ||
+        normalized === 'transaction-history' ||
+        lastSegment === 'transactionhistory' ||
+        lastSegment === 'transaction_history' ||
+        lastSegment === 'transaction-history';
+
+      const isRedeem =
+        normalized === 'redeem' ||
+        normalized === 'redeem-screen' ||
+        normalized === 'redeem_screen' ||
+        normalized === 'redeemscreen' ||
+        lastSegment === 'redeem' ||
+        lastSegment === 'redeem-screen' ||
+        lastSegment === 'redeem_screen' ||
+        lastSegment === 'redeemscreen';
+
+      if (isRedemptionHistory || isTransactionHistory) {
+        // Prevent duplicate handling
+        if (deepLinkHandledRef.current) {
+          console.log('🚀 Deep link already handled, skipping duplicate call');
+          return;
+        }
+        deepLinkHandledRef.current = true;
+        console.log('🚀 Intent matched! Will authenticate then navigate to TransactionHistory...');
+        // Store pending deep link and authenticate first
+        pendingDeepLinkRef.current = { target: 'RedemptionHistory', from: 'HostApp' };
+        authenticateAndNavigate('RedemptionHistory', 'HostApp');
+      } else if (isRedeem) {
+        // Prevent duplicate handling
+        if (deepLinkHandledRef.current) {
+          console.log('🚀 Deep link already handled, skipping duplicate call');
+          return;
+        }
+        deepLinkHandledRef.current = true;
+        console.log('🚀 Intent matched! Will authenticate then navigate to Redeem...');
+        pendingDeepLinkRef.current = { target: 'Redeem', from: 'HostApp' };
+        authenticateAndNavigate('Redeem', 'HostApp');
+      }
+    },
+    [authenticateAndNavigate]
+  );
+
+  useEffect(() => {
+    // Clear auth state on SDK mount to ensure fresh authentication each time
+    // This prevents stale data from previous SDK sessions
+    const clearPreviousSession = async () => {
+      store.dispatch(clearAllAuthState());
+      clearSDKCredentials();
+      // Also clear the stored access token to force re-authentication
+      await AsyncStorage.removeItem('accessToken');
+    };
+    clearPreviousSession();
+    
+    // Reset deep link handled flag and pending deep link on each SDK mount
+    // This ensures fresh deep link handling for each SDK session
+    deepLinkHandledRef.current = false;
+    pendingDeepLinkRef.current = null;
+  }, []);
+
+  useEffect(() => {
+    // Get initial parameters from native host app OR from RN host props
+    const loadParams = async () => {
+      try {
+        const baseParams = initialPropsRef.current || {};
+        const isRNHostMode = !!baseParams.__rnHostMode;
+
+        // In RN host mode, skip native bridge entirely — use props as the source
+        const bridgeParams = isRNHostMode ? {} : (await sdkBridge.getInitialParams()) || {};
+        
+        // IMPORTANT: Bridge params (from native) take precedence for deep link params
+        // Only use initialPropsRef for base config like apiUrl, userToken
+        // This prevents stale customParams from previous sessions
+        const mergedParams = {
+          ...baseParams,
+          ...bridgeParams,
+          // Explicitly handle deep link related params - bridge takes full precedence
+          // In RN host mode, baseParams IS the source of truth
+          screen: isRNHostMode ? (baseParams.screen || baseParams.customParams?.screen) : bridgeParams.screen,
+          route: isRNHostMode ? baseParams.route : bridgeParams.route,
+          initialRoute: isRNHostMode ? baseParams.initialRoute : bridgeParams.initialRoute,
+          customParams: isRNHostMode ? baseParams.customParams : bridgeParams.customParams,
+        } as SDKParams;
+
+        console.log('🔍 SDKApp loadParams: bridgeParams.customParams=', bridgeParams.customParams);
+        console.log('🔍 SDKApp loadParams: mergedParams.customParams=', mergedParams.customParams);
+
+        if (mergedParams?.userToken && mergedParams.userToken !== 'null') {
+          await AsyncStorage.setItem('accessToken', mergedParams.userToken);
+        }
+
+        // Override API URL if provided by host app
+        if (mergedParams?.apiUrl) {
+          setApiUrl(mergedParams.apiUrl);
+        }
+
+        // Set SDK credentials for authentication
+        if (mergedParams?.authToken && mergedParams?.authId) {
+          setSDKCredentials({
+            authToken: mergedParams.authToken,
+            authId: mergedParams.authId,
+            userId: mergedParams.userId,
+            userName: mergedParams.userName,
+            userMobile: mergedParams.userMobile,
+            userEmail: mergedParams.userEmail,
+            deviceId: mergedParams.deviceId,
+            clientName: mergedParams.clientName,
+            clientVersion: mergedParams.clientVersion,
+            environment: mergedParams.environment,
+          });
+        }
+
+        setInitialParams(mergedParams);
+        setIsReady(true);
+      } catch (error) {
+        console.error('Failed to load SDK params:', error);
+        // Use default params if bridge fails
+        const mergedParams = {
+          apiUrl: ENV.apiUrl,
+          environment: 'production',
+          // Don't include deep link params from cached initialPropsRef on error
+        } as SDKParams;
+
+        if (mergedParams?.apiUrl) {
+          setApiUrl(mergedParams.apiUrl);
+        }
+
+        setInitialParams(mergedParams);
+        setIsReady(true);
+      }
+    };
+
+    loadParams();
+  }, []);
+
+  useEffect(() => {
+    // Handle deep link intents passed via initial params/props
+    if (!initialParams) return;
+    
+    // Log for debugging
+    console.log('🔍 SDKApp: Checking for deep link intent in initialParams:', {
+      screen: initialParams?.screen,
+      route: initialParams?.route,
+      initialRoute: initialParams?.initialRoute,
+      customParams: initialParams?.customParams,
+    });
+    
+    // Only process deep links if current initialParams actually has deep link data
+    // These values come from the bridge (native) and are NOT cached from previous sessions
+    const hasDeepLinkInCurrentParams = 
+      initialParams?.screen || 
+      initialParams?.route || 
+      initialParams?.initialRoute ||
+      (initialParams?.customParams && Object.keys(initialParams.customParams).length > 0);
+    
+    if (!hasDeepLinkInCurrentParams) {
+      console.log('🔍 SDKApp: No deep link params in current session, skipping deep link handling');
+      return;
+    }
+    
+    // Only use initialParams (which has bridge values) - don't use initialPropsRef which may be stale
+    maybeHandleRedeemHistoryIntent(initialParams);
+    maybeHandleRedeemHistoryIntent(initialParams?.customParams);
+  }, [initialParams, maybeHandleRedeemHistoryIntent]);
+
+  useEffect(() => {
+    const handleUrl = (url: string) => {
+      maybeHandleRedeemHistoryIntent(url);
+    };
+
+    Linking.getInitialURL()
+      .then((url) => {
+        if (url) handleUrl(url);
+      })
+      .catch(() => {
+        // ignore
+      });
+
+    const subscription = Linking.addEventListener('url', ({ url }) => {
+      if (url) handleUrl(url);
+    });
+
+    return () => {
+      subscription.remove();
+    };
+  }, [maybeHandleRedeemHistoryIntent]);
+
+  if (!isReady || !initialParams) {
+    // Return loading state or null while initializing
+    return null;
+  }
+
+  // Determine if app was opened via deep link
+  const isDeepLinkEntryValue = deepLinkToRedemptionHistory || deepLinkToRedeem;
+  const deepLinkTargetValue = deepLinkToRedemptionHistory ? 'RedemptionHistory' : (deepLinkToRedeem ? 'Redeem' : undefined);
+  const isRNHostMode = !!(initialParams as any)?.__rnHostMode;
+  
+  console.log('🔍 SDKApp render: deepLinkToRedemptionHistory=', deepLinkToRedemptionHistory, 'deepLinkToRedeem=', deepLinkToRedeem, 'deepLinkTargetValue=', deepLinkTargetValue);
+
+  return (
+    <GestureHandlerRootView style={{ flex: 1 }}>
+    <Provider store={store}>
+      <SDKProvider 
+        isSDK={true}
+        initialDeepLinkEntry={isDeepLinkEntryValue}
+        initialDeepLinkTarget={deepLinkTargetValue}
+      >
+        <SafeAreaProvider>
+          <NavigationContainer
+            key={navigationKey}
+            ref={navigationRef}
+            independent={isRNHostMode}
+            onReady={() => {
+              console.log('🚀 NavigationContainer onReady fired');
+              console.log('🚀 Navigation state after ready:', JSON.stringify(navigationRef.current?.getRootState(), null, 2));
+              
+              // Execute any pending navigation
+              if (pendingNavigationRef.current) {
+                console.log('🚀 Executing pending navigation');
+                const pendingNav = pendingNavigationRef.current;
+                pendingNavigationRef.current = null;
+                // Use setTimeout to ensure navigation state is fully ready
+                setTimeout(() => {
+                  pendingNav();
+                }, 100);
+              }
+            }}
+          >
+            <SDKNavigator 
+              initialParams={initialParams} 
+              initialRouteOverride={deepLinkTargetValue}
+            />
+          </NavigationContainer>
+          <Toast 
+            config={toastConfig} 
+            topOffset={Platform.OS === 'ios' ? 60 : 40} 
+          />
+        </SafeAreaProvider>
+      </SDKProvider>
+    </Provider>
+    </GestureHandlerRootView>
+  );
+};
+
+export default SDKApp;
+

package/src/bridge/SDKBridge.ts

@@ -0,0 +1,104 @@
+/**
+ * SDK Bridge Module
+ * 
+ * Handles communication between native host app and React Native SDK
+ */
+
+import { NativeModules, NativeEventEmitter, Platform } from 'react-native';
+
+export interface SDKBridgeParams {
+  apiUrl: string;
+  apiKey?: string;
+  userId?: string;
+  userToken?: string;
+  theme?: any;
+  environment?: string;
+  [key: string]: any;
+}
+
+export interface SDKBridgeResult {
+  success: boolean;
+  data?: any;
+  message?: string;
+}
+
+class SDKBridge {
+  private bridgeModule: any;
+  private eventEmitter: NativeEventEmitter | null = null;
+
+  constructor() {
+    this.bridgeModule = NativeModules.PropelSDKBridge || NativeModules.PropelSDKModule;
+    
+    if (this.bridgeModule) {
+      this.eventEmitter = new NativeEventEmitter(this.bridgeModule);
+    }
+  }
+
+  /**
+   * Get initial parameters from native host app
+   */
+  getInitialParams(): Promise<SDKBridgeParams> {
+    if (this.bridgeModule && this.bridgeModule.getInitialParams) {
+      return this.bridgeModule.getInitialParams();
+    }
+    return Promise.resolve({} as SDKBridgeParams);
+  }
+
+  /**
+   * Send result/response back to native host app
+   */
+  sendResult(result: SDKBridgeResult): void {
+    if (this.bridgeModule && this.bridgeModule.sendResult) {
+      this.bridgeModule.sendResult(result);
+    }
+  }
+
+  /**
+   * Send event to native host app
+   */
+  sendEvent(eventType: string, payload?: any): void {
+    if (this.bridgeModule && this.bridgeModule.sendEvent) {
+      this.bridgeModule.sendEvent(eventType, payload);
+    }
+  }
+
+  /**
+   * Listen to events from native host app
+   */
+  addEventListener(eventType: string, callback: (data: any) => void): any {
+    if (this.eventEmitter) {
+      return this.eventEmitter.addListener(eventType, callback);
+    }
+    return null;
+  }
+
+  /**
+   * Remove event listener
+   */
+  removeEventListener(listener: any): void {
+    if (listener) {
+      listener.remove();
+    }
+  }
+
+  /**
+   * Dismiss SDK (close the SDK view)
+   */
+  dismiss(): void {
+    if (this.bridgeModule && this.bridgeModule.dismiss) {
+      this.bridgeModule.dismiss();
+    }
+  }
+
+  /**
+   * Check if bridge is available
+   */
+  isAvailable(): boolean {
+    return !!this.bridgeModule;
+  }
+}
+
+// Export singleton instance
+export const sdkBridge = new SDKBridge();
+export default sdkBridge;
+

package/src/bridge/index.ts

@@ -0,0 +1,3 @@
+export { default as sdkBridge, SDKBridge } from './SDKBridge';
+export type { SDKBridgeParams, SDKBridgeResult } from './SDKBridge';
+