@tagadapay/plugin-sdk 2.8.8 → 2.8.10

package/dist/v2/core/pathRemapping.js

@@ -395,6 +395,57 @@ function matchesPathPattern(pathname, pattern) {
         return { matched: pathname === pattern, params: {} };
     }
 }
+/**
+ * Map parameter names from external pattern to internal pattern
+ * Assumes parameters appear in the same order in both patterns
+ *
+ * @param externalParams - Parameters extracted from external URL
+ * @param externalPattern - External path pattern (e.g., /off1/:lolo)
+ * @param internalPattern - Internal path pattern (e.g., /post/:orderId)
+ * @returns Mapped parameters with internal param names
+ *
+ * @example
+ * ```typescript
+ * mapParamNames(
+ *   {lolo: 'order_123'},
+ *   '/off1/:lolo',
+ *   '/post/:orderId'
+ * )
+ * // Returns: {orderId: 'order_123'}
+ * ```
+ */
+function mapParamNames(externalParams, externalPattern, internalPattern) {
+    // Extract parameter names from patterns
+    const externalParamNames = extractParamNames(externalPattern);
+    const internalParamNames = extractParamNames(internalPattern);
+    // If no params or count mismatch, return original params
+    if (externalParamNames.length === 0 ||
+        externalParamNames.length !== internalParamNames.length) {
+        return externalParams;
+    }
+    // Map parameters by position
+    const mappedParams = {};
+    externalParamNames.forEach((externalName, index) => {
+        const internalName = internalParamNames[index];
+        const value = externalParams[externalName];
+        if (value !== undefined) {
+            mappedParams[internalName] = value;
+        }
+    });
+    return mappedParams;
+}
+/**
+ * Extract parameter names from a path pattern
+ *
+ * @param pattern - Path pattern (e.g., /post/:orderId/item/:itemId)
+ * @returns Array of parameter names (e.g., ['orderId', 'itemId'])
+ */
+function extractParamNames(pattern) {
+    const matches = pattern.match(/:([a-zA-Z0-9_]+)/g);
+    if (!matches)
+        return [];
+    return matches.map(m => m.substring(1)); // Remove ':' prefix
+}
 /**
  * Match a route and extract URL parameters
  *
@@ -496,9 +547,16 @@ export function matchRoute(internalPath) {
             if (externalPattern) {
                 const externalMatch = matchesPathPattern(currentPath, externalPattern);
                 if (externalMatch.matched) {
-                    // Since we enforce matching parameter names in CRM, 
-                    // the params extracted from external pattern will have the correct names
-                    return { matched: true, params: externalMatch.params };
+                    // Map parameter names from external pattern to internal pattern
+                    // External: /off1/:lolo → {lolo: 'value'}
+                    // Internal: /post/:orderId → expects {orderId: 'value'}
+                    console.log('[TagadaPay SDK] 🔄 Mapping params from external to internal pattern');
+                    console.log('[TagadaPay SDK]    External params:', externalMatch.params);
+                    console.log('[TagadaPay SDK]    External pattern:', externalPattern);
+                    console.log('[TagadaPay SDK]    Internal pattern:', internalPath);
+                    const mappedParams = mapParamNames(externalMatch.params, externalPattern, internalPath);
+                    console.log('[TagadaPay SDK]    Mapped params:', mappedParams);
+                    return { matched: true, params: mappedParams };
                 }
             }
             // Fallback: try to extract from current URL using internal pattern

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

@@ -3,15 +3,26 @@
  * Shared between all resource clients
  */
 import { AxiosInstance, AxiosRequestConfig } from 'axios';
+declare module 'axios' {
+    interface AxiosRequestConfig {
+        skipAuth?: boolean;
+    }
+}
 export interface ApiClientConfig {
     baseURL: string;
     headers?: Record<string, string>;
     timeout?: number;
 }
+export type TokenProvider = () => Promise<string | null>;
 export declare class ApiClient {
     axios: AxiosInstance;
     private currentToken;
+    private tokenProvider;
+    private requestHistory;
+    private readonly WINDOW_MS;
+    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>;
@@ -22,4 +33,6 @@ export declare class ApiClient {
     updateToken(token: string | null): void;
     getCurrentToken(): string | null;
     updateConfig(config: Partial<ApiClientConfig>): void;
+    private checkRequestLimit;
+    private cleanupHistory;
 }

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

@@ -6,6 +6,11 @@ import axios from 'axios';
 export class ApiClient {
     constructor(config) {
         this.currentToken = null;
+        this.tokenProvider = null;
+        // Circuit breaker state
+        this.requestHistory = new Map();
+        this.WINDOW_MS = 5000; // 5 seconds window
+        this.MAX_REQUESTS = 5; // Max 5 requests per endpoint in window
         this.axios = axios.create({
             baseURL: config.baseURL,
             timeout: config.timeout || 30000,
@@ -14,13 +19,43 @@ export class ApiClient {
                 ...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((config) => {
-            console.log(`[SDK] Making ${config.method?.toUpperCase()} request to: ${config.baseURL}${config.url}`);
-            console.log('[SDK] Request headers:', config.headers);
-            if (config.data) {
-                console.log('[SDK] Request body:', config.data);
+        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);
@@ -28,14 +63,18 @@ export class ApiClient {
         });
         // Response interceptor for logging
         this.axios.interceptors.response.use((response) => {
-            console.log('[SDK] Response status:', response.status);
-            console.log('[SDK] Response data:', response.data);
+            // console.log('[SDK] Response status:', response.status);
             return response;
         }, (error) => {
-            console.error('[SDK] Response error:', error);
+            console.error('[SDK] Response error:', error.message);
             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
+    setTokenProvider(provider) {
+        this.tokenProvider = provider;
+    }
     // Convenience methods
     async get(url, config) {
         const response = await this.axios.get(url, config);
@@ -69,7 +108,7 @@ export class ApiClient {
         this.currentToken = token;
         if (token) {
             this.setHeader('x-cms-token', token);
-            console.log('[SDK] Token updated in ApiClient:', token.substring(0, 8) + '...');
+            // console.log('[SDK] Token updated in ApiClient:', token.substring(0, 8) + '...');
         }
         else {
             this.removeHeader('x-cms-token');
@@ -92,4 +131,33 @@ export class ApiClient {
         }
         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;
+        }
+        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) {
+            const error = new Error(`Circuit Breaker: Too many requests to ${key} (${history.count} in ${this.WINDOW_MS}ms)`);
+            // Add a property to identify this as a circuit breaker error
+            error.isCircuitBreaker = true;
+            throw 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);
+            }
+        }
+    }
 }

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

@@ -391,6 +391,14 @@ export interface SimpleFunnelContext<TCustom = {}> {
      * Only moves forward, never backward - used for analytics
      */
     furthestStepId?: string;
+    /**
+     * ✅ Environment context (staging or production)
+     * - Determined at session initialization based on entry URL
+     * - Ensures all navigation stays in the same environment
+     * - 'staging': Uses funnel.config (alias domains like funnel--store.cdn.tagadapay.com)
+     * - 'production': Uses funnel.productionConfig (custom domains)
+     */
+    environment?: 'staging' | 'production';
     startedAt: number;
     lastActivityAt: number;
     /**
@@ -400,6 +408,13 @@ export interface SimpleFunnelContext<TCustom = {}> {
      * - Standard keys provide IntelliSense, custom keys always allowed
      */
     resources?: FunnelResourceMap<TCustom>;
+    /**
+     * Static resources from plugin manifest (type: "static")
+     * - Configured in funnel editor's Static Resources tab
+     * - Available at runtime as context.static
+     * - Example: context.static.offer.id for statically configured offers
+     */
+    static?: Record<string, any>;
     /**
      * Legacy/Custom metadata
      * For backward compatibility and flexible unstructured data
@@ -416,6 +431,12 @@ export interface FunnelInitializeRequest {
     funnelId?: string;
     entryStepId?: string;
     existingSessionId?: string;
+    /**
+     * Current URL for session synchronization (browser back/forward handling)
+     * If not provided, SDK will automatically use window.location.href
+     * @example '/checkout', 'https://store.com/payment'
+     */
+    currentUrl?: string;
 }
 export interface FunnelInitializeResponse {
     success: boolean;

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

@@ -76,9 +76,32 @@ export interface PaymentOptions {
     threedsProvider?: 'basis_theory';
     initiatedBy?: 'customer' | 'merchant';
     source?: 'upsell' | 'checkout' | 'offer' | 'missing_club' | 'forced';
+    /** @deprecated Use onPaymentSuccess instead - this will be removed in v3 */
     onSuccess?: (response: PaymentResponse) => void;
+    /** @deprecated Use onPaymentFailed instead - this will be removed in v3 */
     onFailure?: (error: string) => void;
     onRequireAction?: (payment: Payment) => void;
+    /**
+     * Called when payment succeeds (matches FunnelActionType.PAYMENT_SUCCESS)
+     * Use this with useFunnel's next() to navigate to the next step
+     * This replaces automatic redirects to /post or /thankyou
+     */
+    onPaymentSuccess?: (response: PaymentResponse) => void;
+    /**
+     * Called when payment fails (matches FunnelActionType.PAYMENT_FAILED)
+     * Use this to handle retry logic, show errors, or trigger funnel failure flows
+     */
+    onPaymentFailed?: (error: {
+        code: string;
+        message: string;
+        payment?: Payment;
+    }) => void;
+    /**
+     * Disable automatic redirects to /post or /thankyou (default: true)
+     * Set to false only for legacy implementations without funnel orchestrator
+     * The funnel orchestrator handles navigation automatically with useFunnel
+     */
+    disableAutoRedirect?: boolean;
 }
 export interface CardPaymentMethod {
     cardNumber: string;

package/dist/v2/core/types.d.ts

@@ -0,0 +1,271 @@
+/**
+ * Types for the Tagada Pay SDK Core
+ */
+export type Environment = 'production' | 'development' | 'local';
+export interface ApiConfig {
+    baseUrl: string;
+    endpoints: {
+        checkout: {
+            sessionInit: string;
+            sessionStatus: string;
+        };
+        customer: {
+            profile: string;
+            session: string;
+        };
+        store: {
+            config: string;
+        };
+    };
+}
+export interface EnvironmentConfig {
+    environment: Environment;
+    apiConfig: ApiConfig;
+}
+export interface Customer {
+    id: string;
+    email?: string;
+    firstName?: string;
+    lastName?: string;
+    phone?: string;
+    isAuthenticated: boolean;
+    role: 'authenticated' | 'anonymous';
+}
+export type SessionRole = 'authenticated' | 'anonymous';
+export interface Session {
+    sessionId: string;
+    storeId: string;
+    accountId: string;
+    customerId: string;
+    role: SessionRole;
+    isValid: boolean;
+    isLoading: boolean;
+}
+export interface AuthState {
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    customer: Customer | null;
+    session: Session | null;
+}
+export interface Locale {
+    locale: string;
+    language: string;
+    region: string;
+    messages?: Record<string, string>;
+}
+export interface Currency {
+    code: string;
+    symbol: string;
+    name: string;
+}
+export interface Store {
+    id: string;
+    name: string;
+    domain: string;
+    currency: string;
+    locale: string;
+    presentmentCurrencies: string[];
+    chargeCurrencies: string[];
+}
+export interface PickupPoint {
+    id: string;
+    name: string;
+    country: string;
+    postal_code: string;
+    city: string;
+    address: string;
+    address2?: string;
+    house_number?: string;
+    phone?: string;
+    email?: string;
+    latitude?: number;
+    longitude?: number;
+    opening_hours?: string;
+    extra_info?: string;
+}
+export interface OrderItem {
+    id: string;
+    productId: string;
+    variantId: string;
+    quantity: number;
+    unitAmount: number;
+    amount: number;
+    adjustedAmount: number;
+    currency: string;
+    recurring?: boolean;
+    interval?: 'day' | 'week' | 'month' | 'year' | null;
+    intervalCount?: number | null;
+    orderLineItemProduct?: {
+        name: string;
+    };
+    orderLineItemVariant?: {
+        name: string;
+        imageUrl: string | null;
+    };
+    subscriptionSettings?: {
+        trial?: boolean;
+    };
+}
+export interface OrderSummary {
+    currency: string;
+    totalPromotionAmount: number;
+    totalTaxAmount: number;
+    shippingCost: number;
+    shippingCostIsFree: boolean;
+    subtotalAmount: number;
+    subtotalAdjustedAmount: number;
+    totalAdjustedAmount: number;
+    adjustments?: {
+        type: string;
+        amount: number;
+        description: string;
+    }[];
+}
+export interface OrderAddress {
+    firstName: string;
+    lastName: string;
+    address1: string;
+    address2?: string;
+    city: string;
+    state: string;
+    postal: string;
+    country: string;
+    phone?: string;
+}
+export interface Order {
+    id: string;
+    currency: string;
+    paidAmount: number;
+    status: string;
+    createdAt: string;
+    metadata?: Record<string, any>;
+    items: OrderItem[];
+    summaries?: OrderSummary[];
+    shippingAddress?: OrderAddress;
+    billingAddress?: OrderAddress;
+    pickupAddress?: PickupPoint;
+    checkoutSession?: {
+        returnUrl?: string;
+        [key: string]: any;
+    };
+    relatedOrders?: Order[];
+}
+export interface PaymentSummary {
+    id: string;
+    status: string;
+    amount: number;
+    currency: string;
+    createdAt: string;
+    updatedAt?: string;
+    provider?: string;
+    metadata?: Record<string, any>;
+}
+export interface PromotionSummary {
+    id: string;
+    code?: string | null;
+    type?: string;
+    amount?: number;
+    description?: string | null;
+}
+export interface OrderAdjustmentSummary {
+    type: string;
+    amount: number;
+    description: string;
+}
+export interface OrderWithRelations extends Order {
+    customer?: Customer;
+    store?: Store;
+    account?: {
+        id: string;
+        name?: string;
+    } | undefined;
+    items: OrderItem[];
+    payments?: PaymentSummary[];
+    summaries: OrderSummary[];
+    checkoutSession?: {
+        id?: string;
+        returnUrl?: string;
+        [key: string]: any;
+    };
+    promotions?: PromotionSummary[];
+    subscriptions?: any[];
+    adjustments: OrderAdjustmentSummary[];
+}
+export interface CustomerAddress {
+    company?: string;
+    firstName: string;
+    lastName: string;
+    address1: string;
+    city: string;
+    country: string;
+    state: string;
+    postal: string;
+    phone?: string;
+    email?: string;
+}
+export interface CustomerOrderSummary {
+    id: string;
+    storeId: string;
+    accountId: string;
+    createdAt: string;
+    updatedAt: string;
+    status: string;
+    cancelledAt: string | null;
+    cancelledReason: string | null;
+    paidAt: string | null;
+    paidAmount: number | null;
+    openAt: string | null;
+    abandonedAt: string | null;
+    currency: string;
+    externalCustomerType: string | null;
+    externalCustomerId: string | null;
+    externalOrderId: string | null;
+    billingAddress: CustomerAddress;
+    shippingAddress: Omit<CustomerAddress, 'email'>;
+    pickupAddress: any | null;
+    taxesIncluded: boolean;
+    draft: boolean;
+    checkoutSessionId: string | null;
+    sessionHash: string | null;
+    customerId: string;
+    createdFrom: string | null;
+    paymentInstrumentId: string | null;
+    refundedAt: string | null;
+    refundedAmount: number | null;
+    metadata?: Record<string, any>;
+}
+export interface CustomerInfos {
+    customer: {
+        id: string;
+        email: string | null;
+        firstName: string | null;
+        lastName: string | null;
+        externalCustomerId: string | null;
+        lastOrderId: string | null;
+        accountId: string;
+        storeId: string;
+        billingAddress: CustomerAddress | null;
+        shippingAddress: Omit<CustomerAddress, 'email'> | null;
+        currency: string | null;
+        locale: string | null;
+        draft: boolean;
+        acceptsMarketing: boolean;
+        createdAt: string;
+        updatedAt: string;
+        metadata: Record<string, any>;
+        device: any | null;
+        orders: CustomerOrderSummary[];
+        subscriptions: any[];
+    };
+    promotionCodes: any[];
+}
+export interface SessionInitResponse {
+    store: Store;
+    locale: string;
+    messages?: Record<string, string>;
+    customer?: Customer;
+    session?: Session;
+}
+export interface AnonymousTokenResponse {
+    token: string;
+}

package/dist/v2/core/types.js

@@ -0,0 +1,4 @@
+/**
+ * Types for the Tagada Pay SDK Core
+ */
+export {};

package/dist/v2/core/utils/deviceInfo.d.ts

@@ -0,0 +1,39 @@
+export interface DeviceInfo {
+    userAgent: {
+        browser: {
+            name: string;
+            version: string;
+        };
+        os: {
+            name: string;
+            version: string;
+        };
+        device?: {
+            type: string;
+            model: string;
+        };
+    };
+    screenResolution: {
+        width: number;
+        height: number;
+    };
+    timeZone: string;
+}
+/**
+ * Get browser locale
+ */
+export declare function getBrowserLocale(): string;
+/**
+ * Collect all device information
+ */
+export declare function collectDeviceInfo(): DeviceInfo;
+/**
+ * Get URL parameters for session initialization
+ */
+export declare function getUrlParams(): {
+    locale?: string;
+    currency?: string;
+    utmSource?: string;
+    utmMedium?: string;
+    utmCampaign?: string;
+};