@tagadapay/plugin-sdk 2.8.8 → 2.8.9

package/dist/v2/react/hooks/useOffersQuery.js

@@ -2,19 +2,23 @@
  * Offers Hook using TanStack Query
  * Handles offers with automatic caching
  */
-import { useMemo, useCallback, useState } from 'react';
-import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import { useCallback, useMemo, useRef, useState } from 'react';
 import { OffersResource } from '../../core/resources/offers';
 import { useTagadaContext } from '../providers/TagadaProvider';
-import { usePluginConfig } from './usePluginConfig';
 import { getGlobalApiClient } from './useApiQuery';
+import { usePluginConfig } from './usePluginConfig';
 export function useOffersQuery(options = {}) {
-    const { offerIds = [], enabled = true, returnUrl } = options;
+    const { offerIds = [], enabled = true, returnUrl, orderId: defaultOrderId } = options;
     const { storeId } = usePluginConfig();
     const { isSessionInitialized, session } = useTagadaContext();
     const _queryClient = useQueryClient();
     // State for checkout sessions per offer (similar to postPurchases)
     const [checkoutSessions, setCheckoutSessions] = useState({});
+    // Use ref to break dependency cycles in callbacks
+    const checkoutSessionsRef = useRef(checkoutSessions);
+    // Update ref on every render
+    checkoutSessionsRef.current = checkoutSessions;
     // Create offers resource client
     const offersResource = useMemo(() => {
         try {
@@ -59,7 +63,9 @@ export function useOffersQuery(options = {}) {
                         isUpdatingSummary: false,
                     }
                 }));
+                return orderSummary;
             }
+            return null;
         }
         catch (error) {
             setCheckoutSessions(prev => ({
@@ -75,7 +81,7 @@ export function useOffersQuery(options = {}) {
     // Create query key based on options
     const queryKey = useMemo(() => ['offers', { storeId, offerIds }], [storeId, offerIds]);
     // Use TanStack Query for fetching offers
-    const { data: offers = [], isLoading, error, refetch } = useQuery({
+    const { data: offers = [], isLoading, error } = useQuery({
         queryKey,
         enabled: enabled && !!storeId && isSessionInitialized,
         queryFn: async () => {
@@ -94,32 +100,7 @@ export function useOffersQuery(options = {}) {
         staleTime: 5 * 60 * 1000, // 5 minutes
         refetchOnWindowFocus: false,
     });
-    // Mutations for offer actions
-    const createCheckoutSessionMutation = useMutation({
-        mutationFn: async ({ offerId, returnUrl }) => {
-            return await offersResource.createCheckoutSession(offerId, returnUrl);
-        },
-        onError: (_error) => {
-            // Error handling removed
-        },
-    });
-    const payOfferMutation = useMutation({
-        mutationFn: async ({ offerId, orderId }) => {
-            return await offersResource.payOffer(offerId, orderId);
-        },
-        onError: (_error) => {
-            // Error handling removed
-        },
-    });
-    const transformToCheckoutMutation = useMutation({
-        mutationFn: async ({ offerId, returnUrl }) => {
-            return await offersResource.transformToCheckout(offerId, returnUrl);
-        },
-        onError: (_error) => {
-            // Error handling removed
-        },
-    });
-    const payWithCheckoutSessionMutation = useMutation({
+    const { mutateAsync: payWithCheckoutSessionAsync } = useMutation({
         mutationFn: async ({ checkoutSessionId, orderId }) => {
             return await offersResource.payWithCheckoutSession(checkoutSessionId, orderId);
         },
@@ -127,7 +108,7 @@ export function useOffersQuery(options = {}) {
             // Error handling removed
         },
     });
-    const initCheckoutSessionMutation = useMutation({
+    const { mutateAsync: initCheckoutSessionAsync } = useMutation({
         mutationFn: async ({ offerId, orderId, customerId }) => {
             return await offersResource.initCheckoutSession(offerId, orderId, customerId);
         },
@@ -135,108 +116,125 @@ export function useOffersQuery(options = {}) {
             // Error handling removed
         },
     });
-    // Helper functions (matching V1 useOffers exactly)
-    const getOffer = useCallback((offerId) => {
-        return offers.find((offer) => offer.id === offerId);
-    }, [offers]);
-    const getTotalValue = useCallback(() => {
-        return offers.reduce((total, offer) => {
-            const firstSummary = offer.summaries[0];
-            return total + (firstSummary?.totalAdjustedAmount || 0);
-        }, 0);
-    }, [offers]);
-    const getTotalSavings = useCallback(() => {
-        return offers.reduce((total, offer) => {
-            const firstSummary = offer.summaries[0];
-            return total + (firstSummary?.totalPromotionAmount || 0);
-        }, 0);
-    }, [offers]);
-    // Action functions
-    const createCheckoutSession = useCallback(async (offerId, options) => {
-        return await createCheckoutSessionMutation.mutateAsync({
-            offerId,
-            returnUrl: options?.returnUrl || returnUrl,
-        });
-    }, [createCheckoutSessionMutation, returnUrl]);
-    const payOffer = useCallback(async (offerId, orderId) => {
-        return await payOfferMutation.mutateAsync({ offerId, orderId });
-    }, [payOfferMutation]);
-    const transformToCheckout = useCallback(async (offerId, options) => {
-        return await transformToCheckoutMutation.mutateAsync({
-            offerId,
-            returnUrl: options?.returnUrl || returnUrl,
-        });
-    }, [transformToCheckoutMutation, returnUrl]);
     const payWithCheckoutSession = useCallback(async (checkoutSessionId, orderId) => {
-        return await payWithCheckoutSessionMutation.mutateAsync({ checkoutSessionId, orderId });
-    }, [payWithCheckoutSessionMutation]);
+        return await payWithCheckoutSessionAsync({ checkoutSessionId, orderId });
+    }, [payWithCheckoutSessionAsync]);
     const initCheckoutSession = useCallback(async (offerId, orderId, customerId) => {
         // Use customerId from session context if not provided
         const effectiveCustomerId = customerId || session?.customerId;
         if (!effectiveCustomerId) {
             throw new Error('Customer ID is required. Make sure the session is properly initialized.');
         }
-        return await initCheckoutSessionMutation.mutateAsync({
+        return await initCheckoutSessionAsync({
             offerId,
             orderId,
             customerId: effectiveCustomerId
         });
-    }, [initCheckoutSessionMutation, session?.customerId]);
-    return {
-        // Query data
-        offers,
-        isLoading,
-        error,
-        // Actions
-        refetch: async () => {
-            await refetch();
-        },
-        // Offer management
-        createCheckoutSession,
-        payOffer,
-        transformToCheckout,
-        // Helper functions
-        getOffer,
-        getTotalValue,
-        getTotalSavings,
-        // Payment functions
-        payWithCheckoutSession,
-        initCheckoutSession,
-        // Checkout session management (similar to postPurchases)
-        getCheckoutSessionState: (offerId) => {
-            return checkoutSessions[offerId] || null;
-        },
-        initializeOfferCheckout: async (offerId) => {
-            // Check if customer ID is available
-            if (!session?.customerId) {
-                throw new Error('Customer ID is required. Make sure the session is properly initialized.');
-            }
-            // Initialize checkout session using transformToCheckout
-            const initResult = await offersResource.transformToCheckout(offerId, returnUrl);
-            if (!initResult.checkoutUrl) {
-                throw new Error('Failed to initialize checkout session');
+    }, [initCheckoutSessionAsync, session?.customerId]);
+    const payOffer = useCallback(async (offerId, orderId) => {
+        const effectiveOrderId = orderId || defaultOrderId;
+        const effectiveCustomerId = session?.customerId;
+        if (!effectiveOrderId) {
+            throw new Error('Order ID is required for payment. Please provide it in the hook options or the function call.');
+        }
+        if (!effectiveCustomerId) {
+            throw new Error('Customer ID is required. Make sure the session is properly initialized.');
+        }
+        // 1. Init session
+        const { checkoutSessionId } = await initCheckoutSession(offerId, effectiveOrderId, effectiveCustomerId);
+        // 2. Pay
+        await payWithCheckoutSession(checkoutSessionId, effectiveOrderId);
+    }, [initCheckoutSession, payWithCheckoutSession, defaultOrderId, session?.customerId]);
+    const preview = useCallback(async (offerId) => {
+        const effectiveOrderId = defaultOrderId;
+        const effectiveCustomerId = session?.customerId;
+        // Use ref to check current state without creating dependency
+        const currentSessions = checkoutSessionsRef.current;
+        // If we already have a summary in state, return it
+        if (currentSessions[offerId]?.orderSummary) {
+            return currentSessions[offerId].orderSummary;
+        }
+        // Prevent duplicate initialization if already has a session and is updating
+        if (currentSessions[offerId]?.checkoutSessionId && currentSessions[offerId]?.isUpdatingSummary) {
+            return null;
+        }
+        // If we don't have orderId, fallback to static summary from offer object
+        // as we can't initialize a checkout session properly without orderId (for upsells)
+        if (!effectiveOrderId || !effectiveCustomerId) {
+            const offer = offers.find(o => o.id === offerId);
+            return offer?.summaries?.[0] || null;
+        }
+        try {
+            // If we already have a session ID, reuse it instead of creating a new one
+            let sessionId = currentSessions[offerId]?.checkoutSessionId;
+            if (!sessionId) {
+                const { checkoutSessionId } = await initCheckoutSession(offerId, effectiveOrderId, effectiveCustomerId);
+                sessionId = checkoutSessionId;
+                // Update state with session ID
+                setCheckoutSessions(prev => ({
+                    ...prev,
+                    [offerId]: {
+                        checkoutSessionId: sessionId,
+                        orderSummary: null,
+                        selectedVariants: {},
+                        loadingVariants: {},
+                        isUpdatingSummary: false,
+                    }
+                }));
             }
-            // Extract session ID from checkout URL or use a placeholder
-            const sessionId = 'session_' + offerId; // This would need to be extracted from the actual response
-            // Initialize session state
-            setCheckoutSessions(prev => ({
-                ...prev,
-                [offerId]: {
-                    checkoutSessionId: sessionId,
-                    orderSummary: null,
-                    selectedVariants: {},
-                    loadingVariants: {},
-                    isUpdatingSummary: false,
+            // Fetch and return summary
+            return await fetchOrderSummary(offerId, sessionId);
+        }
+        catch (e) {
+            console.error("Failed to preview offer", e);
+            return null;
+        }
+    }, [offers, defaultOrderId, session?.customerId, initCheckoutSession, fetchOrderSummary]); // Removed checkoutSessions dependency
+    const getAvailableVariants = useCallback((offerId, productId) => {
+        const sessionState = checkoutSessions[offerId]; // This hook needs to react to state changes
+        if (!sessionState?.orderSummary?.options?.[productId])
+            return [];
+        return sessionState.orderSummary.options[productId].map((variant) => ({
+            variantId: variant.id,
+            variantName: variant.name,
+            variantSku: variant.sku,
+            variantDefault: variant.default,
+            variantExternalId: variant.externalVariantId,
+            priceId: variant.prices[0]?.id,
+            currencyOptions: variant.prices[0]?.currencyOptions,
+        }));
+    }, [checkoutSessions]);
+    const isLoadingVariants = useCallback((offerId, productId) => {
+        return checkoutSessions[offerId]?.loadingVariants?.[productId] ?? false;
+    }, [checkoutSessions]);
+    const selectVariant = useCallback(async (offerId, productId, variantId) => {
+        // Use ref for initial check to avoid dependency but we might need latest state for logic
+        // Actually for actions it's better to use ref or just dependency if action is not called in useEffect
+        const currentSessions = checkoutSessionsRef.current;
+        const sessionState = currentSessions[offerId];
+        if (!sessionState?.checkoutSessionId || !sessionState.orderSummary) {
+            throw new Error('Checkout session not initialized for this offer');
+        }
+        const sessionId = sessionState.checkoutSessionId;
+        // Set loading state for this specific variant
+        setCheckoutSessions(prev => ({
+            ...prev,
+            [offerId]: {
+                ...prev[offerId],
+                loadingVariants: {
+                    ...prev[offerId].loadingVariants,
+                    [productId]: true,
                 }
-            }));
-            // Fetch order summary with variant options
-            await fetchOrderSummary(offerId, sessionId);
-        },
-        getAvailableVariants: (offerId, productId) => {
-            const sessionState = checkoutSessions[offerId];
-            if (!sessionState?.orderSummary?.options?.[productId])
-                return [];
-            return sessionState.orderSummary.options[productId].map((variant) => ({
+            }
+        }));
+        try {
+            // We need to use the state from the ref to ensure we have the latest data without causing infinite loops
+            // if selectVariant was in a dependency array that triggered effects
+            const sessionState = checkoutSessionsRef.current[offerId];
+            if (!sessionState?.orderSummary?.options?.[productId]) {
+                throw new Error('No variants available for this product');
+            }
+            const availableVariants = sessionState.orderSummary.options[productId].map((variant) => ({
                 variantId: variant.id,
                 variantName: variant.name,
                 variantSku: variant.sku,
@@ -245,98 +243,60 @@ export function useOffersQuery(options = {}) {
                 priceId: variant.prices[0]?.id,
                 currencyOptions: variant.prices[0]?.currencyOptions,
             }));
-        },
-        selectVariant: async (offerId, productId, variantId) => {
-            const sessionState = checkoutSessions[offerId];
-            if (!sessionState?.checkoutSessionId || !sessionState.orderSummary) {
-                throw new Error('Checkout session not initialized for this offer');
+            const selectedVariant = availableVariants.find(v => v.variantId === variantId);
+            if (!selectedVariant) {
+                throw new Error('Selected variant not found');
+            }
+            // Find the current item to get its quantity
+            const currentItem = sessionState.orderSummary.items.find(item => item.productId === productId);
+            if (!currentItem) {
+                throw new Error('Current item not found');
             }
-            const sessionId = sessionState.checkoutSessionId;
-            // Set loading state for this specific variant
+            // Update selected variants state
+            setCheckoutSessions(prev => ({
+                ...prev,
+                [offerId]: {
+                    ...prev[offerId],
+                    selectedVariants: {
+                        ...prev[offerId].selectedVariants,
+                        [productId]: variantId,
+                    }
+                }
+            }));
+            // Update line items on the server
+            await offersResource.updateLineItems(sessionId, [
+                {
+                    variantId: selectedVariant.variantId,
+                    quantity: currentItem.quantity,
+                },
+            ]);
+            // Refetch order summary after successful line item update
+            return await fetchOrderSummary(offerId, sessionId);
+        }
+        finally {
+            // Clear loading state for this specific variant
             setCheckoutSessions(prev => ({
                 ...prev,
                 [offerId]: {
                     ...prev[offerId],
                     loadingVariants: {
                         ...prev[offerId].loadingVariants,
-                        [productId]: true,
+                        [productId]: false,
                     }
                 }
             }));
-            try {
-                const sessionState = checkoutSessions[offerId];
-                if (!sessionState?.orderSummary?.options?.[productId]) {
-                    throw new Error('No variants available for this product');
-                }
-                const availableVariants = sessionState.orderSummary.options[productId].map((variant) => ({
-                    variantId: variant.id,
-                    variantName: variant.name,
-                    variantSku: variant.sku,
-                    variantDefault: variant.default,
-                    variantExternalId: variant.externalVariantId,
-                    priceId: variant.prices[0]?.id,
-                    currencyOptions: variant.prices[0]?.currencyOptions,
-                }));
-                const selectedVariant = availableVariants.find(v => v.variantId === variantId);
-                if (!selectedVariant) {
-                    throw new Error('Selected variant not found');
-                }
-                // Find the current item to get its quantity
-                const currentItem = sessionState.orderSummary.items.find(item => item.productId === productId);
-                if (!currentItem) {
-                    throw new Error('Current item not found');
-                }
-                // Update selected variants state
-                setCheckoutSessions(prev => ({
-                    ...prev,
-                    [offerId]: {
-                        ...prev[offerId],
-                        selectedVariants: {
-                            ...prev[offerId].selectedVariants,
-                            [productId]: variantId,
-                        }
-                    }
-                }));
-                // Update line items on the server
-                await offersResource.updateLineItems(sessionId, [
-                    {
-                        variantId: selectedVariant.variantId,
-                        quantity: currentItem.quantity,
-                    },
-                ]);
-                // Refetch order summary after successful line item update
-                await fetchOrderSummary(offerId, sessionId);
-            }
-            finally {
-                // Clear loading state for this specific variant
-                setCheckoutSessions(prev => ({
-                    ...prev,
-                    [offerId]: {
-                        ...prev[offerId],
-                        loadingVariants: {
-                            ...prev[offerId].loadingVariants,
-                            [productId]: false,
-                        }
-                    }
-                }));
-            }
-        },
-        getOrderSummary: (offerId) => {
-            return checkoutSessions[offerId]?.orderSummary ?? null;
-        },
-        isLoadingVariants: (offerId, productId) => {
-            return checkoutSessions[offerId]?.loadingVariants?.[productId] ?? false;
-        },
-        isUpdatingOrderSummary: (offerId) => {
-            return checkoutSessions[offerId]?.isUpdatingSummary || false;
-        },
-        confirmPurchase: async (offerId, _options) => {
-            const sessionState = checkoutSessions[offerId];
-            if (!sessionState?.checkoutSessionId) {
-                throw new Error('Checkout session not initialized for this offer');
-            }
-            // Use the enhanced payWithCheckoutSession with proper metadata
-            await offersResource.payWithCheckoutSession(sessionState.checkoutSessionId);
-        },
+        }
+    }, [offersResource, fetchOrderSummary]); // Removed checkoutSessions dependency
+    return {
+        // Query data
+        offers,
+        isLoading,
+        error,
+        // Actions
+        payOffer,
+        preview,
+        getAvailableVariants,
+        selectVariant,
+        isLoadingVariants,
     };
 }

package/dist/v2/react/hooks/usePaymentQuery.js

@@ -87,15 +87,28 @@ export function usePaymentQuery() {
                                 },
                                 onSuccess: (successPayment) => {
                                     setIsLoading(false);
-                                    options.onSuccess?.({
+                                    const response = {
                                         paymentId: successPayment.id,
                                         payment: successPayment,
-                                    });
+                                        // Extract order from payment if available (for funnel path resolution)
+                                        order: successPayment.order,
+                                    };
+                                    // Legacy callback (backwards compatibility)
+                                    options.onSuccess?.(response);
+                                    // Funnel-aligned callback (recommended)
+                                    options.onPaymentSuccess?.(response);
                                 },
                                 onFailure: (errorMsg) => {
                                     setError(errorMsg);
                                     setIsLoading(false);
+                                    // Legacy callback (backwards compatibility)
                                     options.onFailure?.(errorMsg);
+                                    // Funnel-aligned callback (recommended)
+                                    options.onPaymentFailed?.({
+                                        code: 'PAYMENT_FAILED',
+                                        message: errorMsg,
+                                        payment,
+                                    });
                                 },
                             });
                         }
@@ -105,22 +118,57 @@ export function usePaymentQuery() {
                         const errorMsg = _error instanceof Error ? _error.message : 'Failed to start 3DS challenge';
                         setError(errorMsg);
                         setIsLoading(false);
+                        // Legacy callback (backwards compatibility)
                         options.onFailure?.(errorMsg);
+                        // Funnel-aligned callback (recommended)
+                        options.onPaymentFailed?.({
+                            code: '3DS_CHALLENGE_FAILED',
+                            message: errorMsg,
+                            payment,
+                        });
                     }
                 }
                 break;
             case 'processor_auth':
             case 'redirect': {
-                if (actionData.metadata?.redirect?.redirectUrl) {
+                // Only auto-redirect if explicitly enabled (disableAutoRedirect: false)
+                // Default behavior: disable redirects and let funnel orchestrator handle navigation
+                const shouldRedirect = options.disableAutoRedirect === false;
+                if (shouldRedirect && actionData.metadata?.redirect?.redirectUrl) {
                     window.location.href = actionData.metadata.redirect.redirectUrl;
                 }
+                else {
+                    // If auto-redirect is disabled AND payment succeeded, call success callbacks
+                    // This allows funnel orchestrator to handle navigation
+                    if (payment.status === 'succeeded') {
+                        setIsLoading(false);
+                        const response = {
+                            paymentId: payment.id,
+                            payment,
+                            // Extract order from payment if available (for funnel path resolution)
+                            order: payment.order,
+                        };
+                        // Legacy callback (backwards compatibility)
+                        options.onSuccess?.(response);
+                        // Funnel-aligned callback (recommended)
+                        options.onPaymentSuccess?.(response);
+                    }
+                }
                 break;
             }
             case 'error': {
                 const errorMsg = actionData.message || 'Payment processing failed';
+                const errorCode = actionData.errorCode || 'PAYMENT_FAILED';
                 setError(errorMsg);
                 setIsLoading(false);
+                // Legacy callback (backwards compatibility)
                 options.onFailure?.(errorMsg);
+                // Funnel-aligned callback (recommended)
+                options.onPaymentFailed?.({
+                    code: errorCode,
+                    message: errorMsg,
+                    payment,
+                });
                 break;
             }
         }
@@ -147,7 +195,15 @@ export function usePaymentQuery() {
             }
             else if (response.payment.status === 'succeeded') {
                 setIsLoading(false);
-                options.onSuccess?.(response);
+                // Ensure order is at response root (extract from payment if needed)
+                const successResponse = {
+                    ...response,
+                    order: response.order || response.payment.order,
+                };
+                // Legacy callback (backwards compatibility)
+                options.onSuccess?.(successResponse);
+                // Funnel-aligned callback (recommended)
+                options.onPaymentSuccess?.(successResponse);
             }
             else {
                 // Start polling for payment status
@@ -157,15 +213,28 @@ export function usePaymentQuery() {
                     },
                     onSuccess: (payment) => {
                         setIsLoading(false);
-                        options.onSuccess?.({
+                        const successResponse = {
                             paymentId: payment.id,
                             payment,
-                        });
+                            // Extract order from payment if available (for funnel path resolution)
+                            order: payment.order,
+                        };
+                        // Legacy callback (backwards compatibility)
+                        options.onSuccess?.(successResponse);
+                        // Funnel-aligned callback (recommended)
+                        options.onPaymentSuccess?.(successResponse);
                     },
                     onFailure: (errorMsg) => {
                         setError(errorMsg);
                         setIsLoading(false);
+                        // Legacy callback (backwards compatibility)
                         options.onFailure?.(errorMsg);
+                        // Funnel-aligned callback (recommended)
+                        options.onPaymentFailed?.({
+                            code: 'PAYMENT_FAILED',
+                            message: errorMsg,
+                            payment: response.payment,
+                        });
                     },
                 });
             }
@@ -175,7 +244,13 @@ export function usePaymentQuery() {
             const errorMsg = _error instanceof Error ? _error.message : 'Payment failed';
             setError(errorMsg);
             setIsLoading(false);
+            // Legacy callback (backwards compatibility)
             options.onFailure?.(errorMsg);
+            // Funnel-aligned callback (recommended)
+            options.onPaymentFailed?.({
+                code: 'PAYMENT_PROCESSING_ERROR',
+                message: errorMsg,
+            });
             throw _error;
         }
     }, [paymentsResource, handlePaymentAction, startPolling]);
@@ -205,7 +280,13 @@ export function usePaymentQuery() {
             setIsLoading(false);
             const errorMsg = _error instanceof Error ? _error.message : 'Payment failed';
             setError(errorMsg);
+            // Legacy callback (backwards compatibility)
             options.onFailure?.(errorMsg);
+            // Funnel-aligned callback (recommended)
+            options.onPaymentFailed?.({
+                code: 'CARD_PAYMENT_ERROR',
+                message: errorMsg,
+            });
             throw _error;
         }
     }, [createCardPaymentInstrument, createSession, processPaymentDirect]);
@@ -223,7 +304,13 @@ export function usePaymentQuery() {
             setIsLoading(false);
             const errorMsg = _error instanceof Error ? _error.message : 'Apple Pay payment failed';
             setError(errorMsg);
+            // Legacy callback (backwards compatibility)
             options.onFailure?.(errorMsg);
+            // Funnel-aligned callback (recommended)
+            options.onPaymentFailed?.({
+                code: 'APPLE_PAY_ERROR',
+                message: errorMsg,
+            });
             throw _error;
         }
     }, [createApplePayPaymentInstrument, processPaymentDirect]);
@@ -238,7 +325,13 @@ export function usePaymentQuery() {
             setIsLoading(false);
             const errorMsg = _error instanceof Error ? _error.message : 'Payment failed';
             setError(errorMsg);
+            // Legacy callback (backwards compatibility)
             options.onFailure?.(errorMsg);
+            // Funnel-aligned callback (recommended)
+            options.onPaymentFailed?.({
+                code: 'PAYMENT_INSTRUMENT_ERROR',
+                message: errorMsg,
+            });
             throw _error;
         }
     }, [processPaymentDirect]);