@tagadapay/plugin-sdk 3.1.12 → 3.1.24

package/dist/v2/react/hooks/payment-actions/useFinixRadarAction.js

@@ -0,0 +1,187 @@
+/**
+ * Hook for handling Finix fraud detection
+ */
+import { useCallback } from 'react';
+export function useFinixRadarAction({ paymentsResource, startPolling, setError, setIsLoading, hookOptionsRef, }) {
+    const handleFinixRadar = useCallback(async (payment, actionData, options = {}, handlePaymentAction) => {
+        const radarConfig = actionData.metadata?.radar;
+        if (!radarConfig) {
+            console.error('Finix radar config missing from payment action');
+            return;
+        }
+        try {
+            // Dynamically load Finix SDK if not already loaded
+            if (typeof window !== 'undefined' && typeof window.Finix?.Auth !== 'function') {
+                const existingScript = document.querySelector('script[src="https://js.finix.com/v/1/finix.js"]');
+                if (!existingScript) {
+                    const script = document.createElement('script');
+                    script.src = 'https://js.finix.com/v/1/finix.js';
+                    script.async = true;
+                    document.head.appendChild(script);
+                    await new Promise((resolve, reject) => {
+                        script.onload = () => {
+                            console.log('Finix SDK loaded successfully');
+                            resolve();
+                        };
+                        script.onerror = () => reject(new Error('Failed to load Finix SDK'));
+                    });
+                }
+                else {
+                    // Wait for existing script to load
+                    await new Promise((resolve, reject) => {
+                        const checkFinix = () => {
+                            if (typeof window.Finix?.Auth === 'function') {
+                                resolve();
+                            }
+                            else {
+                                setTimeout(checkFinix, 100);
+                            }
+                        };
+                        checkFinix();
+                        setTimeout(() => reject(new Error('Timeout waiting for Finix SDK')), 10000);
+                    });
+                }
+            }
+            // Get session key from Finix using callback to ensure initialization is complete
+            const sessionKey = await new Promise((resolve, reject) => {
+                const timeoutId = setTimeout(() => {
+                    reject(new Error('Timeout waiting for Finix Auth initialization'));
+                }, 10000);
+                // Initialize Finix Auth with callback
+                const FinixAuth = window.Finix.Auth(radarConfig.environment, radarConfig.merchantId, () => {
+                    // Callback fired when Finix Auth is ready
+                    clearTimeout(timeoutId);
+                    const key = FinixAuth.getSessionKey();
+                    console.log('Finix Auth initialized, session key:', key);
+                    if (key) {
+                        resolve(key);
+                    }
+                    else {
+                        reject(new Error('No session key returned from Finix after initialization'));
+                    }
+                });
+                // Also try getting session key immediately in case it's already ready
+                const immediateKey = FinixAuth.getSessionKey();
+                if (immediateKey) {
+                    clearTimeout(timeoutId);
+                    console.log('Finix session key obtained immediately:', immediateKey);
+                    resolve(immediateKey);
+                }
+            });
+            console.log('Finix fraud session key obtained:', sessionKey);
+            // Save radar session to database
+            await paymentsResource.saveRadarSession({
+                orderId: radarConfig.orderId,
+                finixRadarSessionId: sessionKey,
+                finixRadarSessionData: {
+                    sessionKey,
+                    merchantId: radarConfig.merchantId,
+                    environment: radarConfig.environment,
+                    createdAt: new Date().toISOString(),
+                },
+            });
+            console.log('Finix radar session saved to database');
+            // Resume payment by calling completePaymentAfterAction
+            const resumedPayment = await paymentsResource.completePaymentAfterAction(payment.id);
+            console.log('Payment resumed after Finix radar:', resumedPayment);
+            // Handle the resumed payment response
+            if (resumedPayment.status === 'declined' || resumedPayment.status === 'failed') {
+                // Payment declined or failed - extract error message from response
+                const errorMsg = resumedPayment.error?.message
+                    || resumedPayment.error?.processorMessage
+                    || 'Payment declined';
+                console.error('❌ [usePayment] Payment declined after Finix radar:', errorMsg);
+                setError(errorMsg);
+                setIsLoading(false);
+                options.onFailure?.(errorMsg);
+                options.onPaymentFailed?.({
+                    code: resumedPayment.error?.code || 'PAYMENT_DECLINED',
+                    message: errorMsg,
+                    payment: resumedPayment,
+                });
+                // Hook-level callback (universal handler)
+                if (hookOptionsRef.current?.onPaymentFailed) {
+                    hookOptionsRef.current.onPaymentFailed(errorMsg, {
+                        isRedirectReturn: false,
+                    });
+                }
+            }
+            else if (resumedPayment.status === 'succeeded') {
+                // Payment succeeded
+                setIsLoading(false);
+                const response = {
+                    paymentId: resumedPayment.id,
+                    payment: resumedPayment,
+                    order: resumedPayment.order,
+                };
+                // Hook-level callback (universal handler)
+                if (hookOptionsRef.current?.onPaymentCompleted) {
+                    await hookOptionsRef.current.onPaymentCompleted(resumedPayment, {
+                        isRedirectReturn: false,
+                        order: response.order,
+                    });
+                }
+                options.onSuccess?.(response);
+                options.onPaymentSuccess?.(response);
+            }
+            else if (resumedPayment.requireAction !== 'none' && resumedPayment.requireActionData) {
+                // Payment requires another action (e.g., 3DS)
+                await handlePaymentAction(resumedPayment, options);
+            }
+            else {
+                // Start polling for final status
+                startPolling(resumedPayment.id, {
+                    onRequireAction: (updatedPayment) => {
+                        void handlePaymentAction(updatedPayment, options);
+                    },
+                    onSuccess: async (successPayment) => {
+                        setIsLoading(false);
+                        const response = {
+                            paymentId: successPayment.id,
+                            payment: successPayment,
+                            order: successPayment.order,
+                        };
+                        // Hook-level callback (universal handler)
+                        if (hookOptionsRef.current?.onPaymentCompleted) {
+                            await hookOptionsRef.current.onPaymentCompleted(successPayment, {
+                                isRedirectReturn: false,
+                                order: response.order,
+                            });
+                        }
+                        options.onSuccess?.(response);
+                        options.onPaymentSuccess?.(response);
+                    },
+                    onFailure: async (errorMsg) => {
+                        setError(errorMsg);
+                        setIsLoading(false);
+                        // Hook-level callback (universal handler)
+                        if (hookOptionsRef.current?.onPaymentFailed) {
+                            await hookOptionsRef.current.onPaymentFailed(errorMsg, {
+                                isRedirectReturn: false,
+                            });
+                        }
+                        options.onFailure?.(errorMsg);
+                        options.onPaymentFailed?.({
+                            code: 'PAYMENT_FAILED',
+                            message: errorMsg,
+                            payment,
+                        });
+                    },
+                });
+            }
+        }
+        catch (radarError) {
+            const errorMsg = radarError instanceof Error ? radarError.message : 'Finix fraud detection failed';
+            console.error('Finix radar error:', radarError);
+            setError(errorMsg);
+            setIsLoading(false);
+            options.onFailure?.(errorMsg);
+            options.onPaymentFailed?.({
+                code: 'FINIX_RADAR_FAILED',
+                message: errorMsg,
+                payment,
+            });
+        }
+    }, [paymentsResource, startPolling, setError, setIsLoading, hookOptionsRef]);
+    return { handleFinixRadar };
+}

package/dist/v2/react/hooks/payment-actions/useKessPayAction.d.ts

@@ -0,0 +1,11 @@
+import type { Payment, PaymentOptions } from '../../../core/resources/payments';
+import type { UsePaymentOptions } from '../usePaymentQuery';
+interface UseKessPayActionParams {
+    setError: (error: string | null) => void;
+    setIsLoading: (loading: boolean) => void;
+    hookOptionsRef: React.MutableRefObject<UsePaymentOptions | undefined>;
+}
+export declare function useKessPayAction({ setError, setIsLoading, hookOptionsRef, }: UseKessPayActionParams): {
+    handleKessPayAuth: (payment: Payment, actionData: any, options?: PaymentOptions) => Promise<void>;
+};
+export {};

package/dist/v2/react/hooks/payment-actions/useKessPayAction.js

@@ -0,0 +1,91 @@
+/**
+ * Hook for handling KessPay 3DS authentication
+ */
+import { useCallback, useRef } from 'react';
+export function useKessPayAction({ setError, setIsLoading, hookOptionsRef, }) {
+    const challengeInProgressRef = useRef(false);
+    const handleKessPayAuth = useCallback(async (payment, actionData, options = {}) => {
+        if (challengeInProgressRef.current) {
+            console.log('KessPay 3DS challenge already in progress');
+            return;
+        }
+        const threeDSData = actionData?.metadata?.threeds;
+        if (!threeDSData?.challengeHtml) {
+            const errorMsg = 'Missing KessPay 3DS challenge HTML';
+            console.error(errorMsg);
+            setError(errorMsg);
+            setIsLoading(false);
+            options.onFailure?.(errorMsg);
+            options.onPaymentFailed?.({
+                code: 'KESSPAY_MISSING_DATA',
+                message: errorMsg,
+                payment,
+            });
+            return;
+        }
+        try {
+            challengeInProgressRef.current = true;
+            setIsLoading(false); // Stop loading before redirect
+            console.log('🔐 [KessPay] Starting 3DS authentication:', {
+                sessionId: threeDSData.sessionId,
+                orderId: threeDSData.orderId,
+                hasHtml: !!threeDSData.challengeHtml,
+            });
+            // Create a temporary document to execute the challenge HTML
+            // This will trigger the auto-submit form and redirect
+            const tempDoc = document.implementation.createHTMLDocument('KessPay 3DS Challenge');
+            tempDoc.body.innerHTML = threeDSData.challengeHtml;
+            // Find and submit the form directly
+            const form = tempDoc.querySelector('form');
+            if (form) {
+                // Create a new form in the current document and submit it
+                const redirectForm = document.createElement('form');
+                redirectForm.method = form.method || 'POST';
+                redirectForm.action = form.action || '';
+                redirectForm.style.display = 'none';
+                // Copy all form inputs
+                const inputs = form.querySelectorAll('input');
+                inputs.forEach(input => {
+                    const newInput = document.createElement('input');
+                    newInput.type = input.type;
+                    newInput.name = input.name;
+                    newInput.value = input.value;
+                    redirectForm.appendChild(newInput);
+                });
+                // Add form to document and submit
+                document.body.appendChild(redirectForm);
+                redirectForm.submit();
+                console.log('🔐 [KessPay] Redirecting to 3DS challenge...');
+            }
+            else {
+                // Fallback: write the HTML directly to current document
+                // This should trigger the auto-submit script
+                document.open();
+                document.write(threeDSData.challengeHtml);
+                document.close();
+            }
+            // Note: Success callback will be triggered after redirect return
+            // Payment status will be updated via webhook
+        }
+        catch (error) {
+            challengeInProgressRef.current = false;
+            const errorMsg = error instanceof Error ? error.message : 'Failed to process KessPay 3DS authentication';
+            console.error('🔐 [KessPay] 3DS authentication error:', error);
+            setError(errorMsg);
+            setIsLoading(false);
+            options.onFailure?.(errorMsg);
+            options.onPaymentFailed?.({
+                code: 'KESSPAY_AUTH_FAILED',
+                message: errorMsg,
+                payment,
+            });
+            // Hook-level callback (universal handler)
+            if (hookOptionsRef.current?.onPaymentFailed) {
+                hookOptionsRef.current.onPaymentFailed(errorMsg, {
+                    isRedirectReturn: false,
+                });
+            }
+        }
+    }, [setError, setIsLoading, hookOptionsRef]);
+    return { handleKessPayAuth };
+}

package/dist/v2/react/hooks/payment-actions/useMasterCardAction.d.ts

@@ -0,0 +1,24 @@
+import type { Payment, PaymentOptions } from '../../../core/resources/payments';
+import type { PaymentsResource } from '../../../core/resources/payments';
+import type { UsePaymentOptions } from '../usePaymentQuery';
+interface UseMasterCardActionParams {
+    paymentsResource: PaymentsResource;
+    startPolling: any;
+    setError: (error: string | null) => void;
+    setIsLoading: (loading: boolean) => void;
+    hookOptionsRef: React.MutableRefObject<UsePaymentOptions | undefined>;
+}
+declare global {
+    interface Window {
+        ThreeDS: {
+            configure: (config: any) => void;
+            isConfigured: () => boolean;
+            initiateAuthentication: (orderId: string, transactionId: string, callback: (result: any) => void, optionalParams?: any) => void;
+            authenticatePayer: (orderId: string, transactionId: string, callback: (result: any) => void, optionalParams?: any) => void;
+        };
+    }
+}
+export declare function useMasterCardAction({ paymentsResource, startPolling, setError, setIsLoading, hookOptionsRef, }: UseMasterCardActionParams): {
+    handleMasterCardAuth: (payment: Payment, actionData: any, options: PaymentOptions | undefined, handlePaymentAction: any) => Promise<void>;
+};
+export {};

package/dist/v2/react/hooks/payment-actions/useMasterCardAction.js

@@ -0,0 +1,221 @@
+/**
+ * Hook for handling MasterCard 3DS authentication
+ */
+import { useCallback, useRef, useState } from 'react';
+import { useThreedsModal } from '../useThreedsModal';
+export function useMasterCardAction({ paymentsResource, startPolling, setError, setIsLoading, hookOptionsRef, }) {
+    const challengeInProgressRef = useRef(false);
+    const [isShowingChallenge, setIsShowingChallenge] = useState(false);
+    const { createThreedsModal, closeThreedsModal } = useThreedsModal();
+    // Load MasterCard 3DS script
+    const loadScript = useCallback(async (scriptUrl) => {
+        return new Promise((resolve, reject) => {
+            if (window.ThreeDS) {
+                resolve();
+                return;
+            }
+            const existingScript = document.querySelector(`script[src="${scriptUrl}"]`);
+            if (existingScript) {
+                existingScript.addEventListener('load', () => resolve());
+                existingScript.addEventListener('error', () => reject(new Error('Failed to load 3DS script')));
+                return;
+            }
+            const script = document.createElement('script');
+            script.src = scriptUrl;
+            script.onload = () => resolve();
+            script.onerror = () => reject(new Error('Failed to load 3DS script'));
+            document.head.appendChild(script);
+        });
+    }, []);
+    const handleMasterCardAuth = useCallback(async (payment, actionData, options = {}, handlePaymentAction) => {
+        if (challengeInProgressRef.current) {
+            console.log('MasterCard 3DS challenge already in progress');
+            return;
+        }
+        const threeDSData = actionData?.metadata?.threeds;
+        if (!threeDSData?.sessionId || !threeDSData?.merchantId) {
+            const errorMsg = 'Missing MasterCard 3DS authentication data';
+            console.error(errorMsg);
+            setError(errorMsg);
+            setIsLoading(false);
+            options.onFailure?.(errorMsg);
+            options.onPaymentFailed?.({
+                code: 'MASTERCARD_MISSING_DATA',
+                message: errorMsg,
+                payment,
+            });
+            return;
+        }
+        try {
+            challengeInProgressRef.current = true;
+            setIsLoading(false);
+            console.log('[MasterCard 3DS] Starting authentication:', {
+                sessionId: threeDSData.sessionId,
+                orderId: threeDSData.orderId,
+                transactionId: threeDSData.transactionId,
+            });
+            // Load the MasterCard 3DS script
+            await loadScript(threeDSData.scriptUrl);
+            // Create hidden container for 3DS iframe
+            const containerId = 'mastercard-3ds-container';
+            let container = document.getElementById(containerId);
+            if (!container) {
+                container = document.createElement('div');
+                container.id = containerId;
+                container.style.cssText = 'position: absolute; top: -9999px; left: -9999px; width: 1px; height: 1px; overflow: hidden;';
+                document.body.appendChild(container);
+            }
+            // Configure ThreeDS API
+            console.log('[MasterCard 3DS] Configuring ThreeDS API');
+            await new Promise((resolve, reject) => {
+                window.ThreeDS.configure({
+                    merchantId: threeDSData.merchantId,
+                    sessionId: threeDSData.sessionId,
+                    containerId,
+                    callback: function () {
+                        if (window.ThreeDS.isConfigured()) {
+                            console.log('[MasterCard 3DS] Configuration completed');
+                            resolve();
+                        }
+                        else {
+                            reject(new Error('ThreeDS configuration failed'));
+                        }
+                    },
+                    configuration: {
+                        userLanguage: 'en-US',
+                        wsVersion: threeDSData.version ? parseInt(threeDSData.version, 10) : 72,
+                    },
+                });
+            });
+            // Authenticate payer
+            const authResult = await new Promise((resolve) => {
+                window.ThreeDS.authenticatePayer(threeDSData.orderId, threeDSData.transactionId, (payerResult) => {
+                    console.log('[MasterCard 3DS] authenticatePayer result:', payerResult);
+                    resolve(payerResult);
+                });
+            });
+            // Check if challenge HTML is present
+            const challengeHtml = authResult?.htmlRedirectCode || authResult?.restApiResponse?.authentication?.redirect?.html;
+            if (challengeHtml) {
+                setIsShowingChallenge(true);
+                // Create modal for challenge
+                const modal = createThreedsModal({
+                    containerId: 'mastercard-3ds-modal',
+                    mode: 'auto-fit',
+                    onClose: () => {
+                        console.log('[MasterCard 3DS] Modal closed by user');
+                        setIsShowingChallenge(false);
+                        challengeInProgressRef.current = false;
+                        const errorMsg = 'User closed the authentication modal';
+                        setError(errorMsg);
+                        options.onFailure?.(errorMsg);
+                        options.onPaymentFailed?.({
+                            code: 'MASTERCARD_CANCELLED',
+                            message: errorMsg,
+                            payment,
+                        });
+                    },
+                });
+                const contentElement = modal.getContentElement();
+                if (contentElement) {
+                    contentElement.innerHTML = challengeHtml;
+                    // Auto-submit form if present
+                    setTimeout(() => {
+                        const frictionlessForm = contentElement.querySelector('#threedsFrictionLessRedirectForm');
+                        const challengeForm = contentElement.querySelector('#threedsChallengeRedirectForm');
+                        const form = frictionlessForm ?? challengeForm;
+                        if (form) {
+                            console.log('[MasterCard 3DS] Auto-submitting form');
+                            form.submit();
+                            // For frictionless flow, close modal and complete payment
+                            if (frictionlessForm) {
+                                setTimeout(async () => {
+                                    closeThreedsModal('mastercard-3ds-modal');
+                                    setIsShowingChallenge(false);
+                                    challengeInProgressRef.current = false;
+                                    // Complete payment after frictionless 3DS
+                                    if (threeDSData.paymentId) {
+                                        const resumedPayment = await paymentsResource.completePaymentAfterAction(threeDSData.paymentId);
+                                        await handlePaymentAction(resumedPayment, options);
+                                    }
+                                }, 1000);
+                            }
+                            else {
+                                // Challenge flow - listen for completion
+                                const handleIframeMessage = async (event) => {
+                                    const messageData = event.data;
+                                    let isComplete = false;
+                                    if (typeof messageData === 'string') {
+                                        isComplete = messageData.toLowerCase().includes('complete') ||
+                                            messageData.toLowerCase().includes('success');
+                                    }
+                                    else if (typeof messageData === 'object' && messageData !== null) {
+                                        isComplete = messageData.result === 'SUCCESS' ||
+                                            messageData.transStatus === 'Y' ||
+                                            messageData.type === '3DSAuthenticationComplete';
+                                    }
+                                    if (isComplete) {
+                                        console.log('[MasterCard 3DS] Challenge completed');
+                                        window.removeEventListener('message', handleIframeMessage);
+                                        closeThreedsModal('mastercard-3ds-modal');
+                                        setIsShowingChallenge(false);
+                                        challengeInProgressRef.current = false;
+                                        // Complete payment after challenge
+                                        if (threeDSData.paymentId) {
+                                            const resumedPayment = await paymentsResource.completePaymentAfterAction(threeDSData.paymentId);
+                                            await handlePaymentAction(resumedPayment, options);
+                                        }
+                                    }
+                                };
+                                window.addEventListener('message', handleIframeMessage);
+                                // Timeout after 5 minutes
+                                setTimeout(() => {
+                                    window.removeEventListener('message', handleIframeMessage);
+                                    closeThreedsModal('mastercard-3ds-modal');
+                                    setIsShowingChallenge(false);
+                                    challengeInProgressRef.current = false;
+                                    const errorMsg = '3DS authentication timed out';
+                                    setError(errorMsg);
+                                    options.onFailure?.(errorMsg);
+                                }, 300000);
+                            }
+                        }
+                    }, 100);
+                }
+            }
+            else {
+                // No challenge required - frictionless flow
+                console.log('[MasterCard 3DS] No challenge required');
+                challengeInProgressRef.current = false;
+                if (threeDSData.paymentId) {
+                    const resumedPayment = await paymentsResource.completePaymentAfterAction(threeDSData.paymentId);
+                    await handlePaymentAction(resumedPayment, options);
+                }
+            }
+            // Cleanup container
+            const cleanupContainer = document.getElementById('mastercard-3ds-container');
+            if (cleanupContainer && document.body.contains(cleanupContainer)) {
+                document.body.removeChild(cleanupContainer);
+            }
+        }
+        catch (error) {
+            challengeInProgressRef.current = false;
+            const errorMsg = error instanceof Error ? error.message : 'MasterCard 3DS authentication failed';
+            console.error('[MasterCard 3DS] Error:', error);
+            setError(errorMsg);
+            setIsLoading(false);
+            options.onFailure?.(errorMsg);
+            options.onPaymentFailed?.({
+                code: 'MASTERCARD_AUTH_FAILED',
+                message: errorMsg,
+                payment,
+            });
+            if (hookOptionsRef.current?.onPaymentFailed) {
+                hookOptionsRef.current.onPaymentFailed(errorMsg, {
+                    isRedirectReturn: false,
+                });
+            }
+        }
+    }, [paymentsResource, loadScript, createThreedsModal, closeThreedsModal, setError, setIsLoading, hookOptionsRef]);
+    return { handleMasterCardAuth };
+}

package/dist/v2/react/hooks/payment-actions/usePaymentActionHandler.d.ts

@@ -0,0 +1,15 @@
+import type { Payment, PaymentOptions } from '../../../core/resources/payments';
+import type { PaymentsResource } from '../../../core/resources/payments';
+import type { UsePaymentOptions } from '../usePaymentQuery';
+interface UsePaymentActionHandlerParams {
+    paymentsResource: PaymentsResource;
+    startChallenge: any;
+    startPolling: any;
+    setIsLoading: (loading: boolean) => void;
+    setError: (error: string | null) => void;
+    hookOptionsRef: React.MutableRefObject<UsePaymentOptions | undefined>;
+}
+export declare function usePaymentActionHandler({ paymentsResource, startChallenge, startPolling, setIsLoading, setError, hookOptionsRef, }: UsePaymentActionHandlerParams): {
+    handlePaymentAction: (payment: Payment, options?: PaymentOptions) => Promise<void>;
+};
+export {};