@finspringinnovations/fdsdk 0.0.5 → 0.0.7

package/src/hooks/usePaymentSSE.ts

@@ -14,6 +14,7 @@
  */
 
 import { useCallback, useRef } from 'react';
+import { Platform } from 'react-native';
 import { parseSSEBuffer } from '../utils/sseParser';
 import { getEnvironmentData, getUserInfoForAPI } from '../config/appDataConfig';
 import { getApiConfig, getSecureHeaders } from '../config/apiConfig';
@@ -40,6 +41,10 @@ export interface PaymentSSEExtraHeaders {
 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)
@@ -47,11 +52,23 @@ export function usePaymentSSE() {
 
     const start = useCallback(
         (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;
@@ -63,177 +80,307 @@ export function usePaymentSSE() {
             const baseUrl = (envData?.apiBaseUrl || apiConfig?.baseUrl || '').replace(/\/$/, '');
             const url = baseUrl ? `${baseUrl}/events?applicationId=${encodeURIComponent(applicationId)}` : '';
 
+            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;
+
             if (!url) {
-                if (__DEV__) console.warn('[usePaymentSSE] No base URL, skipping SSE');
+                if (__DEV__ && verboseSSE) console.warn('[usePaymentSSE] No base URL, skipping SSE');
                 return;
             }
 
-            // 2. Create XMLHttpRequest
-            const xhr = new XMLHttpRequest();
-            xhrRef.current = xhr;
+            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;
+                }
 
-            xhr.open('GET', url);
+                reconnectAttempts += 1;
+                const delay = reconnectDelayMs * reconnectAttempts;
 
-            // 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);
-            }
-            
-            // 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);
+                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,
+                    });
                 }
-            });
-            
-            // 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);
+
+                if (reconnectTimerRef.current) {
+                    clearTimeout(reconnectTimerRef.current);
                 }
-            } catch {
-                if (__DEV__) console.warn('[usePaymentSSE] Could not get userReferenceId');
-            }
-            
-            // Add provider header (required for authentication)
-            if (extraHeaders?.providerId) {
-                xhr.setRequestHeader('provider', extraHeaders.providerId);
-            }
-            
-            // Add onboarding headers - both camelCase and lowercase variants
-            if (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);
-            }
 
-            // 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;
+                reconnectTimerRef.current = setTimeout(() => {
+                    if (stopRequestedRef.current || connectionIdRef.current !== connectionId) return;
+                    openConnection();
+                }, delay);
+            };
 
-                if (!newText) return;
+            const openConnection = () => {
+                if (stopRequestedRef.current || connectionIdRef.current !== connectionId) return;
+                connected = false;
 
-                // Parse new text into SSE events
-                const events = parseSSEBuffer(bufferRef.current, newText);
+                // 2. Create XMLHttpRequest
+                const xhr = new XMLHttpRequest();
+                xhrRef.current = xhr;
 
-                // Handle each event (support encrypted payload like web)
-                const handleEventData = async (rawData: string) => {
-                    try {
-                        const parsed = JSON.parse(rawData || '{}') as Record<string, unknown>;
-                        let payload = parsed;
-                        if (typeof parsed?.encryptedResponse === 'string' && parsed.encryptedResponse) {
+                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);
+                    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,
+                        });
+                    }
+                };
+
+                // 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(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__ && 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 config = getEncryptionConfig();
-                                const decrypted = await decryptResponse(
-                                    { encryptedResponse: parsed.encryptedResponse },
-                                    config
-                                );
-                                payload = (decrypted || {}) as Record<string, unknown>;
+                                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 {
-                                if (__DEV__) console.warn('[usePaymentSSE] Decrypt failed, using raw');
+                                // ignore
                             }
                         }
-                        const status = String(payload?.paymentStatus ?? payload?.payment_status ?? '').toUpperCase();
-                        if (status) callbacks.onPaymentStatus(status, payload);
-                    } catch (parseError) {
-                        if (__DEV__) console.error('[usePaymentSSE] Failed to parse event data:', parseError);
                     }
                 };
 
-                for (const { eventType, data } of events) {
-                    if (!data) continue;
-                    if (eventType === 'fd_payment_status') {
-                        handleEventData(data);
-                    } else if (eventType === 'message') {
-                        try {
-                            const parsed = JSON.parse(data) as { event?: string; [k: string]: unknown };
-                            if (parsed?.event === 'fd_payment_status') handleEventData(data);
-                        } catch {
-                            // ignore
+                // 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}`);
                         }
                     }
-                }
-            };
 
-            // 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');
+                    if (xhr.readyState === XMLHttpRequest.DONE && !stopRequestedRef.current && connectionIdRef.current === connectionId) {
+                        if (xhr.status !== 200) {
+                            scheduleReconnect(`SSE closed with status: ${xhr.status}`);
                         }
-                    } else {
-                        if (__DEV__) {
-                            console.error('[usePaymentSSE] Bad 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);
-                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',
-                });
-            }
+            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;
@@ -246,4 +393,4 @@ export function usePaymentSSE() {
     }, []);
 
     return { start, stop };
-}
+}

package/src/screens/FDCalculator.tsx

@@ -757,7 +757,29 @@ const FDCalculator: React.FC<FDCalculatorProps> = ({ onGoBack, onExitSDK, onPanR
                                 ? data?.sdrCalc?.[0]
                                 : data?.fdrCalc?.[0];
                             const maturityAmount = calcData?.maturityAmount || data?.maturityAmount || data?.totalAmount || data?.finalAmount || data?.amount;
-                            return maturityAmount ? `₹${maturityAmount.toLocaleString()}` : "";
+                            return maturityAmount ? `₹${Number(maturityAmount).toLocaleString()}` : "";
+                        })()}
+                        intPayAmt={(() => {
+                            const data = calculationResult?.data;
+                            const investmentType = payoutValue === 'On Maturity' ? 'SDR' : 'FDR';
+                            const calcData = investmentType === 'SDR'
+                                ? data?.sdrCalc?.[0]
+                                : data?.fdrCalc?.[0];
+                            const val = calcData?.intPayAmt;
+                            if (val == null) return undefined;
+                            const num = Number(val);
+                            return Number.isFinite(num) ? `₹ ${num.toLocaleString()}` : String(val);
+                        })()}
+                        totalInterestEarnings={(() => {
+                            const data = calculationResult?.data;
+                            const investmentType = payoutValue === 'On Maturity' ? 'SDR' : 'FDR';
+                            const calcData = investmentType === 'SDR'
+                                ? data?.sdrCalc?.[0]
+                                : data?.fdrCalc?.[0];
+                            const val = calcData?.totalInterestEarnings;
+                            if (val == null) return undefined;
+                            const num = Number(val);
+                            return Number.isFinite(num) ? `₹ ${num.toLocaleString()}` : String(val);
                         })()}
                     >
                         <CheckboxOption