@tagadapay/plugin-sdk 2.4.39 → 2.5.2

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

@@ -0,0 +1,343 @@
+/**
+ * Post Purchases Hook using TanStack Query
+ * Handles post-purchase offers with automatic caching
+ */
+import { useMemo, useEffect, useState, useCallback } from 'react';
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
+import { PostPurchasesResource } from '../../core/resources/postPurchases';
+import { useTagadaContext } from '../providers/TagadaProvider';
+import { getGlobalApiClient } from './useApiQuery';
+export function usePostPurchasesQuery(options) {
+    const { orderId, enabled = true, autoInitializeCheckout = false } = options;
+    const queryClient = useQueryClient();
+    const { session } = useTagadaContext();
+    // State for checkout sessions per offer
+    const [checkoutSessions, setCheckoutSessions] = useState({});
+    // Create post purchases resource client
+    const postPurchasesResource = useMemo(() => {
+        try {
+            return new PostPurchasesResource(getGlobalApiClient());
+        }
+        catch (error) {
+            throw new Error('Failed to initialize post purchases resource: ' + (error instanceof Error ? error.message : 'Unknown error'));
+        }
+    }, []);
+    // Helper function for fetching order summary - exact same as V1
+    const fetchOrderSummary = useCallback(async (offerId, sessionId) => {
+        try {
+            // Set updating state
+            setCheckoutSessions(prev => ({
+                ...prev,
+                [offerId]: {
+                    ...prev[offerId],
+                    isUpdatingSummary: true,
+                }
+            }));
+            const summaryResult = await postPurchasesResource.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) {
+            setCheckoutSessions(prev => ({
+                ...prev,
+                [offerId]: {
+                    ...prev[offerId],
+                    isUpdatingSummary: false,
+                }
+            }));
+            throw error;
+        }
+    }, [postPurchasesResource]);
+    // Main post-purchase offers query
+    const { data: offers = [], isLoading, error, refetch, } = useQuery({
+        queryKey: ['post-purchase-offers', orderId],
+        queryFn: () => postPurchasesResource.getPostPurchaseOffers(orderId),
+        enabled: enabled && !!orderId,
+        staleTime: 30000, // 30 seconds
+        refetchOnWindowFocus: false,
+    });
+    // Auto-initialize checkout sessions if enabled
+    useEffect(() => {
+        if (autoInitializeCheckout && offers.length > 0) {
+            // Initialize checkout sessions for all offers
+            offers.forEach((offer) => {
+                try {
+                    // This is a placeholder - in a full implementation, you'd call initializeOfferCheckout
+                }
+                catch (_error) {
+                    // Error handling removed
+                }
+            });
+        }
+    }, [autoInitializeCheckout, offers]);
+    // Accept offer mutation
+    const acceptMutation = useMutation({
+        mutationFn: ({ offerId, items }) => {
+            if (!orderId) {
+                throw new Error('No order ID available');
+            }
+            return postPurchasesResource.acceptOffer(orderId, offerId, items);
+        },
+        onSuccess: () => {
+            // Refresh offers and potentially checkout data
+            void refetch();
+            if (orderId) {
+                void queryClient.invalidateQueries({ queryKey: ['checkout', orderId] });
+            }
+        },
+    });
+    // Decline offer mutation
+    const declineMutation = useMutation({
+        mutationFn: ({ offerId }) => {
+            if (!orderId) {
+                throw new Error('No order ID available');
+            }
+            return postPurchasesResource.declineOffer(orderId, offerId);
+        },
+        onSuccess: () => {
+            // Refresh offers
+            void refetch();
+        },
+    });
+    // Preview offer mutation
+    const previewMutation = useMutation({
+        mutationFn: ({ offerId, items }) => {
+            if (!orderId) {
+                throw new Error('No order ID available');
+            }
+            return postPurchasesResource.previewOffer(orderId, offerId, items);
+        },
+        // No onSuccess needed for preview - it doesn't change state
+    });
+    return {
+        // Query data
+        offers,
+        isLoading,
+        error,
+        // Actions
+        acceptOffer: async (offerId, items) => {
+            try {
+                return await acceptMutation.mutateAsync({ offerId, items });
+            }
+            catch (err) {
+                const error = err instanceof Error ? err : new Error('Failed to accept offer');
+                return { success: false, error: error.message };
+            }
+        },
+        declineOffer: async (offerId) => {
+            try {
+                return await declineMutation.mutateAsync({ offerId });
+            }
+            catch (err) {
+                const error = err instanceof Error ? err : new Error('Failed to decline offer');
+                return { success: false, error: error.message };
+            }
+        },
+        previewOffer: async (offerId, items) => {
+            try {
+                return await previewMutation.mutateAsync({ offerId, items });
+            }
+            catch (err) {
+                const error = err instanceof Error ? err : new Error('Failed to preview offer');
+                return { success: false, error: error.message };
+            }
+        },
+        refresh: () => void refetch(),
+        // V1 compatibility methods
+        payWithCheckoutSession: async (checkoutSessionId, orderId) => {
+            await postPurchasesResource.payWithCheckoutSession(checkoutSessionId, orderId);
+        },
+        // Missing V1 methods implementations
+        initCheckoutSession: async (offerId, orderId) => {
+            // Check if customer ID is available
+            if (!session?.customerId) {
+                throw new Error('Customer ID is required. Make sure the session is properly initialized.');
+            }
+            return await postPurchasesResource.initCheckoutSession(offerId, orderId, session.customerId);
+        },
+        initCheckoutSessionWithVariants: async (offerId, orderId, lineItems) => {
+            return await postPurchasesResource.initCheckoutSessionWithVariants(offerId, orderId, lineItems);
+        },
+        getOffer: (offerId) => {
+            return offers.find(offer => offer.id === offerId);
+        },
+        getTotalValue: () => {
+            return offers.reduce((total, offer) => {
+                return total + offer.summaries.reduce((summaryTotal, summary) => {
+                    return summaryTotal + summary.totalAmount;
+                }, 0);
+            }, 0);
+        },
+        getTotalSavings: () => {
+            return offers.reduce((total, offer) => {
+                return total + offer.summaries.reduce((summaryTotal, summary) => {
+                    return summaryTotal + (summary.totalAmount - summary.totalAdjustedAmount);
+                }, 0);
+            }, 0);
+        },
+        // Checkout session management - exact same as V1
+        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
+                const initResult = await postPurchasesResource.initCheckoutSession(offerId, orderId, session.customerId);
+                if (!initResult.checkoutSessionId) {
+                    throw new Error('Failed to initialize checkout session');
+                }
+                const sessionId = initResult.checkoutSessionId;
+                // 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) {
+                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');
+            }
+            // 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 postPurchasesResource.updateLineItems(sessionState.checkoutSessionId, [
+                    {
+                        variantId: selectedVariant.variantId,
+                        quantity: currentItem.quantity,
+                    },
+                ]);
+                // Refetch order summary after successful line item update
+                await fetchOrderSummary(offerId, sessionState.checkoutSessionId);
+            }
+            catch (_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 postPurchasesResource.payWithCheckoutSession(sessionState.checkoutSessionId, orderId);
+        },
+    };
+}

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

@@ -0,0 +1,31 @@
+/**
+ * Products Hook using TanStack Query
+ * Replaces manual fetching with automatic caching
+ */
+import { Product, ProductVariant } from '../../core/resources/products';
+export interface UseProductsQueryOptions {
+    productIds?: string[];
+    enabled?: boolean;
+    includeVariants?: boolean;
+    includePrices?: boolean;
+}
+export interface UseProductsQueryResult {
+    products: Product[];
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+    getProduct: (productId: string) => Product | undefined;
+    getVariant: (variantId: string) => {
+        product: Product;
+        variant: ProductVariant;
+    } | undefined;
+    getAllVariants: () => {
+        product: Product;
+        variant: ProductVariant;
+    }[];
+    filterVariants: (predicate: (variant: ProductVariant, product: Product) => boolean) => {
+        product: Product;
+        variant: ProductVariant;
+    }[];
+}
+export declare function useProductsQuery(options?: UseProductsQueryOptions): UseProductsQueryResult;

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

@@ -0,0 +1,102 @@
+/**
+ * Products Hook using TanStack Query
+ * Replaces manual fetching with automatic caching
+ */
+import { useMemo, useCallback } from 'react';
+import { useQuery } from '@tanstack/react-query';
+import { ProductsResource } from '../../core/resources/products';
+import { useTagadaContext } from '../providers/TagadaProvider';
+import { usePluginConfig } from './usePluginConfig';
+import { getGlobalApiClient } from './useApiQuery';
+export function useProductsQuery(options = {}) {
+    const { productIds = [], enabled = true, includeVariants = true, includePrices = true } = options;
+    const { storeId } = usePluginConfig();
+    const { isSessionInitialized } = useTagadaContext();
+    // Create products resource client
+    const productsResource = useMemo(() => {
+        try {
+            return new ProductsResource(getGlobalApiClient());
+        }
+        catch (error) {
+            throw new Error('Failed to initialize products resource: ' + (error instanceof Error ? error.message : 'Unknown error'));
+        }
+    }, []);
+    // Create query key based on options
+    const queryKey = useMemo(() => ['products', { storeId, productIds, includeVariants, includePrices }], [storeId, productIds, includeVariants, includePrices]);
+    // Use TanStack Query for fetching products
+    const { data: products = [], 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.');
+            }
+            const options = {
+                storeId,
+                includeVariants,
+                includePrices,
+            };
+            if (productIds.length > 0) {
+                // Fetch specific products
+                return await productsResource.getProductsByIds(productIds, options);
+            }
+            else {
+                // Fetch all products for the store
+                return await productsResource.getProducts(options);
+            }
+        },
+        staleTime: 5 * 60 * 1000, // 5 minutes
+    });
+    // Helper functions (matching old useProducts exactly)
+    const getProduct = useCallback((productId) => {
+        return products.find((product) => product.id === productId);
+    }, [products]);
+    const getVariant = useCallback((variantId) => {
+        for (const product of products) {
+            const variant = product.variants?.find((v) => v.id === variantId);
+            if (variant) {
+                return { product, variant };
+            }
+        }
+        return undefined;
+    }, [products]);
+    const getAllVariants = useCallback(() => {
+        const allVariants = [];
+        for (const product of products) {
+            if (product.variants) {
+                for (const variant of product.variants) {
+                    allVariants.push({ product, variant });
+                }
+            }
+        }
+        return allVariants;
+    }, [products]);
+    const filterVariants = useCallback((predicate) => {
+        const filtered = [];
+        for (const product of products) {
+            if (product.variants) {
+                for (const variant of product.variants) {
+                    if (predicate(variant, product)) {
+                        filtered.push({ product, variant });
+                    }
+                }
+            }
+        }
+        return filtered;
+    }, [products]);
+    return {
+        // Query data
+        products,
+        isLoading,
+        error,
+        // Actions
+        refetch: async () => {
+            await refetch();
+        },
+        // Helper functions
+        getProduct,
+        getVariant,
+        getAllVariants,
+        filterVariants,
+    };
+}

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

@@ -0,0 +1,28 @@
+/**
+ * Promotions Hook using TanStack Query
+ * Replaces manual refresh with automatic cache invalidation
+ */
+import { Promotion } from '../../core/resources/checkout';
+export interface UsePromotionsQueryOptions {
+    checkoutSessionId?: string;
+    enabled?: boolean;
+}
+export interface UsePromotionsQueryResult {
+    appliedPromotions: Promotion[];
+    isLoading: boolean;
+    error: Error | null;
+    isApplying: boolean;
+    isRemoving: boolean;
+    applyPromotionCode: (code: string) => Promise<{
+        success: boolean;
+        error?: string;
+        promotion?: Promotion;
+    }>;
+    removePromotionCode: (promotionId: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    refresh: () => Promise<void>;
+    clearError: () => void;
+}
+export declare function usePromotionsQuery(options?: UsePromotionsQueryOptions): UsePromotionsQueryResult;

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

@@ -0,0 +1,97 @@
+/**
+ * Promotions Hook using TanStack Query
+ * Replaces manual refresh with automatic cache invalidation
+ */
+import { useMemo } from 'react';
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
+import { PromotionsResource } from '../../core/resources/promotions';
+import { getGlobalApiClient } from './useApiQuery';
+export function usePromotionsQuery(options = {}) {
+    const { checkoutSessionId, enabled = true } = options;
+    const queryClient = useQueryClient();
+    const client = getGlobalApiClient();
+    // Create resource client
+    const promotionsResource = useMemo(() => {
+        try {
+            return new PromotionsResource(client);
+        }
+        catch (error) {
+            throw new Error('Failed to initialize promotions resource: ' + (error instanceof Error ? error.message : 'Unknown error'));
+        }
+    }, [client]);
+    // Main promotions query
+    const { data: appliedPromotions = [], isLoading, error, refetch, } = useQuery({
+        queryKey: ['promotions', checkoutSessionId],
+        queryFn: () => promotionsResource.getAppliedPromotions(checkoutSessionId),
+        enabled: enabled && !!checkoutSessionId,
+        staleTime: 30000, // 30 seconds
+        refetchOnWindowFocus: false,
+    });
+    // Apply promotion mutation
+    const applyMutation = useMutation({
+        mutationFn: ({ code }) => {
+            if (!checkoutSessionId) {
+                throw new Error('No checkout session available');
+            }
+            return promotionsResource.applyPromotionCode(checkoutSessionId, code);
+        },
+        onSuccess: () => {
+            // Invalidate related queries
+            if (checkoutSessionId) {
+                void queryClient.invalidateQueries({ queryKey: ['promotions', checkoutSessionId] });
+                void queryClient.invalidateQueries({ queryKey: ['checkout', checkoutSessionId] });
+            }
+        },
+    });
+    // Remove promotion mutation
+    const removeMutation = useMutation({
+        mutationFn: ({ promotionId }) => {
+            if (!checkoutSessionId) {
+                throw new Error('No checkout session available');
+            }
+            return promotionsResource.removePromotionCode(checkoutSessionId, promotionId);
+        },
+        onSuccess: () => {
+            // Invalidate related queries
+            if (checkoutSessionId) {
+                void queryClient.invalidateQueries({ queryKey: ['promotions', checkoutSessionId] });
+                void queryClient.invalidateQueries({ queryKey: ['checkout', checkoutSessionId] });
+            }
+        },
+    });
+    return {
+        // Query data
+        appliedPromotions,
+        isLoading,
+        error,
+        // Loading states for mutations
+        isApplying: applyMutation.isPending,
+        isRemoving: removeMutation.isPending,
+        // Actions
+        applyPromotionCode: async (code) => {
+            try {
+                return await applyMutation.mutateAsync({ code });
+            }
+            catch (err) {
+                const error = err instanceof Error ? err : new Error('Failed to apply promotion code');
+                return { success: false, error: error.message };
+            }
+        },
+        removePromotionCode: async (promotionId) => {
+            try {
+                return await removeMutation.mutateAsync({ promotionId });
+            }
+            catch (err) {
+                const error = err instanceof Error ? err : new Error('Failed to remove promotion code');
+                return { success: false, error: error.message };
+            }
+        },
+        refresh: async () => {
+            await refetch();
+        },
+        clearError: () => {
+            // Clear query error by refetching
+            void refetch();
+        },
+    };
+}

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

@@ -0,0 +1,36 @@
+export type ThreedsProvider = 'basis_theory';
+export interface PaymentInstrument {
+    id: string;
+    token: string | null;
+    type: string;
+    card: {
+        maskedCardNumber?: string;
+        expirationMonth?: number;
+        expirationYear?: number;
+    };
+}
+export interface ThreedsSession {
+    id: string;
+    sessionId: string;
+    provider: string;
+}
+export interface ThreedsChallenge {
+    sessionId: string;
+    acsChallengeUrl: string;
+    acsTransactionId: string;
+    threeDSVersion: string;
+}
+export interface ThreedsOptions {
+    provider?: ThreedsProvider;
+}
+export interface ThreedsHook {
+    createSession: (paymentInstrument: PaymentInstrument, options?: ThreedsOptions) => Promise<ThreedsSession>;
+    startChallenge: (challengeData: ThreedsChallenge, options?: ThreedsOptions) => Promise<any>;
+    isLoading: boolean;
+    error: Error | null;
+}
+interface UseThreedsOptions {
+    defaultProvider?: ThreedsProvider;
+}
+export declare function useThreeds(options?: UseThreedsOptions): ThreedsHook;
+export {};