@tagadapay/plugin-sdk 2.4.38 → 2.5.0

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

@@ -0,0 +1,353 @@
+/**
+ * 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 { OffersResource } from '../../core/resources/offers';
+import { useTagadaContext } from '../providers/TagadaProvider';
+import { usePluginConfig } from './usePluginConfig';
+import { getGlobalApiClient } from './useApiQuery';
+export function useOffersQuery(options = {}) {
+    const { offerIds = [], enabled = true, returnUrl } = options;
+    const { storeId } = usePluginConfig();
+    const { isSessionInitialized, session } = useTagadaContext();
+    const _queryClient = useQueryClient();
+    // State for checkout sessions per offer (similar to postPurchases)
+    const [checkoutSessions, setCheckoutSessions] = useState({});
+    // Create offers resource client
+    const offersResource = useMemo(() => {
+        try {
+            return new OffersResource(getGlobalApiClient());
+        }
+        catch (error) {
+            throw new Error('Failed to initialize offers resource: ' + (error instanceof Error ? error.message : 'Unknown error'));
+        }
+    }, []);
+    // Helper function for fetching order summary (similar to postPurchases)
+    const fetchOrderSummary = useCallback(async (offerId, sessionId) => {
+        try {
+            // Set updating state
+            setCheckoutSessions(prev => ({
+                ...prev,
+                [offerId]: {
+                    ...prev[offerId],
+                    isUpdatingSummary: true,
+                }
+            }));
+            const summaryResult = await offersResource.getOrderSummary(sessionId, true);
+            if (summaryResult) {
+                // Sort items by productId to ensure consistent order
+                const sortedItems = [...summaryResult.items].sort((a, b) => a.productId.localeCompare(b.productId));
+                const orderSummary = {
+                    ...summaryResult,
+                    items: sortedItems,
+                };
+                // Initialize selected variants based on the summary
+                const initialVariants = {};
+                sortedItems.forEach((item) => {
+                    if (item.productId && item.variantId) {
+                        initialVariants[item.productId] = item.variantId;
+                    }
+                });
+                setCheckoutSessions(prev => ({
+                    ...prev,
+                    [offerId]: {
+                        ...prev[offerId],
+                        orderSummary,
+                        selectedVariants: initialVariants,
+                        isUpdatingSummary: false,
+                    }
+                }));
+            }
+        }
+        catch (error) {
+            console.error(`[SDK] Failed to fetch order summary for offer ${offerId}:`, error);
+            setCheckoutSessions(prev => ({
+                ...prev,
+                [offerId]: {
+                    ...prev[offerId],
+                    isUpdatingSummary: false,
+                }
+            }));
+            throw error;
+        }
+    }, [offersResource]);
+    // 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({
+        queryKey,
+        enabled: enabled && !!storeId && isSessionInitialized,
+        queryFn: async () => {
+            if (!storeId) {
+                throw new Error('Store ID not found. Make sure the TagadaProvider is properly configured.');
+            }
+            if (offerIds.length > 0) {
+                // Fetch specific offers by IDs
+                return await offersResource.getOffersByIds(storeId, offerIds);
+            }
+            else {
+                // Fetch all offers for the store
+                return await offersResource.getOffers(storeId);
+            }
+        },
+        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) => {
+            console.error('Failed to create checkout session:', error);
+        },
+    });
+    const payOfferMutation = useMutation({
+        mutationFn: async ({ offerId, orderId }) => {
+            return await offersResource.payOffer(offerId, orderId);
+        },
+        onError: (error) => {
+            console.error('Failed to pay offer:', error);
+        },
+    });
+    const transformToCheckoutMutation = useMutation({
+        mutationFn: async ({ offerId, returnUrl }) => {
+            return await offersResource.transformToCheckout(offerId, returnUrl);
+        },
+        onError: (error) => {
+            console.error('Failed to transform offer to checkout:', error);
+        },
+    });
+    const payWithCheckoutSessionMutation = useMutation({
+        mutationFn: async ({ checkoutSessionId, orderId }) => {
+            return await offersResource.payWithCheckoutSession(checkoutSessionId, orderId);
+        },
+        onError: (error) => {
+            console.error('Failed to pay with checkout session:', error);
+        },
+    });
+    const initCheckoutSessionMutation = useMutation({
+        mutationFn: async ({ offerId, orderId, customerId }) => {
+            return await offersResource.initCheckoutSession(offerId, orderId, customerId);
+        },
+        onError: (error) => {
+            console.error('Failed to initialize checkout session:', error);
+        },
+    });
+    // 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]);
+    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({
+            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) => {
+            try {
+                // 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');
+                }
+                // 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 order summary with variant options
+                await fetchOrderSummary(offerId, sessionId);
+            }
+            catch (error) {
+                console.error(`[SDK] Failed to initialize checkout for offer ${offerId}:`, error);
+                throw error;
+            }
+        },
+        getAvailableVariants: (offerId, productId) => {
+            const sessionState = checkoutSessions[offerId];
+            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,
+            }));
+        },
+        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 sessionId = sessionState.checkoutSessionId;
+            // Set loading state for this specific variant
+            setCheckoutSessions(prev => ({
+                ...prev,
+                [offerId]: {
+                    ...prev[offerId],
+                    loadingVariants: {
+                        ...prev[offerId].loadingVariants,
+                        [productId]: true,
+                    }
+                }
+            }));
+            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);
+            }
+            catch (error) {
+                console.error(`[SDK] Failed to update variant for offer ${offerId}:`, error);
+                throw error;
+            }
+            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);
+        },
+    };
+}

package/dist/v2/react/hooks/useOrderBumpQuery.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Order Bump Hook using TanStack Query
+ * Replaces coordinator pattern with automatic cache invalidation
+ */
+export interface UseOrderBumpQueryOptions {
+    checkoutToken: string | null;
+    offerId: string;
+    productId?: string;
+    checkout?: any;
+}
+export interface UseOrderBumpQueryResult {
+    isSelected: boolean;
+    isToggling: boolean;
+    error: Error | null;
+    toggle: (selected?: boolean) => Promise<{
+        success: boolean;
+        error?: any;
+    }>;
+}
+export declare function useOrderBumpQuery(options: UseOrderBumpQueryOptions): UseOrderBumpQueryResult;

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

@@ -0,0 +1,88 @@
+/**
+ * Order Bump Hook using TanStack Query
+ * Replaces coordinator pattern with automatic cache invalidation
+ */
+import { useState, useCallback, useEffect } from 'react';
+import { useApiMutation, useInvalidateQuery, getGlobalApiClient } from './useApiQuery';
+import { useCheckoutQuery } from './useCheckoutQuery';
+export function useOrderBumpQuery(options) {
+    const { checkoutToken, offerId, productId, checkout: providedCheckout } = options;
+    const { invalidateCheckout, invalidatePromotions } = useInvalidateQuery();
+    const client = getGlobalApiClient();
+    // Use checkout query only if no checkout is provided
+    const { checkout: loadedCheckout } = useCheckoutQuery({
+        checkoutToken: checkoutToken || undefined,
+        enabled: !providedCheckout && !!checkoutToken,
+    });
+    // Use provided checkout or loaded checkout
+    const checkout = providedCheckout || loadedCheckout;
+    // Function to check if order bump is selected
+    const checkOrderBumpSelection = useCallback(() => {
+        if (!checkout?.checkoutSession?.sessionLineItems) {
+            return false;
+        }
+        const targetProductId = productId || offerId;
+        return checkout.checkoutSession.sessionLineItems.some((item) => {
+            return item.isOrderBump === true && item.productId === targetProductId;
+        });
+    }, [checkout?.checkoutSession?.sessionLineItems, offerId, productId]);
+    // State management
+    const [isSelected, setIsSelected] = useState(() => checkOrderBumpSelection());
+    const [error, setError] = useState(null);
+    // Update state when checkout session changes
+    useEffect(() => {
+        const isSelectedFromSession = checkOrderBumpSelection();
+        setIsSelected(isSelectedFromSession);
+    }, [checkOrderBumpSelection]);
+    // Order bump toggle mutation
+    const toggleMutation = useApiMutation(async ({ selected }) => {
+        if (!checkout?.checkoutSession?.id) {
+            throw new Error('No checkout session available');
+        }
+        return client.post(`/api/v1/checkout-sessions/${checkout.checkoutSession.id}/toggle-order-bump`, {
+            orderBumpOfferId: offerId,
+            selected,
+        });
+    }, {
+        onMutate: async ({ selected }) => {
+            // Optimistic update
+            setIsSelected(selected);
+            setError(null);
+        },
+        onSuccess: () => {
+            // Invalidate related queries
+            if (checkoutToken) {
+                invalidateCheckout(checkoutToken);
+            }
+            if (checkout?.checkoutSession?.id) {
+                invalidatePromotions(checkout.checkoutSession.id);
+            }
+        },
+        onError: (err, { selected }) => {
+            // Revert optimistic update on error
+            setIsSelected(!selected);
+            setError(err instanceof Error ? err : new Error('Failed to toggle order bump'));
+        },
+    });
+    const toggle = useCallback(async (selected) => {
+        if (!checkout?.checkoutSession?.id) {
+            console.warn('useOrderBumpQuery: No checkout session available yet');
+            return { success: false, error: 'Checkout session not ready' };
+        }
+        const targetState = selected ?? !isSelected;
+        try {
+            const result = await toggleMutation.mutateAsync({ selected: targetState });
+            return { success: true };
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error('Failed to toggle order bump');
+            return { success: false, error: error.message };
+        }
+    }, [checkout?.checkoutSession?.id, isSelected, toggleMutation]);
+    return {
+        isSelected,
+        isToggling: toggleMutation.isPending,
+        error,
+        toggle,
+    };
+}

package/dist/v2/react/hooks/useOrderQuery.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Order Hook using TanStack Query
+ * Handles order creation and management with automatic caching
+ */
+import { Order, OrderLineItem } from '../../core/utils/order';
+export interface UseOrderQueryOptions {
+    orderId?: string;
+    enabled?: boolean;
+}
+export interface UseOrderQueryResult {
+    order: Order | undefined;
+    isLoading: boolean;
+    error: Error | null;
+    createOrder: (checkoutSessionId: string) => Promise<{
+        success: boolean;
+        order?: Order;
+        error?: string;
+    }>;
+    updateOrderStatus: (status: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    addOrderItems: (items: Omit<OrderLineItem, 'id'>[]) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    refresh: () => void;
+}
+export declare function useOrderQuery(options?: UseOrderQueryOptions): UseOrderQueryResult;

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

@@ -0,0 +1,98 @@
+/**
+ * Order Hook using TanStack Query
+ * Handles order creation and management with automatic caching
+ */
+import { useMemo } from 'react';
+import { useQuery, useMutation } from '@tanstack/react-query';
+import { OrdersResource } from '../../core/resources/orders';
+import { getGlobalApiClient } from './useApiQuery';
+export function useOrderQuery(options = {}) {
+    const { orderId, enabled = true } = options;
+    // Create orders resource client
+    const ordersResource = useMemo(() => {
+        try {
+            return new OrdersResource(getGlobalApiClient());
+        }
+        catch (error) {
+            throw new Error('Failed to initialize orders resource: ' + (error instanceof Error ? error.message : 'Unknown error'));
+        }
+    }, []);
+    // Main order query
+    const { data: order, isLoading, error, refetch, } = useQuery({
+        queryKey: ['order', orderId],
+        queryFn: () => ordersResource.getOrder(orderId),
+        enabled: enabled && !!orderId,
+        staleTime: 60000, // 1 minute
+        refetchOnWindowFocus: false,
+    });
+    // Create order mutation
+    const createMutation = useMutation({
+        mutationFn: ({ checkoutSessionId }) => {
+            return ordersResource.createOrder(checkoutSessionId);
+        },
+        onSuccess: () => {
+            // Order created successfully - no specific cache invalidation needed
+        },
+    });
+    // Update order status mutation
+    const updateStatusMutation = useMutation({
+        mutationFn: ({ status }) => {
+            if (!orderId) {
+                throw new Error('No order ID available');
+            }
+            return ordersResource.updateOrderStatus(orderId, status);
+        },
+        onSuccess: () => {
+            // Refetch order data
+            void refetch();
+        },
+    });
+    // Add order items mutation
+    const addItemsMutation = useMutation({
+        mutationFn: ({ items }) => {
+            if (!orderId) {
+                throw new Error('No order ID available');
+            }
+            return ordersResource.addOrderItems(orderId, items);
+        },
+        onSuccess: () => {
+            // Refetch order data
+            void refetch();
+        },
+    });
+    return {
+        // Query data
+        order,
+        isLoading,
+        error,
+        // Actions
+        createOrder: async (checkoutSessionId) => {
+            try {
+                return await createMutation.mutateAsync({ checkoutSessionId });
+            }
+            catch (err) {
+                const error = err instanceof Error ? err : new Error('Failed to create order');
+                return { success: false, error: error.message };
+            }
+        },
+        updateOrderStatus: async (status) => {
+            try {
+                return await updateStatusMutation.mutateAsync({ status });
+            }
+            catch (err) {
+                const error = err instanceof Error ? err : new Error('Failed to update order status');
+                return { success: false, error: error.message };
+            }
+        },
+        addOrderItems: async (items) => {
+            try {
+                return await addItemsMutation.mutateAsync({ items });
+            }
+            catch (err) {
+                const error = err instanceof Error ? err : new Error('Failed to add order items');
+                return { success: false, error: error.message };
+            }
+        },
+        refresh: () => void refetch(),
+    };
+}

package/dist/v2/react/hooks/usePaymentPolling.d.ts

@@ -0,0 +1,45 @@
+export interface Payment {
+    id: string;
+    status: string;
+    subStatus: string;
+    requireAction: 'none' | 'redirect' | 'error';
+    requireActionData?: {
+        type: 'redirect' | 'threeds_auth' | 'processor_auth' | 'error';
+        url?: string;
+        processed: boolean;
+        processorId?: string;
+        metadata?: {
+            type: 'redirect';
+            redirect?: {
+                redirectUrl: string;
+                returnUrl: string;
+            };
+            threedsSession?: {
+                externalSessionId: string;
+                acsChallengeUrl: string;
+                acsTransID: string;
+                messageVersion: string;
+            };
+        };
+        redirectUrl?: string;
+        resumeToken?: string;
+        message?: string;
+        errorCode?: string;
+    };
+}
+export interface PollingOptions {
+    onRequireAction?: (payment: Payment, stop: () => void) => void;
+    onSuccess?: (payment: Payment) => void;
+    onFailure?: (error: string) => void;
+    maxAttempts?: number;
+    pollInterval?: number;
+}
+export interface PaymentPollingHook {
+    startPolling: (paymentId: string, options?: PollingOptions) => {
+        stop: () => void;
+        isPolling: () => boolean;
+    };
+    stopPolling: () => void;
+    isPolling: () => boolean;
+}
+export declare function usePaymentPolling(): PaymentPollingHook;