@tagadapay/plugin-sdk 3.1.5 → 3.1.8

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

@@ -1,247 +0,0 @@
-/**
- * Apple Pay Hook for v2 Architecture
- * Handles Apple Pay payment flow with Basis Theory integration
- */
-import { useState, useCallback, useEffect } from 'react';
-import { getBasisTheoryApiKey } from '../../../react/config/payment';
-import { minorUnitsToMajorUnits, getCurrencyInfo } from '../../../react/utils/money';
-import { useCheckoutQuery } from './useCheckoutQuery';
-import { usePaymentQuery } from './usePaymentQuery';
-import { PaymentsResource } from '../../core/resources/payments';
-import { OrdersResource } from '../../core/resources/orders';
-import { getGlobalApiClient } from './useApiQuery';
-export function useApplePay(options = {}) {
-    const [processingPayment, setProcessingPayment] = useState(false);
-    const [error, setError] = useState(null);
-    const [isAvailable, setIsAvailable] = useState(false);
-    const { checkout } = useCheckoutQuery();
-    const { createApplePayPaymentInstrument } = usePaymentQuery();
-    const checkoutSessionId = checkout?.checkoutSession?.id;
-    const store = checkout?.checkoutSession?.store;
-    const summary = checkout?.summary;
-    const basistheoryPublicKey = getBasisTheoryApiKey();
-    // Create SDK resource clients
-    const paymentsResource = new PaymentsResource(getGlobalApiClient());
-    const ordersResource = new OrdersResource(getGlobalApiClient());
-    // Helper to convert minor units to currency string for Apple Pay
-    const minorUnitsToCurrencyString = useCallback((amountMinor, currency) => {
-        if (!amountMinor || !currency)
-            return '0.00';
-        const currencyInfo = getCurrencyInfo(currency);
-        if (!currencyInfo) {
-            console.warn(`Currency info not found for ${currency}, using fallback`);
-            return (amountMinor / 100).toFixed(2);
-        }
-        const majorUnits = minorUnitsToMajorUnits(amountMinor, currency);
-        return majorUnits.toFixed(currencyInfo.ISOdigits);
-    }, []);
-    // Check Apple Pay availability on mount
-    useEffect(() => {
-        const checkApplePayAvailability = () => {
-            if (typeof window === 'undefined' || !window.ApplePaySession) {
-                setIsAvailable(false);
-                return;
-            }
-            try {
-                const canMakePayments = window.ApplePaySession.canMakePayments();
-                setIsAvailable(canMakePayments);
-            }
-            catch (error) {
-                console.error('Error checking Apple Pay availability:', error);
-                setIsAvailable(false);
-            }
-        };
-        checkApplePayAvailability();
-    }, []);
-    // Validate merchant with Basis Theory
-    const validateMerchant = useCallback(async () => {
-        try {
-            const response = await fetch('https://api.basistheory.com/apple-pay/session', {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'BT-API-KEY': basistheoryPublicKey,
-                },
-                body: JSON.stringify({
-                    display_name: store?.name || 'Store',
-                    domain: window.location.host,
-                }),
-            });
-            if (!response.ok) {
-                throw new Error(`HTTP error! Status: ${response.status}`);
-            }
-            return response.json();
-        }
-        catch (err) {
-            console.error('Merchant validation failed:', err);
-            throw err;
-        }
-    }, [basistheoryPublicKey, store?.name]);
-    // Tokenize Apple Pay payment with Basis Theory
-    const tokenizeApplePay = useCallback(async (event) => {
-        try {
-            const response = await fetch('https://api.basistheory.com/apple-pay', {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    'BT-API-KEY': basistheoryPublicKey,
-                },
-                body: JSON.stringify({
-                    apple_payment_data: event.payment.token,
-                }),
-            });
-            if (!response.ok) {
-                setError('Payment Failed');
-                throw new Error(`HTTP error! Status: ${response.status}`);
-            }
-            const result = await response.json();
-            return result.apple_pay; // Basis Theory returns the Apple Pay token in the apple_pay field
-        }
-        catch (error) {
-            console.error('Tokenization failed:', error);
-            throw error;
-        }
-    }, [basistheoryPublicKey]);
-    // Charge payment using SDK methods
-    const chargePayment = useCallback(async (applePayToken) => {
-        if (!checkoutSessionId) {
-            throw new Error('Checkout session ID not available');
-        }
-        setProcessingPayment(true);
-        try {
-            // 1. Tokenize with Basis Theory (already done - we have applePayToken)
-            // 2. Create payment instrument from the tokenized Apple Pay payment
-            const paymentInstrumentData = {
-                type: 'apple_pay',
-                token: applePayToken.id,
-                dpanType: applePayToken.type,
-                card: {
-                    bin: applePayToken.card.bin,
-                    last4: applePayToken.card.last4,
-                    expirationMonth: applePayToken.card.expiration_month,
-                    expirationYear: applePayToken.card.expiration_year,
-                    brand: applePayToken.card.brand,
-                },
-            };
-            const paymentInstrument = await paymentsResource.createPaymentInstrument(paymentInstrumentData);
-            if (!paymentInstrument?.id) {
-                throw new Error('Failed to create payment instrument');
-            }
-            // 3. Create order from checkout session
-            const orderResponse = await ordersResource.createOrder(checkoutSessionId);
-            if (!orderResponse?.success || !orderResponse?.order?.id) {
-                throw new Error('Failed to create order');
-            }
-            // 4. Process payment
-            const paymentResult = await paymentsResource.processPaymentDirect(checkoutSessionId, paymentInstrument.id, undefined, {
-                initiatedBy: 'customer',
-                source: 'checkout',
-            });
-            if (options.onSuccess) {
-                options.onSuccess(paymentResult);
-            }
-            return paymentResult;
-        }
-        catch (error) {
-            console.error('Payment failed:', error);
-            const errorMessage = error instanceof Error ? error.message : 'Payment Failed';
-            setError(errorMessage);
-            if (options.onError) {
-                options.onError(errorMessage);
-            }
-            throw error;
-        }
-        finally {
-            setProcessingPayment(false);
-        }
-    }, [checkoutSessionId, paymentsResource, ordersResource, options]);
-    // Handle Apple Pay button click - opens Apple Pay sheet
-    const handleApplePayClick = useCallback(() => {
-        if (!summary || !store) {
-            console.error('Order summary or store not available');
-            return;
-        }
-        const total = {
-            label: store.name || 'Store',
-            amount: minorUnitsToCurrencyString(summary.totalAdjustedAmount, summary.currency),
-            type: 'final',
-        };
-        const lineItems = [
-            {
-                label: 'Subtotal',
-                amount: minorUnitsToCurrencyString(summary.subtotalAdjustedAmount, summary.currency),
-                type: 'final',
-            },
-            {
-                label: 'Shipping',
-                amount: minorUnitsToCurrencyString(summary.shippingCost ?? 0, summary.currency),
-                type: 'final',
-            },
-            {
-                label: 'Tax',
-                amount: minorUnitsToCurrencyString(summary.totalTaxAmount, summary.currency),
-                type: 'final',
-            },
-        ];
-        const request = {
-            countryCode: 'US', // TODO: Get from checkout session metadata
-            currencyCode: summary.currency,
-            supportedNetworks: ['visa', 'masterCard', 'amex', 'discover'],
-            merchantCapabilities: ['supports3DS'],
-            total,
-            lineItems,
-        };
-        try {
-            const session = new ApplePaySession(3, request);
-            session.onvalidatemerchant = (event) => {
-                void (async () => {
-                    try {
-                        console.log('Merchant validation requested for:', event.validationURL);
-                        const merchantSession = await validateMerchant();
-                        session.completeMerchantValidation(merchantSession);
-                    }
-                    catch (error) {
-                        console.error('Merchant validation failed:', error);
-                        session.abort();
-                    }
-                })();
-            };
-            session.onpaymentauthorized = (event) => {
-                void (async () => {
-                    try {
-                        const applePayToken = await tokenizeApplePay(event);
-                        session.completePayment(ApplePaySession.STATUS_SUCCESS);
-                        await chargePayment(applePayToken);
-                    }
-                    catch (error) {
-                        console.error('Payment processing failed:', error);
-                        session.completePayment(ApplePaySession.STATUS_FAILURE);
-                    }
-                })();
-            };
-            session.onerror = (event) => {
-                console.error('Apple Pay Session Error:', event);
-            };
-            session.oncancel = () => {
-                console.log('Payment cancelled by user');
-                if (options.onCancel) {
-                    options.onCancel();
-                }
-            };
-            session.begin();
-        }
-        catch (error) {
-            console.error('Failed to start Apple Pay session:', error);
-            setError('Failed to start Apple Pay session');
-            if (options.onError) {
-                options.onError('Failed to start Apple Pay session');
-            }
-        }
-    }, [summary, store, minorUnitsToCurrencyString, validateMerchant, tokenizeApplePay, chargePayment, options]);
-    return {
-        handleApplePayClick,
-        processingPayment,
-        applePayError: error,
-        isAvailable,
-    };
-}