@finspringinnovations/fdsdk 0.0.4 → 0.0.6

package/src/hooks/usePaymentSSE.ts

@@ -14,9 +14,12 @@
  */
 
 import { useCallback, useRef } from 'react';
-import { parseSSEBuffer, type SSEEvent } from '../utils/sseParser';
-import { getEnvironmentData } from '../config/appDataConfig';
-import { getApiConfig } from '../config/apiConfig';
+import { Platform } from 'react-native';
+import { parseSSEBuffer } from '../utils/sseParser';
+import { getEnvironmentData, getUserInfoForAPI } from '../config/appDataConfig';
+import { getApiConfig, getSecureHeaders } from '../config/apiConfig';
+import { decryptResponse } from '../utils/encryption';
+import { getEncryptionConfig } from '../config/encryptionConfig';
 
 // -- Types --
 
@@ -26,23 +29,46 @@ interface UsePaymentSSECallbacks {
     onConnected?: () => void;
 }
 
+export interface PaymentSSEExtraHeaders {
+    workflowInstanceId?: string;
+    applicationId?: string;
+    entityid?: string;
+    providerId?: string;
+}
+
 // -- Hook --
 
 export function usePaymentSSE() {
     // Store the XMLHttpRequest so we can abort it later
     const xhrRef = useRef<XMLHttpRequest | null>(null);
+    const reconnectTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+    const connectWatchdogTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+    const stopRequestedRef = useRef<boolean>(false);
+    const connectionIdRef = useRef<number>(0);
     // Track how much of responseText we've already parsed
     const lastIndexRef = useRef<number>(0);
     // SSE text buffer (persists across onprogress calls)
     const bufferRef = useRef<{ value: string }>({ value: '' });
 
     const start = useCallback(
-        (applicationId: string, callbacks: UsePaymentSSECallbacks) => {
+        (applicationId: string, callbacks: UsePaymentSSECallbacks, extraHeaders?: PaymentSSEExtraHeaders) => {
+            connectionIdRef.current += 1;
+            const connectionId = connectionIdRef.current;
+            stopRequestedRef.current = false;
+
             // Clean up any existing connection first
             if (xhrRef.current) {
                 xhrRef.current.abort();
                 xhrRef.current = null;
             }
+            if (reconnectTimerRef.current) {
+                clearTimeout(reconnectTimerRef.current);
+                reconnectTimerRef.current = null;
+            }
+            if (connectWatchdogTimerRef.current) {
+                clearTimeout(connectWatchdogTimerRef.current);
+                connectWatchdogTimerRef.current = null;
+            }
 
             // Reset parsing state
             lastIndexRef.current = 0;
@@ -51,95 +77,310 @@ export function usePaymentSSE() {
             // 1. Build the SSE endpoint URL
             const envData = getEnvironmentData();
             const apiConfig = getApiConfig();
-            const baseUrl = envData?.apiBaseUrl || apiConfig?.baseUrl || '';
-            const url = `${baseUrl}/events?applicationId=${encodeURIComponent(applicationId)}`;
+            const baseUrl = (envData?.apiBaseUrl || apiConfig?.baseUrl || '').replace(/\/$/, '');
+            const url = baseUrl ? `${baseUrl}/events?applicationId=${encodeURIComponent(applicationId)}` : '';
 
-            // 2. Create XMLHttpRequest
-            const xhr = new XMLHttpRequest();
-            xhrRef.current = xhr;
+            const minimalLogs = envData?.sseMinimalLogs === true;
+            const verboseSSE = envData?.enableVerboseSSELogging !== false;
+            const maxReconnectAttempts = Number(envData?.sseReconnectAttempts ?? 4);
+            const reconnectDelayMs = Number(envData?.sseReconnectDelayMs ?? 2000);
+            const connectWatchdogMs = Number(envData?.sseConnectTimeoutMs ?? 15000);
+            const rnVersion = (() => {
+                const v = (Platform as any)?.constants?.reactNativeVersion;
+                return v ? `${v.major}.${v.minor}.${v.patch}` : 'unknown';
+            })();
+            const jsEngine = (global as any)?.HermesInternal ? 'hermes' : 'jsc/other';
+            let reconnectAttempts = 0;
+            let connected = false;
 
-            xhr.open('GET', url);
-
-            // 3. Set headers (same headers your baseApi interceptor uses)
-            const apiKey = envData?.apiKey || apiConfig?.headers?.['X-API-Key'] || '';
-            if (apiKey) {
-                xhr.setRequestHeader('x-api-key', apiKey);
+            if (!url) {
+                if (__DEV__ && verboseSSE) console.warn('[usePaymentSSE] No base URL, skipping SSE');
+                return;
             }
-            xhr.setRequestHeader('Accept', 'text/event-stream');
-            xhr.setRequestHeader('Cache-Control', 'no-cache');
 
-            // 4. Handle incoming data
-            xhr.onprogress = () => {
-                // responseText contains ALL text received so far
-                // Only parse the NEW text since last call
-                const newText = xhr.responseText.slice(lastIndexRef.current);
-                lastIndexRef.current = xhr.responseText.length;
+            const scheduleReconnect = (reason: string) => {
+                if (stopRequestedRef.current || connectionIdRef.current !== connectionId) return;
+                if (connectWatchdogTimerRef.current) {
+                    clearTimeout(connectWatchdogTimerRef.current);
+                    connectWatchdogTimerRef.current = null;
+                }
+                if (reconnectAttempts >= maxReconnectAttempts) {
+                    callbacks.onError?.(new Error(reason));
+                    return;
+                }
+
+                reconnectAttempts += 1;
+                const delay = reconnectDelayMs * reconnectAttempts;
+
+                if (__DEV__ && !minimalLogs) {
+                    console.warn(`[usePaymentSSE] Reconnecting (${reconnectAttempts}/${maxReconnectAttempts}) in ${delay}ms`);
+                    console.log('[usePaymentSSE][runtime]', {
+                        reason,
+                        platform: Platform.OS,
+                        osVersion: String(Platform.Version),
+                        rnVersion,
+                        jsEngine,
+                        applicationId,
+                    });
+                }
+
+                if (reconnectTimerRef.current) {
+                    clearTimeout(reconnectTimerRef.current);
+                }
+
+                reconnectTimerRef.current = setTimeout(() => {
+                    if (stopRequestedRef.current || connectionIdRef.current !== connectionId) return;
+                    openConnection();
+                }, delay);
+            };
+
+            const openConnection = () => {
+                if (stopRequestedRef.current || connectionIdRef.current !== connectionId) return;
+                connected = false;
+
+                // 2. Create XMLHttpRequest
+                const xhr = new XMLHttpRequest();
+                xhrRef.current = xhr;
 
-                if (!newText) return;
+                xhr.open('GET', url);
 
-                // Parse new text into SSE events
-                const events = parseSSEBuffer(bufferRef.current, newText);
+                // 3. Set headers (same headers your baseApi interceptor uses)
+                const apiKey = envData?.apiKey || apiConfig?.headers?.['X-API-Key'] || '';
+                if (apiKey) {
+                    xhr.setRequestHeader('x-api-key', apiKey);
+                    xhr.setRequestHeader('X-API-Key', apiKey);
+                }
+
+                // Add secure headers (Content-Type, User-Agent, etc.)
+                const secureHeaders = getSecureHeaders();
+                Object.entries(secureHeaders).forEach(([key, value]) => {
+                    if (key.toLowerCase() !== 'content-type') {
+                        xhr.setRequestHeader(key, value);
+                    }
+                });
+
+                // SSE-specific headers
+                xhr.setRequestHeader('Accept', 'text/event-stream');
+                xhr.setRequestHeader('Cache-Control', 'no-cache, no-store, must-revalidate');
+                xhr.setRequestHeader('Pragma', 'no-cache');
+                xhr.setRequestHeader('Expires', '0');
+
+                // Add userreferenceid header (required for authentication) - both cases
+                try {
+                    const userInfo = getUserInfoForAPI();
+                    const userRefId = userInfo?.userReferenceId || userInfo?.id;
+                    if (userRefId) {
+                        xhr.setRequestHeader('userreferenceid', userRefId);
+                        xhr.setRequestHeader('userReferenceId', userRefId);
+                    }
+                } catch {
+                    if (__DEV__ && verboseSSE) console.warn('[usePaymentSSE] Could not get userReferenceId');
+                }
+
+                // Add provider header variants
+                if (extraHeaders?.providerId) {
+                    xhr.setRequestHeader('provider', extraHeaders.providerId);
+                    xhr.setRequestHeader('providerid', extraHeaders.providerId);
+                    xhr.setRequestHeader('providerId', extraHeaders.providerId);
+                }
+
+                // Add onboarding headers - both camelCase and lowercase variants
+                if (extraHeaders?.workflowInstanceId) {
+                    xhr.setRequestHeader('workflowInstanceId', extraHeaders.workflowInstanceId);
+                    xhr.setRequestHeader('workflowinstanceid', extraHeaders.workflowInstanceId);
+                }
+                if (extraHeaders?.applicationId) {
+                    xhr.setRequestHeader('applicationId', extraHeaders.applicationId);
+                    xhr.setRequestHeader('applicationid', extraHeaders.applicationId);
+                }
+                if (extraHeaders?.entityid) {
+                    xhr.setRequestHeader('entityid', extraHeaders.entityid);
+                    xhr.setRequestHeader('entityId', extraHeaders.entityid);
+                }
+
+                const markConnected = (path: 'headers' | 'progress') => {
+                    if (connected) return;
+                    connected = true;
+                    reconnectAttempts = 0;
+                    if (connectWatchdogTimerRef.current) {
+                        clearTimeout(connectWatchdogTimerRef.current);
+                        connectWatchdogTimerRef.current = null;
+                    }
+                    callbacks.onConnected?.();
+                    if (__DEV__ && !minimalLogs) {
+                        console.log('[usePaymentSSE] Connected to SSE stream');
+                        console.log('[usePaymentSSE][runtime]', {
+                            path,
+                            platform: Platform.OS,
+                            osVersion: String(Platform.Version),
+                            rnVersion,
+                            jsEngine,
+                            applicationId,
+                        });
+                    }
+                };
 
-                // Handle each event
-                for (const { eventType, data } of events) {
-                    if (eventType === 'fd_payment_status') {
+                // 4. Handle incoming data
+                xhr.onprogress = () => {
+                    if (xhr.responseText && xhr.responseText.length > 0) {
+                        markConnected('progress');
+                    }
+
+                    // responseText contains ALL text received so far
+                    // Only parse the NEW text since last call
+                    const newText = xhr.responseText.slice(lastIndexRef.current);
+                    lastIndexRef.current = xhr.responseText.length;
+
+                    if (!newText) return;
+
+                    // Parse new text into SSE events
+                    const events = parseSSEBuffer(bufferRef.current, newText);
+
+                    // Handle each event (support encrypted payload like web)
+                    const handleEventData = async (rawData: string) => {
                         try {
-                            const parsed = JSON.parse(data);
-                            const status = (parsed.paymentStatus ?? '').toUpperCase();
-                            callbacks.onPaymentStatus(status, parsed);
+                            const parsed = JSON.parse(rawData || '{}') as Record<string, unknown>;
+                            let payload = parsed;
+                            if (typeof parsed?.encryptedResponse === 'string' && parsed.encryptedResponse) {
+                                try {
+                                    const config = getEncryptionConfig();
+                                    const decrypted = await decryptResponse(
+                                        { encryptedResponse: parsed.encryptedResponse },
+                                        config
+                                    );
+                                    payload = (decrypted || {}) as Record<string, unknown>;
+                                } catch {
+                                    if (__DEV__ && verboseSSE) console.warn('[usePaymentSSE] Decrypt failed, using raw');
+                                }
+                            }
+                            const payloadData = (payload?.data as Record<string, unknown> | undefined) || {};
+                            const status = String(
+                                payload?.paymentStatus ??
+                                payload?.payment_status ??
+                                payloadData?.paymentStatus ??
+                                payloadData?.payment_status ??
+                                ''
+                            ).toUpperCase();
+                            if (status) callbacks.onPaymentStatus(status, payload);
                         } catch (parseError) {
-                            if (__DEV__) {
-                                console.error('[usePaymentSSE] Failed to parse event data:', parseError);
+                            if (__DEV__ && verboseSSE) console.error('[usePaymentSSE] Failed to parse event data:', parseError);
+                        }
+                    };
+
+                    for (const { eventType, data } of events) {
+                        if (!data) continue;
+                        const normalizedEventType = String(eventType || '').trim().toLowerCase();
+                        if (normalizedEventType === 'fd_payment_status') {
+                            handleEventData(data);
+                        } else if (normalizedEventType === 'message') {
+                            try {
+                                const parsed = JSON.parse(data) as { event?: string; [k: string]: unknown };
+                                const embeddedEvent = String(parsed?.event || '').trim().toLowerCase();
+                                if (embeddedEvent === 'fd_payment_status') handleEventData(data);
+                            } catch {
+                                // ignore
                             }
                         }
                     }
-                }
-            };
+                };
 
-            // 5. Handle successful connection
-            xhr.onreadystatechange = () => {
-                if (xhr.readyState === XMLHttpRequest.HEADERS_RECEIVED) {
-                    if (xhr.status === 200) {
-                        callbacks.onConnected?.();
-                        if (__DEV__) {
-                            console.log('[usePaymentSSE] Connected to SSE stream');
+                // 5. Handle connection status
+                xhr.onreadystatechange = () => {
+                    if (xhr.readyState === XMLHttpRequest.HEADERS_RECEIVED || xhr.readyState === XMLHttpRequest.LOADING) {
+                        if (xhr.status === 200) {
+                            markConnected('headers');
+                        } else if (xhr.readyState === XMLHttpRequest.HEADERS_RECEIVED && xhr.status > 0) {
+                            if (__DEV__) {
+                                console.error('[usePaymentSSE] Bad status:', xhr.status);
+                            }
+                            scheduleReconnect(`SSE response status: ${xhr.status}`);
                         }
-                    } else {
-                        if (__DEV__) {
-                            console.error('[usePaymentSSE] Bad status:', xhr.status);
+                    }
+
+                    if (xhr.readyState === XMLHttpRequest.DONE && !stopRequestedRef.current && connectionIdRef.current === connectionId) {
+                        if (xhr.status !== 200) {
+                            scheduleReconnect(`SSE closed with status: ${xhr.status}`);
                         }
-                        callbacks.onError?.(new Error(`SSE response status: ${xhr.status}`));
                     }
-                }
-            };
+                };
 
-            // 6. Handle errors
-            xhr.onerror = () => {
-                if (__DEV__) {
-                    console.error('[usePaymentSSE] Connection error');
+                // 6. Handle errors
+                xhr.onerror = () => {
+                    if (__DEV__ && verboseSSE) {
+                        console.error('[usePaymentSSE] Connection error');
+                    }
+                    scheduleReconnect('SSE connection failed');
+                };
+
+                // 7. Handle timeout
+                xhr.ontimeout = () => {
+                    if (__DEV__) {
+                        console.error('[usePaymentSSE] Connection timed out');
+                    }
+                    scheduleReconnect('SSE connection timed out');
+                };
+
+                // 8. Send the request (connection stays open)
+                xhr.send();
+
+                // If we never get connected callback/progress, restart connection.
+                if (connectWatchdogTimerRef.current) {
+                    clearTimeout(connectWatchdogTimerRef.current);
                 }
-                callbacks.onError?.(new Error('SSE connection failed'));
-            };
+                connectWatchdogTimerRef.current = setTimeout(() => {
+                    if (connected || stopRequestedRef.current || connectionIdRef.current !== connectionId) return;
+                    try {
+                        xhr.abort();
+                    } catch {
+                        // ignore
+                    }
+                    scheduleReconnect('SSE connect watchdog timeout');
+                }, connectWatchdogMs);
 
-            // 7. Handle timeout
-            xhr.ontimeout = () => {
                 if (__DEV__) {
-                    console.error('[usePaymentSSE] Connection timed out');
+                    console.log('[usePaymentSSE] Starting SSE connection to:', url);
+                    console.log('[usePaymentSSE][runtime]', {
+                        phase: 'start',
+                        platform: Platform.OS,
+                        osVersion: String(Platform.Version),
+                        rnVersion,
+                        jsEngine,
+                        applicationId,
+                    });
+                    console.log('[usePaymentSSE] Headers:', {
+                        'x-api-key': apiKey ? '***' : 'missing',
+                        'userreferenceid': (() => {
+                            try {
+                                const userInfo = getUserInfoForAPI();
+                                return userInfo?.userReferenceId || userInfo?.id || 'missing';
+                            } catch {
+                                return 'missing';
+                            }
+                        })(),
+                        'provider': extraHeaders?.providerId || 'missing',
+                        'workflowInstanceId': extraHeaders?.workflowInstanceId || 'missing',
+                        'applicationId': extraHeaders?.applicationId || 'missing',
+                        'entityid': extraHeaders?.entityid || 'missing',
+                    });
                 }
-                callbacks.onError?.(new Error('SSE connection timed out'));
             };
 
-            // 8. Send the request (connection stays open)
-            xhr.send();
-
-            if (__DEV__) {
-                console.log('[usePaymentSSE] Starting SSE connection to:', url);
-            }
+            openConnection();
         },
         []
     );
 
     const stop = useCallback(() => {
+        stopRequestedRef.current = true;
+        connectionIdRef.current += 1;
+        if (reconnectTimerRef.current) {
+            clearTimeout(reconnectTimerRef.current);
+            reconnectTimerRef.current = null;
+        }
+        if (connectWatchdogTimerRef.current) {
+            clearTimeout(connectWatchdogTimerRef.current);
+            connectWatchdogTimerRef.current = null;
+        }
         if (xhrRef.current) {
             xhrRef.current.abort();
             xhrRef.current = null;
@@ -152,4 +393,4 @@ export function usePaymentSSE() {
     }, []);
 
     return { start, stop };
-}
+}

package/src/navigation/RootNavigator.tsx

@@ -312,15 +312,21 @@ const RootNavigator: React.FC<RootNavigatorProps> = ({
                         onGoBack={() => goBack()}
                         paymentUrl={(getPaymentSession().paymentUrl) || ''}
                         onPaymentSuccess={(data) => {
+                            const payload = data && typeof data === 'object' ? data : {};
+                            const transactionId = (payload as any)?.transactionId ?? (payload as any)?.transaction_id ?? (payload as any)?.TransactionId;
                             navigate('PaymentStatus', {
                                 status: 'success',
-                                paymentData: data
+                                paymentData: data,
+                                transactionId,
                             } as any);
                         }}
                         onPaymentFailure={(error) => {
+                            const payload = error && typeof error === 'object' ? error : {};
+                            const transactionId = (payload as any)?.transactionId ?? (payload as any)?.transaction_id ?? (payload as any)?.TransactionId;
                             navigate('PaymentStatus', {
                                 status: 'failed',
-                                paymentData: error
+                                paymentData: error,
+                                transactionId,
                             } as any);
                         }}
                         onPaymentPending={(info) => {

package/src/screens/AadhaarVerification.tsx

@@ -295,7 +295,7 @@ const AadhaarVerification: React.FC<AadhaarVerificationProps> = ({
                         applicationid: applicationId,
                         entityid: entityId,
                         // Request params/body
-                        targetTaskId: WORKFLOW_TASKS.VALIDATE_OTP,
+                        targetTaskCaption: WORKFLOW_TASKS.VALIDATE_OTP,
                     }).unwrap();
                     setIsValidateOtpTaskCalled(true);
                 } else {
@@ -357,7 +357,7 @@ const AadhaarVerification: React.FC<AadhaarVerificationProps> = ({
                 applicationid: applicationId,
                 entityid: entityId,
                 // Request params/body
-                targetTaskId: WORKFLOW_TASKS.RESEND_OTP,
+                targetTaskCaption: WORKFLOW_TASKS.RESEND_OTP,
             }).unwrap();
 
 

package/src/screens/FDCalculator.tsx

@@ -140,7 +140,12 @@ const FDCalculator: React.FC<FDCalculatorProps> = ({ onGoBack, onExitSDK, onPanR
 
     const { data: fallbackMasterData, isLoading: isLoadingFallback, error: fallbackError, refetch: refetchMasterData } = useGetMasterDataQuery(
         { providerId: defaultProviderId }, // Use default provider ID
-        { skip: !!masterData } // Skip if master data is already available
+        {
+            skip: !!masterData || !defaultProviderId,
+            refetchOnMountOrArgChange: true,
+            refetchOnFocus: true,
+            refetchOnReconnect: true,
+        }
     );
 
     // Use fallback master data if global master data is not available
@@ -1011,4 +1016,4 @@ const createStyles = (typography: any, colors: any, themeName: string) => StyleS
         backgroundColor: 'rgba(0, 0, 0, 0.3)',
         zIndex: 1000,
     },
-});
+});