@tagadapay/plugin-sdk 3.1.22 → 3.1.25

package/dist/v2/core/pixelMapping.js

@@ -72,9 +72,43 @@ function convertValueToMajor(params) {
     }
     return params;
 }
+/** Convert top-level monetary fields (shipping, tax, subtotal, total_discount) from minor → major units. */
+function convertMonetaryFieldsToMajor(params) {
+    const currency = params.currency ? String(params.currency) : null;
+    if (!currency)
+        return params;
+    const result = { ...params };
+    for (const field of ['shipping', 'tax', 'subtotal', 'total_discount']) {
+        if (result[field] != null) {
+            result[field] = minorToMajor(Number(result[field]), currency);
+        }
+    }
+    return result;
+}
+/** Convert price fields inside contents[] items from minor → major units. */
+function convertContentsPricesToMajor(params) {
+    if (!params.contents || !Array.isArray(params.contents))
+        return params;
+    const currency = params.currency ? String(params.currency) : null;
+    const result = { ...params };
+    result.contents = params.contents.map((item) => {
+        const itemCurrency = item.currency ? String(item.currency) : currency;
+        if (!itemCurrency)
+            return { ...item };
+        const converted = { ...item };
+        if (converted.price != null)
+            converted.price = minorToMajor(Number(converted.price), itemCurrency);
+        if (converted.original_price != null)
+            converted.original_price = minorToMajor(Number(converted.original_price), itemCurrency);
+        return converted;
+    });
+    return result;
+}
 function baseTransform(params) {
     let p = ensureCurrencyUppercase(params);
     p = convertValueToMajor(p);
+    p = convertMonetaryFieldsToMajor(p);
+    p = convertContentsPricesToMajor(p);
     return p;
 }
 // ---------------------------------------------------------------------------
@@ -98,6 +132,14 @@ export function mapMetaEvent(eventName, parameters) {
     if (params.contents && Array.isArray(params.contents)) {
         params.content_ids = params.contents.map((i) => i.content_id).filter(Boolean);
         params.content_type = params.content_type ?? 'product';
+        // Reshape contents to Meta's expected format (prices already converted by baseTransform)
+        params.contents = params.contents.map((item) => ({
+            id: item.content_id,
+            quantity: item.quantity != null ? Number(item.quantity) : undefined,
+            item_price: item.price != null ? Number(item.price) : undefined,
+            content_name: item.content_name,
+            content_category: item.content_category,
+        }));
     }
     return { name, params };
 }
@@ -124,35 +166,29 @@ const TIKTOK_EVENT_MAP = {
 export function mapTikTokEvent(eventName, parameters) {
     const name = TIKTOK_EVENT_MAP[eventName] ?? eventName;
     const params = baseTransform(parameters);
-    // Convert additional monetary fields from minor to major units
-    const currency = params.currency ? String(params.currency) : null;
-    if (currency) {
-        for (const field of ['shipping', 'tax', 'subtotal', 'total_discount']) {
-            if (params[field] != null) {
-                params[field] = minorToMajor(Number(params[field]), currency);
-            }
-        }
-    }
     if (params.contents && Array.isArray(params.contents)) {
-        // Extract content_ids at top level for TikTok product matching
+        const ids = params.contents
+            .map((i) => i.content_id)
+            .filter(Boolean);
+        // TikTok requires content_id (singular) at the top level for VSA
+        if (!params.content_id && ids.length > 0) {
+            params.content_id = ids.length === 1 ? ids[0] : JSON.stringify(ids);
+        }
+        // Also keep content_ids for backwards compatibility
         if (!params.content_ids) {
-            params.content_ids = params.contents
-                .map((i) => i.content_id)
-                .filter(Boolean);
+            params.content_ids = ids;
         }
-        params.contents = params.contents.map((item) => {
-            const itemCurrency = item.currency ? String(item.currency) : currency;
-            return {
-                content_id: item.content_id,
-                content_name: item.content_name,
-                content_type: item.content_type ?? 'product',
-                content_category: item.content_category,
-                price: item.price != null && itemCurrency ? minorToMajor(Number(item.price), itemCurrency) : item.price != null ? Number(item.price) : undefined,
-                original_price: item.original_price != null && itemCurrency ? minorToMajor(Number(item.original_price), itemCurrency) : item.original_price != null ? Number(item.original_price) : undefined,
-                quantity: item.quantity != null ? Number(item.quantity) : undefined,
-                description: item.description,
-            };
-        });
+        // Reshape contents to TikTok's expected format (prices already converted by baseTransform)
+        params.contents = params.contents.map((item) => ({
+            content_id: item.content_id,
+            content_name: item.content_name,
+            content_type: item.content_type ?? 'product',
+            content_category: item.content_category,
+            price: item.price != null ? Number(item.price) : undefined,
+            original_price: item.original_price != null ? Number(item.original_price) : undefined,
+            quantity: item.quantity != null ? Number(item.quantity) : undefined,
+            description: item.description,
+        }));
     }
     // Set required fields for InitiateCheckout
     if (eventName === 'InitiateCheckout') {
@@ -224,6 +260,7 @@ export function mapPinterestEvent(eventName, parameters) {
         params.order_quantity = Number(params.order_quantity);
     }
     if (params.contents && Array.isArray(params.contents)) {
+        // Reshape to Pinterest line_items format (prices already converted by baseTransform)
         params.line_items = params.contents.map((item) => ({
             product_id: item.content_id,
             product_name: item.content_name,
@@ -259,6 +296,7 @@ export function mapGTMEvent(eventName, parameters) {
         params.num_items = Number(params.num_items);
     }
     if (params.contents && Array.isArray(params.contents)) {
+        // Reshape to GA4 items format (prices already converted by baseTransform)
         params.items = params.contents.map((item) => ({
             item_id: item.content_id,
             item_name: item.content_name,

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

@@ -1,12 +1,12 @@
 /**
- * Base API Client using Axios
+ * Base API Client using native fetch
  * Shared between all resource clients
  */
-import { AxiosInstance, AxiosRequestConfig } from 'axios';
-declare module 'axios' {
-    interface AxiosRequestConfig {
-        skipAuth?: boolean;
-    }
+export interface RequestConfig {
+    headers?: Record<string, string>;
+    skipAuth?: boolean;
+    params?: Record<string, string>;
+    signal?: AbortSignal;
 }
 export interface ApiClientConfig {
     baseURL: string;
@@ -15,7 +15,9 @@ export interface ApiClientConfig {
 }
 export type TokenProvider = () => Promise<string | null>;
 export declare class ApiClient {
-    axios: AxiosInstance;
+    private baseURL;
+    private timeout;
+    private defaultHeaders;
     private currentToken;
     private tokenProvider;
     private requestHistory;
@@ -23,18 +25,20 @@ export declare class ApiClient {
     private readonly MAX_REQUESTS;
     constructor(config: ApiClientConfig);
     setTokenProvider(provider: TokenProvider): void;
-    get<T = unknown>(url: string, config?: AxiosRequestConfig): Promise<T>;
-    post<T = unknown>(url: string, data?: unknown, config?: AxiosRequestConfig): Promise<T>;
-    put<T = unknown>(url: string, data?: unknown, config?: AxiosRequestConfig): Promise<T>;
-    patch<T = unknown>(url: string, data?: unknown, config?: AxiosRequestConfig): Promise<T>;
-    delete<T = unknown>(url: string, config?: AxiosRequestConfig): Promise<T>;
+    get<T = unknown>(url: string, config?: RequestConfig): Promise<T>;
+    post<T = unknown>(url: string, data?: unknown, config?: RequestConfig): Promise<T>;
+    put<T = unknown>(url: string, data?: unknown, config?: RequestConfig): Promise<T>;
+    patch<T = unknown>(url: string, data?: unknown, config?: RequestConfig): Promise<T>;
+    delete<T = unknown>(url: string, config?: RequestConfig): Promise<T>;
     setHeader(key: string, value: string): void;
     removeHeader(key: string): void;
     updateToken(token: string | null): void;
     getCurrentToken(): string | null;
     updateConfig(config: Partial<ApiClientConfig>): void;
+    private request;
+    /** Convert a non-ok fetch response into the appropriate TagadaError subclass. */
+    private toTagadaError;
+    private safeParseJson;
     private checkRequestLimit;
     private cleanupHistory;
-    /** Convert an AxiosError into the appropriate TagadaError subclass. */
-    private toTagadaError;
 }

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

@@ -1,8 +1,7 @@
 /**
- * Base API Client using Axios
+ * Base API Client using native fetch
  * Shared between all resource clients
  */
-import axios from 'axios';
 import { TagadaApiError, TagadaAuthError, TagadaNetworkError, TagadaCircuitBreakerError, TagadaError, TagadaErrorCode, } from '../errors';
 export class ApiClient {
     constructor(config) {
@@ -12,67 +11,16 @@ export class ApiClient {
         this.requestHistory = new Map();
         this.WINDOW_MS = 5000; // 5 seconds window
         this.MAX_REQUESTS = 30; // Max 30 requests per endpoint in window
-        this.axios = axios.create({
-            baseURL: config.baseURL,
-            timeout: config.timeout || 60000, // 60 seconds for payment operations
-            headers: {
-                'Content-Type': 'application/json',
-                ...config.headers,
-            },
-        });
+        this.baseURL = config.baseURL;
+        this.timeout = config.timeout || 60000; // 60 seconds for payment operations
+        this.defaultHeaders = {
+            'Content-Type': 'application/json',
+            ...config.headers,
+        };
         // Cleanup interval for circuit breaker history
         if (typeof setInterval !== 'undefined') {
             setInterval(() => this.cleanupHistory(), 10000);
         }
-        // Request interceptor for logging and auth
-        this.axios.interceptors.request.use(async (config) => {
-            // Circuit Breaker Check
-            if (config.url) {
-                try {
-                    this.checkRequestLimit(`${config.method?.toUpperCase()}:${config.url}`);
-                }
-                catch (error) {
-                    console.error('[SDK] 🛑 Request blocked by Circuit Breaker:', error);
-                    return Promise.reject(error);
-                }
-            }
-            // Check if we need to wait for token
-            if (!config.skipAuth && !this.currentToken && this.tokenProvider) {
-                try {
-                    console.log('[SDK] Waiting for token...');
-                    const token = await this.tokenProvider();
-                    if (token) {
-                        this.updateToken(token);
-                        // Ensure header is set on this specific request config
-                        config.headers['x-cms-token'] = token;
-                    }
-                }
-                catch (error) {
-                    console.error('[SDK] Failed to get token from provider:', error);
-                }
-            }
-            // Ensure token is in headers if we have it (and not skipped)
-            if (!config.skipAuth && this.currentToken) {
-                config.headers['x-cms-token'] = this.currentToken;
-            }
-            console.log(`[SDK] Making ${config.method?.toUpperCase()} request to: ${config.baseURL || ''}${config.url}`);
-            // console.log('[SDK] Request headers:', config.headers);
-            return config;
-        }, (error) => {
-            console.error('[SDK] Request error:', error);
-            return Promise.reject(error instanceof Error ? error : new Error(String(error)));
-        });
-        // Response interceptor — maps Axios errors to structured TagadaError subtypes
-        this.axios.interceptors.response.use((response) => response, (error) => {
-            console.error('[SDK] Response error:', error.message);
-            if (error instanceof TagadaError) {
-                return Promise.reject(error);
-            }
-            if (axios.isAxiosError(error)) {
-                return Promise.reject(this.toTagadaError(error));
-            }
-            return Promise.reject(error instanceof Error ? error : new Error(String(error)));
-        });
     }
     // Set a provider that returns a promise resolving to the token
     // This allows requests to wait until the token is ready
@@ -81,31 +29,26 @@ export class ApiClient {
     }
     // Convenience methods
     async get(url, config) {
-        const response = await this.axios.get(url, config);
-        return response.data;
+        return this.request('GET', url, undefined, config);
     }
     async post(url, data, config) {
-        const response = await this.axios.post(url, data, config);
-        return response.data;
+        return this.request('POST', url, data, config);
     }
     async put(url, data, config) {
-        const response = await this.axios.put(url, data, config);
-        return response.data;
+        return this.request('PUT', url, data, config);
     }
     async patch(url, data, config) {
-        const response = await this.axios.patch(url, data, config);
-        return response.data;
+        return this.request('PATCH', url, data, config);
     }
     async delete(url, config) {
-        const response = await this.axios.delete(url, config);
-        return response.data;
+        return this.request('DELETE', url, undefined, config);
     }
     // Update headers (useful for auth tokens)
     setHeader(key, value) {
-        this.axios.defaults.headers.common[key] = value;
+        this.defaultHeaders[key] = value;
     }
     removeHeader(key) {
-        delete this.axios.defaults.headers.common[key];
+        delete this.defaultHeaders[key];
     }
     // Token management methods (matching old ApiService pattern)
     updateToken(token) {
@@ -125,59 +68,106 @@ export class ApiClient {
     // Update configuration (useful for environment changes)
     updateConfig(config) {
         if (config.baseURL) {
-            this.axios.defaults.baseURL = config.baseURL;
+            this.baseURL = config.baseURL;
         }
         if (config.timeout) {
-            this.axios.defaults.timeout = config.timeout;
+            this.timeout = config.timeout;
         }
         if (config.headers) {
-            Object.assign(this.axios.defaults.headers.common, config.headers);
+            Object.assign(this.defaultHeaders, config.headers);
         }
         console.log('[SDK] ApiClient configuration updated');
     }
-    // Circuit Breaker Implementation
-    checkRequestLimit(key) {
-        const now = Date.now();
-        const history = this.requestHistory.get(key);
-        if (!history) {
-            this.requestHistory.set(key, { count: 1, firstRequestTime: now });
-            return;
+    // ---- Core request method ----
+    async request(method, url, data, config) {
+        const requestKey = `${method}:${url}`;
+        // Circuit Breaker Check
+        try {
+            this.checkRequestLimit(requestKey);
         }
-        if (now - history.firstRequestTime > this.WINDOW_MS) {
-            // Window expired, reset
-            this.requestHistory.set(key, { count: 1, firstRequestTime: now });
-            return;
+        catch (error) {
+            console.error('[SDK] 🛑 Request blocked by Circuit Breaker:', error);
+            throw error;
         }
-        history.count++;
-        if (history.count > this.MAX_REQUESTS) {
-            throw new TagadaCircuitBreakerError(`Circuit Breaker: Too many requests to ${key} (${history.count} in ${this.WINDOW_MS}ms)`);
+        // Token injection
+        if (!config?.skipAuth && !this.currentToken && this.tokenProvider) {
+            try {
+                console.log('[SDK] Waiting for token...');
+                const token = await this.tokenProvider();
+                if (token) {
+                    this.updateToken(token);
+                }
+            }
+            catch (error) {
+                console.error('[SDK] Failed to get token from provider:', error);
+            }
         }
-    }
-    cleanupHistory() {
-        const now = Date.now();
-        for (const [key, history] of this.requestHistory.entries()) {
-            if (now - history.firstRequestTime > this.WINDOW_MS) {
-                this.requestHistory.delete(key);
+        // Build headers
+        const headers = { ...this.defaultHeaders };
+        if (config?.headers) {
+            Object.assign(headers, config.headers);
+        }
+        if (!config?.skipAuth && this.currentToken) {
+            headers['x-cms-token'] = this.currentToken;
+        }
+        // Build URL
+        let fullUrl = `${this.baseURL}${url}`;
+        if (config?.params) {
+            const searchParams = new URLSearchParams(config.params);
+            fullUrl += `?${searchParams.toString()}`;
+        }
+        console.log(`[SDK] Making ${method} request to: ${fullUrl}`);
+        // Timeout via AbortController
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        // Merge signals if caller provided one
+        const signal = config?.signal
+            ? anySignal([config.signal, controller.signal])
+            : controller.signal;
+        try {
+            const fetchOptions = {
+                method,
+                headers,
+                signal,
+            };
+            if (data !== undefined) {
+                fetchOptions.body = JSON.stringify(data);
+            }
+            const response = await fetch(fullUrl, fetchOptions);
+            if (!response.ok) {
+                const errorData = await this.safeParseJson(response);
+                throw this.toTagadaError(response.status, errorData, response.statusText);
             }
+            const responseData = await response.json();
+            return responseData;
         }
-    }
-    /** Convert an AxiosError into the appropriate TagadaError subclass. */
-    toTagadaError(error) {
-        const status = error.response?.status;
-        const data = error.response?.data;
-        const serverMessage = data?.message ??
-            data?.error ??
-            error.message;
-        // No response at all → network-level failure
-        if (!error.response) {
-            if (error.code === 'ECONNABORTED') {
-                return new TagadaApiError('Request timed out', 0, {
+        catch (error) {
+            if (error instanceof TagadaError) {
+                throw error;
+            }
+            // AbortError → timeout (from our controller) or caller abort
+            if (error instanceof DOMException && error.name === 'AbortError') {
+                throw new TagadaApiError('Request timed out', 0, {
                     code: TagadaErrorCode.TIMEOUT,
                     retryable: true,
                 });
             }
-            return new TagadaNetworkError(serverMessage);
+            // TypeError → network failure (DNS, CORS, offline, etc.)
+            if (error instanceof TypeError) {
+                throw new TagadaNetworkError(error.message);
+            }
+            throw error instanceof Error ? error : new Error(String(error));
         }
+        finally {
+            clearTimeout(timeoutId);
+        }
+    }
+    // ---- Error mapping ----
+    /** Convert a non-ok fetch response into the appropriate TagadaError subclass. */
+    toTagadaError(status, data, statusText) {
+        const serverMessage = data?.message ??
+            data?.error ??
+            statusText;
         // Auth failures
         if (status === 401 || status === 403) {
             return new TagadaAuthError(serverMessage, status);
@@ -197,10 +187,62 @@ export class ApiClient {
             });
         }
         // Generic API error
-        return new TagadaApiError(serverMessage, status ?? 0, {
+        return new TagadaApiError(serverMessage, status, {
             code: data?.code ?? TagadaErrorCode.API_ERROR,
             details: data,
-            retryable: (status ?? 0) >= 500,
+            retryable: status >= 500,
+        });
+    }
+    // ---- Helpers ----
+    async safeParseJson(response) {
+        try {
+            return await response.json();
+        }
+        catch {
+            return undefined;
+        }
+    }
+    // Circuit Breaker Implementation
+    checkRequestLimit(key) {
+        const now = Date.now();
+        const history = this.requestHistory.get(key);
+        if (!history) {
+            this.requestHistory.set(key, { count: 1, firstRequestTime: now });
+            return;
+        }
+        if (now - history.firstRequestTime > this.WINDOW_MS) {
+            // Window expired, reset
+            this.requestHistory.set(key, { count: 1, firstRequestTime: now });
+            return;
+        }
+        history.count++;
+        if (history.count > this.MAX_REQUESTS) {
+            throw new TagadaCircuitBreakerError(`Circuit Breaker: Too many requests to ${key} (${history.count} in ${this.WINDOW_MS}ms)`);
+        }
+    }
+    cleanupHistory() {
+        const now = Date.now();
+        for (const [key, history] of this.requestHistory.entries()) {
+            if (now - history.firstRequestTime > this.WINDOW_MS) {
+                this.requestHistory.delete(key);
+            }
+        }
+    }
+}
+/**
+ * Combine multiple AbortSignals into one that aborts when any input signal aborts.
+ */
+function anySignal(signals) {
+    const controller = new AbortController();
+    for (const signal of signals) {
+        if (signal.aborted) {
+            controller.abort(signal.reason);
+            return controller.signal;
+        }
+        signal.addEventListener('abort', () => controller.abort(signal.reason), {
+            once: true,
+            signal: controller.signal,
         });
     }
+    return controller.signal;
 }

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

@@ -4,6 +4,7 @@
  */
 import type { OrderAddress } from '../types';
 import { ApiClient } from './apiClient';
+export type PaymentMethodName = 'card' | 'paypal' | 'klarna' | 'apple_pay' | 'google_pay' | 'link' | 'bridge' | 'whop' | 'zelle' | 'hipay' | 'crypto' | 'convesiopay' | 'oceanpayment' | 'afterpay' | 'ideal' | 'bancontact' | 'giropay' | 'sepa_debit' | (string & {});
 export interface CheckoutLineItem {
     externalProductId?: string | null;
     externalVariantId?: string | null;
@@ -26,6 +27,7 @@ export interface CheckoutInitParams {
         currency?: string;
         locale?: string;
     };
+    enabledOrderBumpOfferIds?: string[];
 }
 export interface UpsellTrigger {
     id: string;
@@ -185,6 +187,7 @@ export interface CheckoutSummaryItem {
     intervalCount?: number;
     totalBillingCycles?: number;
     unitAmountAfterFirstCycle?: number;
+    properties?: Record<string, unknown>;
     orderLineItemProduct: {
         name: string;
     };
@@ -257,6 +260,7 @@ export interface CheckoutSessionPreviewItem {
     totalBillingCycles?: number;
     unitAmountAfterFirstCycle?: number;
     subscriptionSettings?: Record<string, unknown>;
+    properties?: Record<string, unknown>;
     orderLineItemProduct: {
         name: string | null;
     } | null;
@@ -519,4 +523,10 @@ export declare class CheckoutResource {
         success: boolean;
         preview: CheckoutSessionPreview;
     }>;
+    /**
+     * Set selected payment method for a checkout session
+     */
+    setPaymentMethod(checkoutSessionId: string, paymentMethodName: PaymentMethodName): Promise<{
+        success: boolean;
+    }>;
 }

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

@@ -213,4 +213,10 @@ export class CheckoutResource {
     async previewCheckoutSession(params) {
         return this.apiClient.post('/api/v1/checkout-sessions/preview', params);
     }
+    /**
+     * Set selected payment method for a checkout session
+     */
+    async setPaymentMethod(checkoutSessionId, paymentMethodName) {
+        return this.apiClient.post(`/api/v1/checkout-sessions/${checkoutSessionId}/payment-method`, { paymentMethodName });
+    }
 }

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

@@ -9,6 +9,7 @@ export interface PaymentMethod {
     title: string;
     iconUrl: string;
     default: boolean;
+    settings?: Record<string, unknown>;
     metadata?: Record<string, unknown>;
 }
 export interface Address {

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

@@ -1,6 +1,6 @@
 /**
  * Resource Clients
- * Axios-based API clients for all endpoints
+ * Fetch-based API clients for all endpoints
  */
 export * from './apiClient';
 export * from './checkout';

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

@@ -1,6 +1,6 @@
 /**
  * Resource Clients
- * Axios-based API clients for all endpoints
+ * Fetch-based API clients for all endpoints
  */
 export * from './apiClient';
 export * from './checkout';

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

@@ -44,7 +44,7 @@ export class OffersResource {
      *   - Use lineItemId for precise updates (same product, different variants)
      *   - Use productId for simple updates (all items with this product)
      */
-    async previewOffer(offerId, currency = 'USD', lineItems) {
+    async previewOffer(offerId, currency = '', lineItems) {
         console.log('📡 [OffersResource] Calling preview API:', {
             offerId,
             currency,
@@ -68,7 +68,7 @@ export class OffersResource {
      * @param returnUrl - Optional return URL for checkout
      * @param mainOrderId - Optional main order ID (for upsells)
      */
-    async payPreviewedOffer(offerId, currency = 'USD', lineItems, returnUrl, mainOrderId) {
+    async payPreviewedOffer(offerId, currency = '', lineItems, returnUrl, mainOrderId) {
         console.log('💳 [OffersResource] Calling pay-preview API:', {
             offerId,
             currency,
@@ -96,7 +96,7 @@ export class OffersResource {
      * @param returnUrl - Optional return URL for checkout
      * @param mainOrderId - Optional main order ID
      */
-    async toCheckout(offerId, currency = 'USD', lineItems, returnUrl, mainOrderId) {
+    async toCheckout(offerId, currency = '', lineItems, returnUrl, mainOrderId) {
         console.log('🛒 [OffersResource] Calling to-checkout API:', {
             offerId,
             currency,
@@ -218,7 +218,7 @@ export class OffersResource {
      *
      * // By the time page loads, background processing is usually complete
      */
-    async toCheckoutAsync(offerId, currency = 'USD', lineItems, returnUrl, mainOrderId) {
+    async toCheckoutAsync(offerId, currency = '', lineItems, returnUrl, mainOrderId) {
         console.log('🛒 [OffersResource] Calling to-checkout-async API:', {
             offerId,
             currency,