@tagadapay/plugin-sdk 2.4.38 → 2.5.0

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

@@ -0,0 +1,115 @@
+/**
+ * Offers Resource Client
+ * Axios-based API client for offers endpoints
+ */
+export class OffersResource {
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+    }
+    /**
+     * Get offers for a store
+     */
+    async getOffers(storeId) {
+        const response = await this.apiClient.get(`/api/v1/stores/${storeId}/offers`);
+        return response.offers || [];
+    }
+    /**
+     * Get offers by IDs
+     */
+    async getOffersByIds(storeId, offerIds) {
+        const allOffers = await this.getOffers(storeId);
+        return allOffers.filter(offer => offerIds.includes(offer.id));
+    }
+    /**
+     * Initialize checkout session for an 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 };
+    }
+    /**
+     * Create checkout session for an offer
+     */
+    async createCheckoutSession(offerId, returnUrl) {
+        const response = await this.apiClient.post(`/api/v1/offers/${offerId}/checkout`, {
+            returnUrl: returnUrl || (typeof window !== 'undefined' ? window.location.origin : ''),
+        });
+        return { checkoutUrl: response.checkoutUrl };
+    }
+    /**
+     * Pay with checkout session
+     */
+    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: 'offer',
+            },
+        });
+    }
+    /**
+     * Pay for an offer directly
+     */
+    async payOffer(offerId, orderId) {
+        return this.apiClient.post(`/api/v1/offers/${offerId}/pay`, {
+            offerId,
+            draft: false,
+            returnUrl: typeof window !== 'undefined' ? window.location.href : '',
+            metadata: orderId ? {
+                comingFromPostPurchase: true,
+                postOrder: orderId,
+                upsell: true,
+                source: 'offer',
+            } : {
+                upsell: true,
+                source: 'offer',
+            },
+        });
+    }
+    /**
+     * Transform offer to checkout session with dynamic variant selection
+     */
+    async transformToCheckout(offerId, returnUrl) {
+        const response = await this.apiClient.post(`/api/v1/offers/${offerId}/transform-to-checkout`, {
+            returnUrl: returnUrl || (typeof window !== 'undefined' ? window.location.origin : ''),
+        });
+        return { checkoutUrl: response.checkoutUrl };
+    }
+    /**
+     * Initialize checkout session for an offer with variants (similar to postPurchases)
+     */
+    async initCheckoutSessionWithVariants(offerId, lineItems, returnUrl) {
+        const response = await this.apiClient.post(`/api/v1/offers/${offerId}/transform-to-checkout`, {
+            offerId,
+            lineItems,
+            returnUrl: returnUrl || (typeof window !== 'undefined' ? window.location.href : ''),
+        });
+        return { checkoutSessionId: response.checkoutSessionId };
+    }
+    /**
+     * 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/orders.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Orders Resource Client
+ * Axios-based API client for order endpoints
+ */
+import { Order, OrderLineItem } from '../utils/order';
+import { ApiClient } from './apiClient';
+export declare class OrdersResource {
+    private apiClient;
+    constructor(apiClient: ApiClient);
+    /**
+     * Fetch order by ID
+     */
+    getOrder(orderId: string): Promise<Order>;
+    /**
+     * Create a new order
+     */
+    createOrder(checkoutSessionId: string): Promise<{
+        success: boolean;
+        order?: Order;
+        error?: string;
+    }>;
+    /**
+     * Update order status
+     */
+    updateOrderStatus(orderId: string, status: string): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /**
+     * Add items to an order
+     */
+    addOrderItems(orderId: string, items: Omit<OrderLineItem, 'id'>[]): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /**
+     * Get order line items
+     */
+    getOrderLineItems(orderId: string): Promise<OrderLineItem[]>;
+}

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

@@ -0,0 +1,59 @@
+/**
+ * Orders Resource Client
+ * Axios-based API client for order endpoints
+ */
+export class OrdersResource {
+    constructor(apiClient) {
+        this.apiClient = apiClient;
+    }
+    /**
+     * Fetch order by ID
+     */
+    async getOrder(orderId) {
+        const response = await this.apiClient.get(`/api/v1/orders/${orderId}`);
+        // Handle both response formats: { success, order } and { order }
+        if (typeof response === 'object' && response !== null && 'success' in response && response.success === false) {
+            throw new Error(response.error || 'Failed to fetch order');
+        }
+        // If response has success property, use response.order
+        // Otherwise, assume the response itself is the order data or has order property
+        const orderData = typeof response === 'object' && response !== null && 'order' in response
+            ? response.order
+            : response;
+        if (!orderData) {
+            throw new Error('Order not found');
+        }
+        return orderData;
+    }
+    /**
+     * Create a new order
+     */
+    async createOrder(checkoutSessionId) {
+        return this.apiClient.post('/api/v1/orders', {
+            checkoutSessionId,
+        });
+    }
+    /**
+     * Update order status
+     */
+    async updateOrderStatus(orderId, status) {
+        return this.apiClient.patch(`/api/v1/orders/${orderId}/status`, {
+            status,
+        });
+    }
+    /**
+     * Add items to an order
+     */
+    async addOrderItems(orderId, items) {
+        return this.apiClient.post(`/api/v1/orders/${orderId}/items`, {
+            items,
+        });
+    }
+    /**
+     * Get order line items
+     */
+    async getOrderLineItems(orderId) {
+        const order = await this.getOrder(orderId);
+        return order.items || [];
+    }
+}

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>;
+}