@tagadapay/plugin-sdk 2.8.9 → 3.0.1

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

@@ -0,0 +1,84 @@
+import { ApiClient } from './resources/apiClient';
+import { SimpleFunnelContext, FunnelAction, FunnelNavigationResult } from './resources/funnel';
+import { PluginConfig } from './utils/pluginConfig';
+export interface FunnelClientConfig {
+    apiClient: ApiClient;
+    debugMode?: boolean;
+    pluginConfig?: PluginConfig;
+    environment?: {
+        environment: 'local' | 'development' | 'production' | 'staging';
+    };
+    /**
+     * Automatically redirect to result.url after navigation (default: true)
+     * Set to false if you want to handle navigation manually
+     */
+    autoRedirect?: boolean;
+}
+export interface FunnelState {
+    context: SimpleFunnelContext | null;
+    isLoading: boolean;
+    isInitialized: boolean;
+    isNavigating: boolean;
+    error: Error | null;
+    sessionError: Error | null;
+}
+export declare class FunnelClient {
+    state: FunnelState;
+    private resource;
+    private eventDispatcher;
+    private config;
+    private isInitializing;
+    private initializationAttempted;
+    constructor(config: FunnelClientConfig);
+    /**
+     * Update configuration (e.g. when plugin config loads)
+     */
+    setConfig(config: Partial<FunnelClientConfig>): void;
+    /**
+     * Subscribe to state changes
+     */
+    subscribe(listener: (state: FunnelState) => void): () => void;
+    /**
+     * Get current state
+     */
+    getState(): FunnelState;
+    /**
+     * Initialize session with automatic detection (cookies, URL, etc.)
+     */
+    autoInitialize(authSession: {
+        customerId: string;
+        sessionId: string;
+    }, store: {
+        id: string;
+        accountId: string;
+    }, funnelId?: string): Promise<SimpleFunnelContext | null>;
+    /**
+     * Manual initialization
+     */
+    initialize(authSession: {
+        customerId: string;
+        sessionId: string;
+    }, store: {
+        id: string;
+        accountId: string;
+    }, funnelId?: string, entryStepId?: string): Promise<SimpleFunnelContext<{}>>;
+    /**
+     * Navigate
+     */
+    navigate(event: FunnelAction): Promise<FunnelNavigationResult>;
+    /**
+     * Refresh session data
+     */
+    refreshSession(): Promise<SimpleFunnelContext<{}> | undefined>;
+    /**
+     * Update context data
+     */
+    updateContext(updates: Partial<SimpleFunnelContext>): Promise<void>;
+    /**
+     * End session
+     */
+    endSession(): Promise<void>;
+    private updateState;
+    private handleSessionSuccess;
+    private enrichContext;
+}

package/dist/v2/core/funnelClient.js

@@ -0,0 +1,252 @@
+import { FunnelResource } from './resources/funnel';
+import { EventDispatcher } from './utils/eventDispatcher';
+import { getFunnelSessionCookie, setFunnelSessionCookie } from './utils/sessionStorage';
+import { detectEnvironment } from './config/environment';
+export class FunnelClient {
+    constructor(config) {
+        this.eventDispatcher = new EventDispatcher();
+        // Guards
+        this.isInitializing = false;
+        this.initializationAttempted = false;
+        this.config = config;
+        this.resource = new FunnelResource(config.apiClient);
+        this.state = {
+            context: null,
+            isLoading: false,
+            isInitialized: false,
+            isNavigating: false,
+            error: null,
+            sessionError: null,
+        };
+    }
+    /**
+     * Update configuration (e.g. when plugin config loads)
+     */
+    setConfig(config) {
+        this.config = { ...this.config, ...config };
+    }
+    /**
+     * Subscribe to state changes
+     */
+    subscribe(listener) {
+        return this.eventDispatcher.subscribe(listener);
+    }
+    /**
+     * Get current state
+     */
+    getState() {
+        return this.state;
+    }
+    /**
+     * Initialize session with automatic detection (cookies, URL, etc.)
+     */
+    async autoInitialize(authSession, store, funnelId) {
+        if (this.state.context)
+            return this.state.context;
+        if (this.isInitializing)
+            return null;
+        if (this.initializationAttempted)
+            return null;
+        this.initializationAttempted = true;
+        this.isInitializing = true;
+        this.updateState({ isLoading: true, error: null });
+        try {
+            // URL params
+            const params = new URLSearchParams(typeof window !== 'undefined' ? window.location.search : '');
+            const urlFunnelId = params.get('funnelId');
+            const effectiveFunnelId = urlFunnelId || funnelId;
+            let existingSessionId = params.get('funnelSessionId');
+            // Cookie fallback
+            if (!existingSessionId) {
+                existingSessionId = getFunnelSessionCookie() || null;
+            }
+            if (this.config.debugMode) {
+                console.log('🚀 [FunnelClient] Auto-initializing...', { existingSessionId, effectiveFunnelId });
+            }
+            // Note: We proceed even without funnelId/sessionId - the backend will create a new anonymous session if needed
+            const response = await this.resource.initialize({
+                cmsSession: {
+                    customerId: authSession.customerId,
+                    sessionId: authSession.sessionId,
+                    storeId: store.id,
+                    accountId: store.accountId,
+                },
+                funnelId: effectiveFunnelId,
+                existingSessionId: existingSessionId || undefined,
+                currentUrl: typeof window !== 'undefined' ? window.location.href : undefined,
+            });
+            if (response.success && response.context) {
+                const enriched = this.enrichContext(response.context);
+                this.handleSessionSuccess(enriched);
+                return enriched;
+            }
+            else {
+                throw new Error(response.error || 'Failed to initialize funnel session');
+            }
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.updateState({ error: err, isLoading: false });
+            if (this.config.debugMode) {
+                console.error('❌ [FunnelClient] Init failed:', err);
+            }
+            throw err;
+        }
+        finally {
+            this.isInitializing = false;
+        }
+    }
+    /**
+     * Manual initialization
+     */
+    async initialize(authSession, store, funnelId, entryStepId) {
+        this.updateState({ isLoading: true, error: null });
+        try {
+            const response = await this.resource.initialize({
+                cmsSession: {
+                    customerId: authSession.customerId,
+                    sessionId: authSession.sessionId,
+                    storeId: store.id,
+                    accountId: store.accountId,
+                },
+                funnelId: funnelId,
+                entryStepId,
+                currentUrl: typeof window !== 'undefined' ? window.location.href : undefined,
+            });
+            if (response.success && response.context) {
+                const enriched = this.enrichContext(response.context);
+                this.handleSessionSuccess(enriched);
+                return enriched;
+            }
+            else {
+                throw new Error(response.error || 'Failed to initialize');
+            }
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.updateState({ error: err, isLoading: false });
+            throw err;
+        }
+    }
+    /**
+     * Navigate
+     */
+    async navigate(event) {
+        if (!this.state.context?.sessionId)
+            throw new Error('No active session');
+        this.updateState({ isNavigating: true, isLoading: true });
+        try {
+            const response = await this.resource.navigate({
+                sessionId: this.state.context.sessionId,
+                event
+            });
+            if (response.success && response.result) {
+                // Refresh session to get updated context
+                await this.refreshSession();
+                this.updateState({ isNavigating: false, isLoading: false });
+                const result = response.result;
+                // Auto-redirect if enabled (default: true) and result has a URL
+                const shouldAutoRedirect = this.config.autoRedirect !== false; // Default to true
+                if (shouldAutoRedirect && result?.url && typeof window !== 'undefined') {
+                    if (this.config.debugMode) {
+                        console.log('🚀 [FunnelClient] Auto-redirecting to:', result.url);
+                    }
+                    window.location.href = result.url;
+                }
+                return result;
+            }
+            throw new Error(response.error || 'Navigation failed');
+        }
+        catch (error) {
+            const err = error instanceof Error ? error : new Error(String(error));
+            this.updateState({ error: err, isNavigating: false, isLoading: false });
+            throw err;
+        }
+    }
+    /**
+     * Refresh session data
+     */
+    async refreshSession() {
+        if (!this.state.context?.sessionId)
+            return;
+        try {
+            const response = await this.resource.getSession(this.state.context.sessionId);
+            if (response.success && response.context) {
+                const enriched = this.enrichContext(response.context);
+                this.updateState({ context: enriched, sessionError: null });
+                return enriched;
+            }
+        }
+        catch (error) {
+            this.updateState({ sessionError: error instanceof Error ? error : new Error(String(error)) });
+        }
+    }
+    /**
+     * Update context data
+     */
+    async updateContext(updates) {
+        if (!this.state.context?.sessionId)
+            throw new Error('No active session');
+        this.updateState({ isLoading: true });
+        try {
+            const response = await this.resource.updateContext(this.state.context.sessionId, { contextUpdates: updates });
+            if (response.success) {
+                await this.refreshSession();
+            }
+            else {
+                throw new Error(response.error || 'Failed to update context');
+            }
+        }
+        finally {
+            this.updateState({ isLoading: false });
+        }
+    }
+    /**
+     * End session
+     */
+    async endSession() {
+        if (!this.state.context?.sessionId)
+            return;
+        try {
+            await this.resource.endSession(this.state.context.sessionId);
+        }
+        finally {
+            this.state.context = null;
+            this.updateState({ context: null, isInitialized: false });
+            if (typeof document !== 'undefined') {
+                // Clear cookie via import or manually if needed, but we have utility for that
+                // We should probably import clearFunnelSessionCookie
+            }
+        }
+    }
+    // Private helpers
+    updateState(updates) {
+        this.state = { ...this.state, ...updates };
+        this.eventDispatcher.notify(this.state);
+    }
+    handleSessionSuccess(context) {
+        setFunnelSessionCookie(context.sessionId);
+        this.updateState({
+            context,
+            isLoading: false,
+            isInitialized: true,
+            error: null,
+            sessionError: null
+        });
+    }
+    enrichContext(ctx) {
+        const env = this.config.environment?.environment || detectEnvironment();
+        if (env !== 'local')
+            return ctx;
+        const localResources = this.config.pluginConfig?.staticResources || {};
+        if (Object.keys(localResources).length === 0)
+            return ctx;
+        return {
+            ...ctx,
+            static: {
+                ...localResources,
+                ...(ctx.static || {})
+            }
+        };
+    }
+}

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

@@ -4,6 +4,8 @@
  */
 export * from './utils';
 export * from './resources';
+export * from './client';
+export * from './funnelClient';
 export * from './pathRemapping';
 export * from './googleAutocomplete';
 export * from './isoData';

package/dist/v2/core/index.js

@@ -6,6 +6,9 @@
 export * from './utils';
 // Export resources (axios-based API clients)
 export * from './resources';
+// Export clients (stateful logic)
+export * from './client';
+export * from './funnelClient';
 // Export path remapping helpers (framework-agnostic)
 export * from './pathRemapping';
 // Export legacy files that are still needed

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

@@ -18,6 +18,9 @@ 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>;
@@ -30,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

@@ -7,6 +7,10 @@ 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 = 30; // Max 30 requests per endpoint in window
         this.axios = axios.create({
             baseURL: config.baseURL,
             timeout: config.timeout || 30000,
@@ -15,8 +19,22 @@ 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(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 {
@@ -113,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

@@ -344,6 +344,7 @@ export interface FunnelNavigationAction {
 }
 export interface FunnelNavigationResult {
     stepId: string;
+    url?: string;
     action: FunnelNavigationAction;
     context: SimpleFunnelContext;
     tracking?: {
@@ -408,6 +409,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

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

@@ -3,44 +3,205 @@
  * Axios-based API client for offers endpoints
  */
 import { ApiClient } from './apiClient';
-export interface OfferItem {
+import type { CheckoutSessionState, OrderSummary, OrderSummaryItem, VariantOption } from './postPurchases';
+export type { CheckoutSessionState, OrderSummary, OrderSummaryItem, VariantOption };
+/**
+ * Currency option with rate, amount, and lock info
+ */
+export interface OfferCurrencyOption {
+    rate: number;
+    amount: number;
+    lock?: boolean;
+    date?: string;
+}
+/**
+ * Product info within an offer
+ */
+export interface OfferProduct {
+    id: string;
+    name: string;
+    description: string | null;
+    storeId?: string;
+    externalProductId?: string | null;
+    externalCollectionIds?: string[] | null;
+    active?: boolean;
+    isShippable?: boolean;
+    isTaxable?: boolean;
+    taxCategory?: string;
+    unitLabel?: string;
+    accountingCode?: string;
+    accountId?: string;
+    autoSync?: boolean;
+    creditPrice?: number | null;
+    createdAt?: string;
+    updatedAt?: string;
+    storefrontRawData?: any;
+}
+/**
+ * Variant info within an offer
+ */
+export interface OfferVariant {
+    id: string;
+    productId?: string;
+    default?: boolean;
+    name: string;
+    description?: string | null;
+    sku?: string;
+    externalVariantId?: string | null;
+    price?: number | null;
+    currency?: string | null;
+    compareAtPrice?: number | null;
+    grams?: number | null;
+    imageUrl: string | null;
+    active?: boolean;
+    accountId?: string | null;
+    creditPrice?: number | null;
+    createdAt?: string;
+    updatedAt?: string;
+    product?: OfferProduct | null;
+}
+/**
+ * Price info within an offer line item
+ */
+export interface OfferLineItemPrice {
     id: string;
+    createdAt?: string;
+    updatedAt?: string;
+    accountId?: string;
+    productId?: string;
+    variantId: string;
+    default?: boolean;
+    currencyOptions: Record<string, OfferCurrencyOption>;
+    recurring?: boolean;
+    billingTiming?: string;
+    interval?: string;
+    intervalCount?: number;
+    rebillWithOrder?: boolean;
+    rebillMode?: string | null;
+    rebillStepIntervalMs?: number | null;
+    isExternalSellingPlan?: boolean;
+    isInternalSellingPlan?: boolean;
+    shopifySellingPlanId?: string | null;
+    creditsPerRebill?: number | null;
+    deliverySettings?: Record<string, any>;
+    priceSettings?: Record<string, any>;
+    variant?: OfferVariant | null;
+}
+/**
+ * Line item within an offer
+ */
+export interface OfferLineItem {
+    id: string;
+    offerId?: string;
+    quantity: number;
+    priceId?: string;
+    variantId?: string;
+    productId?: string;
+    price: OfferLineItemPrice | null;
+}
+/**
+ * Summary item within an offer summary
+ */
+export interface OfferSummaryItem {
+    id: string;
+    productId: string;
+    variantId: string;
+    priceId?: string;
     product: {
         name: string;
         description: string;
     };
     variant: {
         name: string;
-        imageUrl: string;
+        description?: string;
+        imageUrl: string | null;
+        grams?: number | null;
     };
-    quantity: number;
+    sku?: string;
     unitAmount: number;
+    quantity: number;
     amount: number;
     adjustedAmount: number;
     currency: string;
+    adjustments?: any[];
+    recurring?: boolean;
+    rebillMode?: string | null;
+    interval?: string;
+    intervalCount?: number;
+    totalBillingCycles?: number;
+    unitAmountAfterFirstCycle?: number;
+    isExternalSellingPlan?: boolean;
+    isInternalSellingPlan?: boolean;
+    deliverySettings?: Record<string, any>;
+    priceSettings?: Record<string, any>;
+    orderLineItemProduct?: {
+        name: string;
+    };
+    orderLineItemVariant?: {
+        name: string;
+        imageUrl: string | null;
+    };
+    metadata?: Record<string, any>;
 }
+/**
+ * Offer summary containing items and totals
+ */
 export interface OfferSummary {
-    items: OfferItem[];
+    items: OfferSummaryItem[];
+    totalWeight?: number;
+    subtotalAmount?: number;
+    lineItemsPromotionAmount?: number;
+    subtotalAdjustedAmount?: number;
+    totalPromotionAmount: number;
+    lineItemsTaxAmount?: number;
+    totalTaxAmount?: number;
+    shippingCost?: number;
+    shippingCostIsFree?: boolean;
     totalAmount: number;
     totalAdjustedAmount: number;
-    totalPromotionAmount: number;
-    currency: string;
     adjustments: {
         type: string;
         description: string;
         amount: number;
     }[];
+    currency: string;
+    _consolidated?: boolean;
+}
+/**
+ * Offer promotion association
+ */
+export interface OfferPromotion {
+    id: string;
+    promotionId: string;
+    promotion?: {
+        id: string;
+        name: string;
+        code?: string | null;
+        automatic?: boolean;
+    };
 }
-import type { CurrencyOptions, VariantOption, OrderSummaryItem, OrderSummary, CheckoutSessionState } from './postPurchases';
-export type { CurrencyOptions, VariantOption, OrderSummaryItem, OrderSummary, CheckoutSessionState };
+/**
+ * Main Offer type
+ */
 export interface Offer {
     id: string;
+    createdAt?: string;
+    updatedAt?: string;
+    storeId?: string;
+    type?: string;
     titleTrans: Record<string, string>;
+    expiryDate?: string | null;
     summaries: OfferSummary[];
+    offerLineItems?: OfferLineItem[];
+    promotions?: OfferPromotion[];
 }
 export declare class OffersResource {
     private apiClient;
     constructor(apiClient: ApiClient);
+    /**
+     * Get a single offer by ID
+     */
+    getOfferById(offerId: string): Promise<Offer>;
     /**
      * Get offers for a store
      */
@@ -70,6 +231,19 @@ export declare class OffersResource {
      */
     payOffer(offerId: string, orderId?: string): Promise<any>;
     /**
+     * Transform offer to checkout session with dynamic variant selection
+     * Uses lineItems from the offer to create a new checkout session
+     */
+    transformToCheckoutSession(offerId: string, lineItems: {
+        variantId: string;
+        quantity: number;
+    }[], mainOrderId: string, returnUrl?: string): Promise<{
+        checkoutUrl: string;
+        checkoutSessionId?: string;
+        customerId?: string;
+    }>;
+    /**
+     * @deprecated Use transformToCheckoutSession instead
      * Transform offer to checkout session with dynamic variant selection
      */
     transformToCheckout(offerId: string, returnUrl?: string): Promise<{