@tagadapay/plugin-sdk 2.6.18 → 2.7.2

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

@@ -0,0 +1,101 @@
+export interface ClubOfferItem {
+    id: string;
+    productId: string;
+    variantId: string;
+    product: {
+        name: string;
+        description: string;
+    };
+    variant: {
+        name: string;
+        description: string;
+        imageUrl: string;
+        grams: number;
+    };
+    unitAmount: number;
+    quantity: number;
+    amount: number;
+    adjustedAmount: number;
+}
+export interface ClubOfferSummary {
+    currency: string;
+    totalAmount: number;
+    totalAdjustedAmount: number;
+    items: ClubOfferItem[];
+}
+export interface ClubOfferLineItem {
+    id: string;
+    quantity: number;
+    price: {
+        variant: {
+            id: string;
+            name: string;
+            description: string | null;
+            imageUrl: string;
+            grams: number;
+            product: {
+                id: string;
+                name: string;
+                description: string;
+            };
+        };
+    };
+}
+export interface ClubOffer {
+    id: string;
+    titleTrans: {
+        en: string;
+    };
+    summaries: ClubOfferSummary[];
+    offerLineItems: ClubOfferLineItem[];
+}
+export interface UseClubOffersOptions {
+    /**
+     * Whether to fetch club offers automatically on mount
+     * @default true
+     */
+    enabled?: boolean;
+    /**
+     * Return URL for payment
+     */
+    returnUrl?: string;
+}
+export interface UseClubOffersResult {
+    /**
+     * Array of fetched club offers
+     */
+    offers: ClubOffer[];
+    /**
+     * Loading state
+     */
+    isLoading: boolean;
+    /**
+     * Error state
+     */
+    error: Error | null;
+    /**
+     * Refetch club offers
+     */
+    refetch: () => Promise<void>;
+    /**
+     * Get club offer by ID from the loaded offers
+     */
+    getOffer: (offerId: string) => ClubOffer | undefined;
+    /**
+     * Get total value of all club offers
+     */
+    getTotalValue: () => number;
+    /**
+     * Get total savings across all club offers
+     */
+    getTotalSavings: () => number;
+    /**
+     * Clear error state
+     */
+    clearError: () => void;
+    /**
+     * Pay for a club offer
+     */
+    payOffer: (offerId: string, returnUrl?: string) => Promise<void>;
+}
+export declare function useClubOffers(options?: UseClubOffersOptions): UseClubOffersResult;

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

@@ -0,0 +1,126 @@
+'use client';
+/**
+ * useClubOffers - Hook for club-specific offers (v2)
+ * Extends the offers functionality with club filtering
+ */
+import { useMutation, useQuery } from '@tanstack/react-query';
+import { useCallback, useMemo } from 'react';
+import { OffersResource } from '../../core/resources/offers';
+import { useTagadaContext } from '../providers/TagadaProvider';
+import { getGlobalApiClient } from './useApiQuery';
+import { usePluginConfig } from './usePluginConfig';
+/**
+ * Transform generic Offer to ClubOffer format
+ */
+function transformToClubOffer(offer) {
+    return {
+        id: offer.id,
+        titleTrans: offer.titleTrans,
+        summaries: offer.summaries.map((summary) => ({
+            currency: summary.currency,
+            totalAmount: summary.totalAmount,
+            totalAdjustedAmount: summary.totalAdjustedAmount,
+            items: summary.items.map((item) => ({
+                id: item.id,
+                productId: item.id, // Using item ID as productId fallback
+                variantId: item.id, // Using item ID as variantId fallback
+                product: item.product,
+                variant: {
+                    name: item.variant.name,
+                    description: '', // Not available in base Offer
+                    imageUrl: item.variant.imageUrl,
+                    grams: 0, // Not available in base Offer
+                },
+                unitAmount: item.unitAmount,
+                quantity: item.quantity,
+                amount: item.amount,
+                adjustedAmount: item.adjustedAmount,
+            })),
+        })),
+        offerLineItems: [], // Not available in base Offer
+    };
+}
+export function useClubOffers(options = {}) {
+    const { enabled = true, returnUrl } = options;
+    const { storeId } = usePluginConfig();
+    const { isSessionInitialized } = useTagadaContext();
+    // 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'));
+        }
+    }, []);
+    // Create query key
+    const queryKey = useMemo(() => ['club-offers', { storeId }], [storeId]);
+    // Fetch club offers using TanStack Query
+    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.');
+            }
+            // Fetch all offers and filter for club type
+            // Note: The API endpoint should support a 'type' parameter
+            const response = await getGlobalApiClient().get(`/api/v1/stores/${storeId}/offers`, {
+                params: {
+                    type: 'club',
+                },
+            });
+            // Transform to club offer format
+            return (response.offers || []).map(transformToClubOffer);
+        },
+        staleTime: 5 * 60 * 1000, // 5 minutes
+        refetchOnWindowFocus: false,
+    });
+    // Pay offer mutation
+    const payOfferMutation = useMutation({
+        mutationFn: async ({ offerId, returnUrl }) => {
+            const url = returnUrl || (typeof window !== 'undefined' ? window.location.href : '');
+            return await offersResource.payOffer(offerId);
+        },
+        onError: (error) => {
+            console.error('[SDK] Failed to pay offer:', error);
+        },
+    });
+    // Helper functions
+    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?.totalAmount - firstSummary?.totalAdjustedAmount || 0);
+        }, 0);
+    }, [offers]);
+    const clearError = useCallback(() => {
+        // TanStack Query doesn't have a direct clearError method
+        // Error will be cleared on next successful fetch
+    }, []);
+    const payOffer = useCallback(async (offerId, returnUrl) => {
+        await payOfferMutation.mutateAsync({ offerId, returnUrl });
+    }, [payOfferMutation]);
+    return {
+        offers,
+        isLoading,
+        error,
+        refetch: async () => {
+            await refetch();
+        },
+        getOffer,
+        getTotalValue,
+        getTotalSavings,
+        clearError,
+        payOffer,
+    };
+}

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

@@ -0,0 +1,67 @@
+import { CreditTransaction, RedeemProductResponse } from '../../core/resources/credits';
+export interface UseCreditsOptions {
+    /**
+     * Customer ID to fetch credits for
+     */
+    customerId?: string | null;
+    /**
+     * Whether to fetch credits automatically on mount
+     * @default true
+     */
+    enabled?: boolean;
+}
+export interface UseCreditsResult {
+    /**
+     * Customer credit balance
+     */
+    balance: number;
+    /**
+     * Lifetime credits earned
+     */
+    lifetimeEarned: number;
+    /**
+     * Lifetime credits spent
+     */
+    lifetimeSpent: number;
+    /**
+     * Credit transaction history
+     */
+    transactions: CreditTransaction[];
+    /**
+     * Loading state
+     */
+    isLoading: boolean;
+    /**
+     * Error state
+     */
+    error: Error | null;
+    /**
+     * Refetch credit balance and history
+     */
+    refetch: () => Promise<void>;
+    /**
+     * Redeem a product using credits
+     */
+    redeemProduct: (data: {
+        productId?: string;
+        variantId: string;
+        quantity?: number;
+    }) => Promise<RedeemProductResponse>;
+    /**
+     * Check if customer has enough credits for a purchase
+     */
+    hasEnoughCredits: (amount: number) => boolean;
+    /**
+     * Get transaction by ID
+     */
+    getTransaction: (transactionId: string) => CreditTransaction | undefined;
+    /**
+     * Redemption mutation state
+     */
+    isRedeeming: boolean;
+    /**
+     * Redemption error state
+     */
+    redeemError: Error | null;
+}
+export declare function useCredits(options?: UseCreditsOptions): UseCreditsResult;

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

@@ -0,0 +1,80 @@
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import { useCallback, useMemo } from 'react';
+import { CreditsResource } from '../../core/resources/credits';
+import { useTagadaContext } from '../providers/TagadaProvider';
+import { getGlobalApiClient } from './useApiQuery';
+import { usePluginConfig } from './usePluginConfig';
+export function useCredits(options = {}) {
+    const { customerId = null, enabled = true } = options;
+    const { storeId } = usePluginConfig();
+    const { isSessionInitialized } = useTagadaContext();
+    const queryClient = useQueryClient();
+    // Create credits resource client
+    const creditsResource = useMemo(() => {
+        try {
+            return new CreditsResource(getGlobalApiClient());
+        }
+        catch (error) {
+            throw new Error('Failed to initialize credits resource: ' +
+                (error instanceof Error ? error.message : 'Unknown error'));
+        }
+    }, []);
+    // Determine if query should be enabled
+    const isEnabled = useMemo(() => {
+        return Boolean(enabled && customerId && storeId && isSessionInitialized);
+    }, [enabled, customerId, storeId, isSessionInitialized]);
+    // Create query key
+    const queryKey = useMemo(() => ['customer-credits', { customerId, storeId }], [customerId, storeId]);
+    // Fetch customer credits using TanStack Query
+    const { data = null, isLoading, error, refetch, } = useQuery({
+        queryKey,
+        enabled: isEnabled,
+        queryFn: async () => {
+            if (!customerId || !storeId) {
+                return null;
+            }
+            return await creditsResource.getCustomerCredits(customerId, storeId);
+        },
+        staleTime: 30 * 1000, // 30 seconds - fresher than most resources
+        refetchOnWindowFocus: true, // Refetch on window focus for up-to-date balance
+    });
+    // Redeem product mutation
+    const redeemMutation = useMutation({
+        mutationFn: async (redeemData) => {
+            return await creditsResource.redeemProduct(redeemData);
+        },
+        onSuccess: () => {
+            // Invalidate credits query to refetch updated balance
+            void queryClient.invalidateQueries({ queryKey });
+        },
+        onError: (error) => {
+            console.error('[SDK] Failed to redeem product with credits:', error);
+        },
+    });
+    // Helper functions
+    const hasEnoughCredits = useCallback((amount) => {
+        return (data?.balance ?? 0) >= amount;
+    }, [data?.balance]);
+    const getTransaction = useCallback((transactionId) => {
+        return data?.transactions.find((tx) => tx.id === transactionId);
+    }, [data?.transactions]);
+    const redeemProduct = useCallback(async (redeemData) => {
+        return await redeemMutation.mutateAsync(redeemData);
+    }, [redeemMutation]);
+    return {
+        balance: data?.balance ?? 0,
+        lifetimeEarned: data?.lifetimeEarned ?? 0,
+        lifetimeSpent: data?.lifetimeSpent ?? 0,
+        transactions: data?.transactions ?? [],
+        isLoading,
+        error,
+        refetch: async () => {
+            await refetch();
+        },
+        redeemProduct,
+        hasEnoughCredits,
+        getTransaction,
+        isRedeeming: redeemMutation.isPending,
+        redeemError: redeemMutation.error,
+    };
+}

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

@@ -0,0 +1,11 @@
+/**
+ * useCustomer - Hook to access current customer data (v2)
+ */
+import { Customer } from '../../../react/types';
+export interface UseCustomerResult {
+    customer: Customer | null;
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    isAnonymous: boolean;
+}
+export declare function useCustomer(): UseCustomerResult;

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

@@ -0,0 +1,11 @@
+'use client';
+import { useTagadaContext } from '../providers/TagadaProvider';
+export function useCustomer() {
+    const { customer, isLoading } = useTagadaContext();
+    return {
+        customer,
+        isAuthenticated: customer?.isAuthenticated || false,
+        isLoading,
+        isAnonymous: customer?.role === 'anonymous',
+    };
+}

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

@@ -0,0 +1,12 @@
+import { CustomerInfos } from '../../core/resources/customer';
+export interface UseCustomerInfosOptions {
+    customerId?: string | null;
+    enabled?: boolean;
+}
+export interface UseCustomerInfosResult {
+    data: CustomerInfos | null;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+}
+export declare function useCustomerInfos(options?: UseCustomerInfosOptions): UseCustomerInfosResult;

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

@@ -0,0 +1,53 @@
+'use client';
+/**
+ * useCustomerInfos - Hook to fetch customer information (v2)
+ * Fetches customer infos from `/api/v1/customers/{customerId}` with `storeId` param
+ */
+import { useQuery } from '@tanstack/react-query';
+import { useMemo } from 'react';
+import { CustomerResource } from '../../core/resources/customer';
+import { useTagadaContext } from '../providers/TagadaProvider';
+import { getGlobalApiClient } from './useApiQuery';
+import { usePluginConfig } from './usePluginConfig';
+export function useCustomerInfos(options = {}) {
+    const { storeId } = usePluginConfig();
+    const { isSessionInitialized } = useTagadaContext();
+    const { customerId = null, enabled = true } = options;
+    // Create customer resource client
+    const customerResource = useMemo(() => {
+        try {
+            return new CustomerResource(getGlobalApiClient());
+        }
+        catch (error) {
+            throw new Error('Failed to initialize customer resource: ' +
+                (error instanceof Error ? error.message : 'Unknown error'));
+        }
+    }, []);
+    // Determine if query should be enabled
+    const isEnabled = useMemo(() => {
+        return Boolean(enabled && customerId && storeId && isSessionInitialized);
+    }, [enabled, customerId, storeId, isSessionInitialized]);
+    // Create query key
+    const queryKey = useMemo(() => ['customer-infos', { customerId, storeId }], [customerId, storeId]);
+    // Fetch customer infos using TanStack Query
+    const { data = null, isLoading, error, refetch, } = useQuery({
+        queryKey,
+        enabled: isEnabled,
+        queryFn: async () => {
+            if (!customerId || !storeId) {
+                return null;
+            }
+            return await customerResource.getCustomerInfos(customerId, storeId);
+        },
+        staleTime: 5 * 60 * 1000, // 5 minutes
+        refetchOnWindowFocus: false,
+    });
+    return {
+        data,
+        isLoading,
+        error,
+        refetch: async () => {
+            await refetch();
+        },
+    };
+}

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

@@ -0,0 +1,17 @@
+/**
+ * useCustomerOrders - Hook to fetch customer orders (v2)
+ */
+import { OrderWithRelations } from '../../core/resources/customer';
+export interface UseCustomerOrdersOptions {
+    customerId?: string | null;
+    enabled?: boolean;
+}
+export interface UseCustomerOrdersResult {
+    data: {
+        orders: OrderWithRelations[];
+    } | null;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+}
+export declare function useCustomerOrders(options?: UseCustomerOrdersOptions): UseCustomerOrdersResult;

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

@@ -0,0 +1,51 @@
+/**
+ * useCustomerOrders - Hook to fetch customer orders (v2)
+ */
+import { useQuery } from '@tanstack/react-query';
+import { useMemo } from 'react';
+import { CustomerResource } from '../../core/resources/customer';
+import { useTagadaContext } from '../providers/TagadaProvider';
+import { getGlobalApiClient } from './useApiQuery';
+import { usePluginConfig } from './usePluginConfig';
+export function useCustomerOrders(options = {}) {
+    const { storeId } = usePluginConfig();
+    const { isSessionInitialized } = useTagadaContext();
+    const { customerId = null, enabled = true } = options;
+    // Create customer resource client
+    const customerResource = useMemo(() => {
+        try {
+            return new CustomerResource(getGlobalApiClient());
+        }
+        catch (error) {
+            throw new Error('Failed to initialize customer resource: ' +
+                (error instanceof Error ? error.message : 'Unknown error'));
+        }
+    }, []);
+    // Determine if query should be enabled
+    const isEnabled = useMemo(() => {
+        return Boolean(enabled && customerId && storeId && isSessionInitialized);
+    }, [enabled, customerId, storeId, isSessionInitialized]);
+    // Create query key
+    const queryKey = useMemo(() => ['customer-orders', { customerId, storeId }], [customerId, storeId]);
+    // Fetch customer orders using TanStack Query
+    const { data = null, isLoading, error, refetch, } = useQuery({
+        queryKey,
+        enabled: isEnabled,
+        queryFn: async () => {
+            if (!customerId || !storeId) {
+                return null;
+            }
+            return await customerResource.getCustomerOrders(customerId, storeId);
+        },
+        staleTime: 5 * 60 * 1000, // 5 minutes
+        refetchOnWindowFocus: false,
+    });
+    return {
+        data,
+        isLoading,
+        error,
+        refetch: async () => {
+            await refetch();
+        },
+    };
+}

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

@@ -0,0 +1,23 @@
+/**
+ * useCustomerSubscriptions - Hook to manage customer subscriptions (v2)
+ */
+import { SubscriptionsResponse } from '../../core/resources/customer';
+export interface UseCustomerSubscriptionsOptions {
+    customerId?: string | null;
+    enabled?: boolean;
+}
+export interface UseCustomerSubscriptionsResult {
+    data: SubscriptionsResponse | null;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+    resumeSubscription: (subscriptionId: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    cancelSubscription: (subscriptionId: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+}
+export declare function useCustomerSubscriptions(options?: UseCustomerSubscriptionsOptions): UseCustomerSubscriptionsResult;

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

@@ -0,0 +1,94 @@
+/**
+ * useCustomerSubscriptions - Hook to manage customer subscriptions (v2)
+ */
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import { useCallback, useMemo } from 'react';
+import { CustomerResource } from '../../core/resources/customer';
+import { useTagadaContext } from '../providers/TagadaProvider';
+import { getGlobalApiClient } from './useApiQuery';
+export function useCustomerSubscriptions(options = {}) {
+    const { isSessionInitialized } = useTagadaContext();
+    const queryClient = useQueryClient();
+    const { customerId = null, enabled = true } = options;
+    // Create customer resource client
+    const customerResource = useMemo(() => {
+        try {
+            return new CustomerResource(getGlobalApiClient());
+        }
+        catch (error) {
+            throw new Error('Failed to initialize customer resource: ' +
+                (error instanceof Error ? error.message : 'Unknown error'));
+        }
+    }, []);
+    // Determine if query should be enabled
+    const isEnabled = useMemo(() => {
+        return Boolean(enabled && customerId && isSessionInitialized);
+    }, [enabled, customerId, isSessionInitialized]);
+    // Create query key
+    const queryKey = useMemo(() => ['customer-subscriptions', { customerId }], [customerId]);
+    // Fetch customer subscriptions using TanStack Query
+    const { data = null, isLoading, error, refetch, } = useQuery({
+        queryKey,
+        enabled: isEnabled,
+        queryFn: async () => {
+            if (!customerId) {
+                return null;
+            }
+            return await customerResource.getCustomerSubscriptions();
+        },
+        staleTime: 5 * 60 * 1000, // 5 minutes
+        refetchOnWindowFocus: false,
+    });
+    // Resume subscription mutation
+    const resumeMutation = useMutation({
+        mutationFn: async (subscriptionId) => {
+            return await customerResource.resumeSubscription(subscriptionId);
+        },
+        onSuccess: () => {
+            // Invalidate and refetch subscriptions
+            void queryClient.invalidateQueries({ queryKey });
+        },
+    });
+    // Cancel subscription mutation
+    const cancelMutation = useMutation({
+        mutationFn: async (subscriptionId) => {
+            return await customerResource.cancelSubscription(subscriptionId);
+        },
+        onSuccess: () => {
+            // Invalidate and refetch subscriptions
+            void queryClient.invalidateQueries({ queryKey });
+        },
+    });
+    // Resume subscription
+    const resumeSubscription = useCallback(async (subscriptionId) => {
+        try {
+            await resumeMutation.mutateAsync(subscriptionId);
+            return { success: true };
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : 'Failed to resume subscription';
+            return { success: false, error: errorMessage };
+        }
+    }, [resumeMutation]);
+    // Cancel subscription
+    const cancelSubscription = useCallback(async (subscriptionId) => {
+        try {
+            await cancelMutation.mutateAsync(subscriptionId);
+            return { success: true };
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : 'Failed to cancel subscription';
+            return { success: false, error: errorMessage };
+        }
+    }, [cancelMutation]);
+    return {
+        data,
+        isLoading,
+        error,
+        refetch: async () => {
+            await refetch();
+        },
+        resumeSubscription,
+        cancelSubscription,
+    };
+}