@tagadapay/plugin-sdk 2.4.39 → 2.5.0

package/dist/v2/core/resources/payments.d.ts

@@ -0,0 +1,140 @@
+/**
+ * Payments Resource Client
+ * Axios-based API client for payment endpoints
+ */
+import { ApiClient } from './apiClient';
+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 PaymentResponse {
+    paymentId: string;
+    payment: Payment;
+    order?: any;
+}
+export interface PaymentInstrumentResponse {
+    id: string;
+    token: string;
+    type: string;
+    card?: {
+        maskedCardNumber?: string;
+        expirationMonth?: number;
+        expirationYear?: number;
+        brand?: string;
+    };
+}
+export interface PaymentInstrumentCustomer {
+    id: string;
+    type: 'card';
+    card: {
+        last4: string;
+        exp_month: number;
+        exp_year: number;
+        brand: string;
+        bin: string;
+    };
+    us_bank_account: null;
+    sepa_debit: null;
+    tokenizer: string;
+    token: string;
+    isDefault: boolean;
+    isActive: boolean;
+    metadata: Record<string, unknown>;
+    customerId: string;
+    accountId: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export type PaymentInstrumentCustomerResponse = PaymentInstrumentCustomer[];
+export interface PaymentOptions {
+    enableThreeds?: boolean;
+    threedsProvider?: 'basis_theory';
+    initiatedBy?: 'customer' | 'merchant';
+    source?: 'upsell' | 'checkout' | 'offer' | 'missing_club' | 'forced';
+    onSuccess?: (response: PaymentResponse) => void;
+    onFailure?: (error: string) => void;
+    onRequireAction?: (payment: Payment) => void;
+}
+export interface CardPaymentMethod {
+    cardNumber: string;
+    expiryDate: string;
+    cvc: string;
+    cardholderName?: string;
+}
+export interface ApplePayToken {
+    id: string;
+    type: string;
+    card: {
+        bin: string;
+        last4: string;
+        expiration_month: number;
+        expiration_year: number;
+        brand: string;
+    };
+}
+export declare class PaymentsResource {
+    private apiClient;
+    constructor(apiClient: ApiClient);
+    /**
+     * Create payment instrument
+     */
+    createPaymentInstrument(paymentInstrumentData: any): Promise<PaymentInstrumentResponse>;
+    /**
+     * Create card payment instrument
+     */
+    createCardPaymentInstrument(basisTheory: any, // BasisTheory instance from @basis-theory/basis-theory-react
+    cardData: CardPaymentMethod): Promise<PaymentInstrumentResponse>;
+    /**
+     * Create Apple Pay payment instrument
+     */
+    createApplePayPaymentInstrument(basisTheory: any, // BasisTheory instance from @basis-theory/basis-theory-react
+    applePayToken: ApplePayToken): Promise<PaymentInstrumentResponse>;
+    /**
+     * Helper function to format expiry date
+     */
+    private getCardMonthAndYear;
+    /**
+     * Process payment directly with checkout session
+     */
+    processPaymentDirect(checkoutSessionId: string, paymentInstrumentId: string, threedsSessionId?: string, options?: {
+        initiatedBy?: 'customer' | 'merchant';
+        source?: 'upsell' | 'checkout' | 'offer' | 'missing_club' | 'forced';
+    }): Promise<PaymentResponse>;
+    /**
+     * Get card payment instruments for customer
+     */
+    getCardPaymentInstruments(): Promise<PaymentInstrumentCustomerResponse>;
+    /**
+     * Mark payment action as processed
+     */
+    markPaymentActionProcessed(paymentId: string): Promise<void>;
+    /**
+     * Get payment status
+     */
+    getPaymentStatus(paymentId: string): Promise<Payment>;
+}

package/dist/v2/core/resources/payments.js

@@ -0,0 +1,126 @@
+/**
+ * Payments Resource Client
+ * Axios-based API client for payment endpoints
+ */
+export class PaymentsResource {
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+    }
+    /**
+     * Create payment instrument
+     */
+    async createPaymentInstrument(paymentInstrumentData) {
+        return this.apiClient.post('/api/v1/payment/create-payment-instrument', {
+            paymentInstrumentData,
+        });
+    }
+    /**
+     * Create card payment instrument
+     */
+    async createCardPaymentInstrument(basisTheory, // BasisTheory instance from @basis-theory/basis-theory-react
+    cardData) {
+        if (!basisTheory) {
+            throw new Error('Payment processor not initialized');
+        }
+        console.log('Creating card payment instrument');
+        // Create token using BasisTheory
+        const btResponse = await basisTheory.tokens.create({
+            type: 'card',
+            data: {
+                cvc: cardData.cvc,
+                number: Number(cardData.cardNumber.replace(/\s+/g, '')),
+                ...this.getCardMonthAndYear(cardData.expiryDate),
+            },
+            metadata: {
+                nonSensitiveField: 'nonSensitiveValue',
+            },
+        });
+        // Create payment instrument through API
+        const { expiration_month, expiration_year } = this.getCardMonthAndYear(cardData.expiryDate);
+        const paymentInstrumentData = {
+            type: btResponse.type,
+            card: {
+                maskedCardNumber: btResponse.enrichments?.cardDetails?.bin ?
+                    `${btResponse.enrichments.cardDetails.bin}****${btResponse.enrichments.cardDetails.last4}` :
+                    cardData.cardNumber.replace(/\d(?=\d{4})/g, '*'),
+                expirationMonth: expiration_month,
+                expirationYear: expiration_year,
+            },
+            token: btResponse.id,
+        };
+        const response = await this.apiClient.post('/api/v1/payment/create-payment-instrument', { paymentInstrumentData });
+        console.log('Payment instrument created:', response);
+        return response;
+    }
+    /**
+     * Create Apple Pay payment instrument
+     */
+    async createApplePayPaymentInstrument(basisTheory, // BasisTheory instance from @basis-theory/basis-theory-react
+    applePayToken) {
+        if (!basisTheory) {
+            throw new Error('Payment processor not initialized');
+        }
+        if (!applePayToken.id) {
+            throw new Error('Apple Pay token is missing');
+        }
+        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 response = await this.apiClient.post('/api/v1/payment/create-payment-instrument', { paymentInstrumentData });
+        return response;
+    }
+    /**
+     * Helper function to format expiry date
+     */
+    getCardMonthAndYear(expiryDate) {
+        const [month, year] = expiryDate.split('/');
+        const currentYear = new Date().getFullYear();
+        const century = Math.floor(currentYear / 100) * 100;
+        const fullYear = Number(year) + century;
+        return {
+            expiration_month: Number(month),
+            expiration_year: fullYear,
+        };
+    }
+    /**
+     * Process payment directly with checkout session
+     */
+    async processPaymentDirect(checkoutSessionId, paymentInstrumentId, threedsSessionId, options = {}) {
+        return this.apiClient.post('/api/public/v1/checkout/pay-v2', {
+            checkoutSessionId,
+            paymentInstrumentId,
+            ...(threedsSessionId && { threedsSessionId }),
+            ...(options.initiatedBy && { initiatedBy: options.initiatedBy }),
+            ...(options.source && { source: options.source }),
+        });
+    }
+    /**
+     * Get card payment instruments for customer
+     */
+    async getCardPaymentInstruments() {
+        return this.apiClient.get('/api/v1/payment-instruments/customer');
+    }
+    /**
+     * Mark payment action as processed
+     */
+    async markPaymentActionProcessed(paymentId) {
+        return this.apiClient.post('/api/v1/payments/require-action/processed', {
+            paymentId,
+        });
+    }
+    /**
+     * Get payment status
+     */
+    async getPaymentStatus(paymentId) {
+        return this.apiClient.get(`/api/v1/payments/${paymentId}`);
+    }
+}

package/dist/v2/core/resources/postPurchases.d.ts

@@ -0,0 +1,182 @@
+/**
+ * Post Purchases Resource Client
+ * Axios-based API client for post-purchase endpoints
+ */
+import { ApiClient } from './apiClient';
+export interface PostPurchaseOfferItem {
+    id: string;
+    productId: string;
+    variantId: string;
+    product: {
+        name: string;
+        description: string;
+    };
+    variant: {
+        name: string;
+        description: string;
+        imageUrl: string;
+        grams: number | null;
+    };
+    unitAmount: number;
+    quantity: number;
+    amount: number;
+    adjustedAmount: number;
+}
+export interface PostPurchaseOfferSummary {
+    currency: string;
+    totalAmount: number;
+    totalAdjustedAmount: number;
+    items: PostPurchaseOfferItem[];
+}
+export interface PostPurchaseOfferLineItem {
+    id: string;
+    quantity: number;
+    price: {
+        variant: {
+            id: string;
+            name: string;
+            description: string | null;
+            grams: number | null;
+            product: {
+                id: string;
+                name: string;
+                description: string;
+            };
+        };
+    };
+}
+export interface PostPurchaseOffer {
+    id: string;
+    titleTrans: Record<string, string> | null;
+    summaries: PostPurchaseOfferSummary[];
+    offerLineItems: PostPurchaseOfferLineItem[];
+}
+export interface CurrencyOptions {
+    rate: number;
+    date: string;
+    amount: number;
+    lock: boolean;
+}
+export interface VariantOption {
+    id: string;
+    name: string;
+    sku: string | null;
+    default: boolean | null;
+    externalVariantId: string | null;
+    prices: {
+        id: string;
+        currencyOptions: CurrencyOptions;
+    }[];
+}
+export interface OrderSummaryItem {
+    id: string;
+    productId: string;
+    productName: string;
+    productDescription: string | null;
+    variantId: string;
+    variantName: string;
+    variantSku: string | null;
+    variantDefault: boolean | null;
+    variantExternalId: string | null;
+    priceId: string;
+    currencyOptions: CurrencyOptions;
+    quantity: number;
+    unitAmount: number;
+    amount: number;
+    adjustedAmount: number;
+    imageUrl?: string;
+    product: {
+        name: string;
+        description: string;
+    };
+    variant: {
+        name: string;
+        description: string;
+        imageUrl: string;
+        grams: number | null;
+    };
+}
+export interface OrderSummary {
+    items: OrderSummaryItem[];
+    totalAmount: number;
+    totalAdjustedAmount: number;
+    totalPromotionAmount: number;
+    currency: string;
+    options: Record<string, VariantOption[]>;
+}
+export interface CheckoutSessionState {
+    checkoutSessionId: string | null;
+    orderSummary: OrderSummary | null;
+    selectedVariants: Record<string, string>;
+    loadingVariants: Record<string, boolean>;
+    isUpdatingSummary: boolean;
+}
+export declare class PostPurchasesResource {
+    private apiClient;
+    constructor(apiClient: ApiClient);
+    /**
+     * Get post-purchase offers for an order
+     */
+    getPostPurchaseOffers(orderId: string): Promise<PostPurchaseOffer[]>;
+    /**
+     * Accept a post-purchase offer
+     */
+    acceptOffer(orderId: string, offerId: string, items: PostPurchaseOfferItem[]): Promise<{
+        success: boolean;
+        summary?: PostPurchaseOfferSummary;
+        error?: string;
+    }>;
+    /**
+     * Decline a post-purchase offer
+     */
+    declineOffer(orderId: string, offerId: string): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /**
+     * Preview a post-purchase offer
+     */
+    previewOffer(orderId: string, offerId: string, items: PostPurchaseOfferItem[]): Promise<{
+        success: boolean;
+        summary?: PostPurchaseOfferSummary;
+        error?: string;
+    }>;
+    /**
+     * Create a post-purchase order
+     */
+    createPostPurchaseOrder(orderId: string, offers: PostPurchaseOffer[]): Promise<{
+        success: boolean;
+        error?: string;
+        orderId?: string;
+    }>;
+    /**
+     * Initialize a checkout session for a post-purchase offer
+     */
+    initCheckoutSession(offerId: string, orderId: string, customerId?: string): Promise<{
+        checkoutSessionId: string;
+    }>;
+    /**
+     * Initialize a checkout session for a post-purchase offer with specific variants
+     */
+    initCheckoutSessionWithVariants(offerId: string, orderId: string, lineItems: {
+        variantId: string;
+        quantity: number;
+    }[]): Promise<{
+        checkoutSessionId: string;
+    }>;
+    /**
+     * Pay with a checkout session for a post-purchase offer
+     */
+    payWithCheckoutSession(checkoutSessionId: string, orderId?: string): Promise<void>;
+    /**
+     * Get order summary for a checkout session
+     */
+    getOrderSummary(sessionId: string, includeVariantOptions?: boolean): Promise<any>;
+    /**
+     * Update line items for a checkout session
+     */
+    updateLineItems(sessionId: string, lineItems: {
+        variantId: string;
+        quantity: number;
+    }[]): Promise<any>;
+}

package/dist/v2/core/resources/postPurchases.js

@@ -0,0 +1,116 @@
+/**
+ * Post Purchases Resource Client
+ * Axios-based API client for post-purchase endpoints
+ */
+export class PostPurchasesResource {
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+    }
+    /**
+     * Get post-purchase offers for an order
+     */
+    async getPostPurchaseOffers(orderId) {
+        const response = await this.apiClient.get(`/api/v1/post-purchase/${orderId}/offers`);
+        return response || [];
+    }
+    /**
+     * Accept a post-purchase offer
+     */
+    async acceptOffer(orderId, offerId, items) {
+        return this.apiClient.post(`/api/v1/orders/${orderId}/post-purchase-offers/${offerId}/accept`, {
+            items,
+        });
+    }
+    /**
+     * Decline a post-purchase offer
+     */
+    async declineOffer(orderId, offerId) {
+        return this.apiClient.post(`/api/v1/orders/${orderId}/post-purchase-offers/${offerId}/decline`);
+    }
+    /**
+     * Preview a post-purchase offer
+     */
+    async previewOffer(orderId, offerId, items) {
+        return this.apiClient.post(`/api/v1/orders/${orderId}/post-purchase-offers/${offerId}/preview`, {
+            items,
+        });
+    }
+    /**
+     * Create a post-purchase order
+     */
+    async createPostPurchaseOrder(orderId, offers) {
+        try {
+            const response = await this.apiClient.post(`/api/v1/orders/${orderId}/post-purchase`, {
+                offers, // Use all offers since they don't have isSelected property
+            });
+            if (response.success) {
+                return { success: true, orderId: response.orderId };
+            }
+            else {
+                return { success: false, error: response.error || 'Failed to create post-purchase order' };
+            }
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : 'Failed to create post-purchase order',
+            };
+        }
+    }
+    /**
+     * Initialize a checkout session for a post-purchase offer
+     */
+    async initCheckoutSession(offerId, orderId, customerId) {
+        const response = await this.apiClient.post('/api/v1/checkout/offer/init', {
+            offerId,
+            returnUrl: typeof window !== 'undefined' ? window.location.href : '',
+            customerId: customerId || '',
+            orderId,
+        });
+        return { checkoutSessionId: response.checkoutSessionId };
+    }
+    /**
+     * Initialize a checkout session for a post-purchase offer with specific variants
+     */
+    async initCheckoutSessionWithVariants(offerId, orderId, lineItems) {
+        const response = await this.apiClient.post(`/api/v1/offers/${offerId}/transform-to-checkout`, {
+            offerId,
+            lineItems,
+            returnUrl: typeof window !== 'undefined' ? window.location.href : '',
+            mainOrderId: orderId,
+        });
+        return { checkoutSessionId: response.checkoutSessionId };
+    }
+    /**
+     * Pay with a checkout session for a post-purchase offer
+     */
+    async payWithCheckoutSession(checkoutSessionId, orderId) {
+        await this.apiClient.post(`/api/v1/checkout-sessions/${checkoutSessionId}/pay`, {
+            checkoutSessionId,
+            draft: false,
+            returnUrl: typeof window !== 'undefined' ? window.location.href : '',
+            metadata: {
+                comingFromPostPurchase: true,
+                postOrder: orderId,
+                upsell: true,
+                source: 'post_purchase_offer',
+            },
+        });
+    }
+    /**
+     * Get order summary for a checkout session
+     */
+    async getOrderSummary(sessionId, includeVariantOptions = false) {
+        return this.apiClient.post(`/api/v1/checkout-sessions/${sessionId}/order-summary`, {
+            includeVariantOptions,
+        });
+    }
+    /**
+     * Update line items for a checkout session
+     */
+    async updateLineItems(sessionId, lineItems) {
+        return this.apiClient.post(`/api/v1/checkout-sessions/${sessionId}/line-items`, {
+            lineItems,
+        });
+    }
+}

package/dist/v2/core/resources/products.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Products Resource Client
+ * Axios-based API client for product endpoints
+ */
+import type { Product, ProductVariant, ProductPrice } from '../utils/products';
+import { ApiClient } from './apiClient';
+export interface GetProductsOptions {
+    storeId: string;
+    productIds?: string[];
+    includeVariants?: boolean;
+    includePrices?: boolean;
+}
+export type { Product, ProductVariant, ProductPrice };
+export declare class ProductsResource {
+    private apiClient;
+    constructor(apiClient: ApiClient);
+    /**
+     * Get all products for a store
+     */
+    getProducts(options: GetProductsOptions): Promise<Product[]>;
+    /**
+     * Get a specific product by ID
+     */
+    getProduct(productId: string, options: GetProductsOptions): Promise<Product | null>;
+    /**
+     * Get multiple products by IDs
+     */
+    getProductsByIds(productIds: string[], options: GetProductsOptions): Promise<Product[]>;
+}

package/dist/v2/core/resources/products.js

@@ -0,0 +1,49 @@
+/**
+ * Products Resource Client
+ * Axios-based API client for product endpoints
+ */
+export class ProductsResource {
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+    }
+    /**
+     * Get all products for a store
+     */
+    async getProducts(options) {
+        const { storeId, includeVariants = true, includePrices = true } = options;
+        const response = await this.apiClient.post('/api/v1/products', {
+            storeId,
+            includeVariants,
+            includePrices,
+        });
+        return Array.isArray(response) ? response : response.items ?? [];
+    }
+    /**
+     * Get a specific product by ID
+     */
+    async getProduct(productId, options) {
+        const { storeId } = options;
+        try {
+            const response = await this.apiClient.post(`/api/v1/products/${productId}`, {
+                productId,
+                storeId,
+            });
+            return response || null;
+        }
+        catch (error) {
+            console.error('Error fetching product:', error);
+            return null;
+        }
+    }
+    /**
+     * Get multiple products by IDs
+     */
+    async getProductsByIds(productIds, options) {
+        const { storeId, includeVariants = true, includePrices = true } = options;
+        const fetchPromises = productIds.map(async (productId) => {
+            return this.getProduct(productId, { storeId, includeVariants, includePrices });
+        });
+        const results = await Promise.all(fetchPromises);
+        return results.filter((product) => product !== null);
+    }
+}

package/dist/v2/core/resources/promotions.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Promotions Resource Client
+ * Axios-based API client for promotion endpoints
+ */
+import { ApiClient } from './apiClient';
+import { Promotion } from './checkout';
+export interface PromotionCodeValidation {
+    isValid: boolean;
+    code: string;
+    error?: string;
+    promotion?: {
+        id: string;
+        name: string;
+        type: string;
+        value: number;
+        currency: string;
+    };
+}
+export declare class PromotionsResource {
+    private apiClient;
+    constructor(apiClient: ApiClient);
+    /**
+     * Get applied promotions for a checkout session
+     */
+    getAppliedPromotions(checkoutSessionId: string): Promise<Promotion[]>;
+    /**
+     * Apply a promotion code to a checkout session
+     */
+    applyPromotionCode(checkoutSessionId: string, code: string): Promise<{
+        success: boolean;
+        error?: string;
+        promotion?: Promotion;
+    }>;
+    /**
+     * Remove a promotion from a checkout session
+     */
+    removePromotionCode(checkoutSessionId: string, promotionId: string): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /**
+     * Validate a promotion code without applying it
+     */
+    validatePromotionCode(checkoutSessionId: string, code: string): Promise<PromotionCodeValidation>;
+}