@tagadapay/plugin-sdk 2.8.10 → 3.0.2

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.js

@@ -10,7 +10,7 @@ export class ApiClient {
         // 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.MAX_REQUESTS = 30; // Max 30 requests per endpoint in window
         this.axios = axios.create({
             baseURL: config.baseURL,
             timeout: config.timeout || 30000,

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?: {

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<{

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

@@ -6,6 +6,13 @@ export class OffersResource {
     constructor(apiClient) {
         this.apiClient = apiClient;
     }
+    /**
+     * Get a single offer by ID
+     */
+    async getOfferById(offerId) {
+        const response = await this.apiClient.get(`/api/v1/offers/${offerId}`);
+        return response;
+    }
     /**
      * Get offers for a store
      */
@@ -77,6 +84,24 @@ export class OffersResource {
         });
     }
     /**
+     * Transform offer to checkout session with dynamic variant selection
+     * Uses lineItems from the offer to create a new checkout session
+     */
+    async transformToCheckoutSession(offerId, lineItems, mainOrderId, returnUrl) {
+        const response = await this.apiClient.post(`/api/v1/offers/${offerId}/transform-to-checkout`, {
+            offerId,
+            lineItems,
+            mainOrderId,
+            returnUrl: returnUrl || (typeof window !== 'undefined' ? window.location.origin : ''),
+        });
+        return {
+            checkoutUrl: response.checkoutUrl,
+            checkoutSessionId: response.checkoutSessionId,
+            customerId: response.customerId,
+        };
+    }
+    /**
+     * @deprecated Use transformToCheckoutSession instead
      * Transform offer to checkout session with dynamic variant selection
      */
     async transformToCheckout(offerId, returnUrl) {

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

@@ -7,6 +7,7 @@ import { ApiClient } from './apiClient';
 export interface GetProductsOptions {
     storeId: string;
     productIds?: string[];
+    variantIds?: string[];
     includeVariants?: boolean;
     includePrices?: boolean;
 }
@@ -26,4 +27,8 @@ export declare class ProductsResource {
      * Get multiple products by IDs
      */
     getProductsByIds(productIds: string[], options: GetProductsOptions): Promise<Product[]>;
+    /**
+     * Get products by variant IDs (efficient filtering on the backend)
+     */
+    getProductsByVariantIds(variantIds: string[], options: GetProductsOptions): Promise<Product[]>;
 }

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

@@ -10,9 +10,10 @@ export class ProductsResource {
      * Get all products for a store
      */
     async getProducts(options) {
-        const { storeId, includeVariants = true, includePrices = true } = options;
+        const { storeId, variantIds, includeVariants = true, includePrices = true } = options;
         const response = await this.apiClient.post('/api/v1/products', {
             storeId,
+            variantIds,
             includeVariants,
             includePrices,
         });
@@ -46,4 +47,17 @@ export class ProductsResource {
         const results = await Promise.all(fetchPromises);
         return results.filter((product) => product !== null);
     }
+    /**
+     * Get products by variant IDs (efficient filtering on the backend)
+     */
+    async getProductsByVariantIds(variantIds, options) {
+        const { storeId, includeVariants = true, includePrices = true } = options;
+        const response = await this.apiClient.post('/api/v1/products', {
+            storeId,
+            variantIds, // Backend will filter products that have these variants
+            includeVariants,
+            includePrices,
+        });
+        return Array.isArray(response) ? response : response.items ?? [];
+    }
 }

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

@@ -60,6 +60,7 @@ export interface Currency {
 }
 export interface Store {
     id: string;
+    accountId: string;
     name: string;
     domain: string;
     currency: string;

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

@@ -0,0 +1,23 @@
+/**
+ * Funnel Query Keys - Core SDK (Framework-agnostic)
+ * Standardized query keys for caching funnel data
+ * Can be used with any query library (TanStack Query, SWR, etc.)
+ */
+/**
+ * Query keys for funnel operations
+ * These keys are used for caching and invalidation strategies
+ */
+export declare const funnelQueryKeys: {
+    /**
+     * Key for a specific funnel session
+     */
+    session: (sessionId: string) => readonly ["funnel", "session", string];
+    /**
+     * Key for all funnel sessions
+     */
+    allSessions: () => readonly ["funnel", "sessions"];
+    /**
+     * Key for funnel metadata/configuration
+     */
+    funnelMeta: (funnelId: string) => readonly ["funnel", "meta", string];
+};

package/dist/v2/core/utils/funnelQueryKeys.js

@@ -0,0 +1,23 @@
+/**
+ * Funnel Query Keys - Core SDK (Framework-agnostic)
+ * Standardized query keys for caching funnel data
+ * Can be used with any query library (TanStack Query, SWR, etc.)
+ */
+/**
+ * Query keys for funnel operations
+ * These keys are used for caching and invalidation strategies
+ */
+export const funnelQueryKeys = {
+    /**
+     * Key for a specific funnel session
+     */
+    session: (sessionId) => ['funnel', 'session', sessionId],
+    /**
+     * Key for all funnel sessions
+     */
+    allSessions: () => ['funnel', 'sessions'],
+    /**
+     * Key for funnel metadata/configuration
+     */
+    funnelMeta: (funnelId) => ['funnel', 'meta', funnelId],
+};

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

@@ -10,3 +10,5 @@ export * from './checkout';
 export * from './promotions';
 export * from './postPurchases';
 export * from './orderBump';
+export * from './sessionStorage';
+export * from './funnelQueryKeys';

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

@@ -10,3 +10,5 @@ export * from './checkout';
 export * from './promotions';
 export * from './postPurchases';
 export * from './orderBump';
+export * from './sessionStorage';
+export * from './funnelQueryKeys';