@tagadapay/plugin-sdk 2.8.7 → 2.8.9

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

@@ -6,6 +6,7 @@ import axios from 'axios';
 export class ApiClient {
     constructor(config) {
         this.currentToken = null;
+        this.tokenProvider = null;
         this.axios = axios.create({
             baseURL: config.baseURL,
             timeout: config.timeout || 30000,
@@ -15,12 +16,28 @@ export class ApiClient {
             },
         });
         // 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) => {
+            // 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 +45,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 +90,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');

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

@@ -33,13 +33,202 @@ export declare enum FunnelActionType {
 export type NextAction<T> = T & {
     [key: string]: any;
 };
-export interface DirectNavigationActionData {
+/**
+ * Base resource data type - all resources must have an id and optional metadata
+ */
+export interface FunnelResourceData {
+    id: string;
+    [key: string]: any;
+}
+/**
+ * Resource metadata for tracking, versioning, and relationships
+ */
+export interface ResourceMetadata {
+    /** Plugin that created this resource */
+    source?: string;
+    /** Schema version for this resource */
+    version?: string;
+    /** Timestamp when resource was created */
+    timestamp?: number;
+    /** Scope: how long should this resource persist */
+    scope?: 'global' | 'session' | 'step' | 'ephemeral';
+    /** Tags for categorization and filtering */
+    tags?: string[];
+    /** Related resource IDs (for relationships) */
+    relatedTo?: string[];
+    /** Custom metadata */
+    [key: string]: any;
+}
+/**
+ * Wrapped resource with metadata
+ */
+export interface ResourceWithMetadata<T extends FunnelResourceData = FunnelResourceData> {
+    data: T;
+    meta: ResourceMetadata;
+}
+/**
+ * Standard resource types for e-commerce (provides IntelliSense)
+ * These are SUGGESTIONS, not limitations - any key is allowed via index signature
+ */
+export interface StandardResourceKeys {
+    order?: FunnelResourceData;
+    customer?: FunnelResourceData;
+    payment?: FunnelResourceData;
+    checkout?: FunnelResourceData;
+    cart?: FunnelResourceData;
+    subscription?: FunnelResourceData;
+    product?: FunnelResourceData;
+    variant?: FunnelResourceData;
+    mainOrder?: FunnelResourceData;
+    upsellOrder?: FunnelResourceData;
+    downsellOrder?: FunnelResourceData;
+    orders?: FunnelResourceData[];
+    customers?: FunnelResourceData[];
+    payments?: FunnelResourceData[];
+}
+/**
+ * Flexible resource map supporting:
+ * 1. Single resources (order)
+ * 2. Collections (orders[])
+ * 3. Wrapped resources with metadata
+ * 4. Completely custom keys
+ *
+ * @example Simple usage (backward compatible)
+ * ```typescript
+ * resources: {
+ *   order: { id: '123', amount: 100 }
+ * }
+ * ```
+ *
+ * @example Multiple instances via collections
+ * ```typescript
+ * resources: {
+ *   order: { id: 'main' },  // Hot context
+ *   orders: [               // Full collection
+ *     { id: 'main', type: 'initial' },
+ *     { id: 'upsell1', type: 'addon' }
+ *   ]
+ * }
+ * ```
+ *
+ * @example With metadata (opt-in)
+ * ```typescript
+ * resources: {
+ *   order: {
+ *     data: { id: '123', amount: 100 },
+ *     meta: { source: 'checkout-plugin', version: '2.0' }
+ *   }
+ * }
+ * ```
+ *
+ * @example Typed resources (opt-in strict typing)
+ * ```typescript
+ * interface MyResources {
+ *   order: Order;  // Your typed Order interface
+ *   customer: Customer;
+ * }
+ *
+ * const result = await funnel.next<MyResources>({
+ *   type: 'payment_success',
+ *   data: {
+ *     resources: {
+ *       order: { id: '123', amount: 100 } // ✅ Type-checked!
+ *     }
+ *   }
+ * });
+ * ```
+ */
+export type FunnelResourceMap<TCustom = {}> = StandardResourceKeys & {
+    /**
+     * Fully extensible - any key allowed
+     * Value can be:
+     * - Single resource: { id: '...' }
+     * - Collection: [{ id: '...' }, ...]
+     * - Wrapped: { data: {...}, meta: {...} }
+     */
+    [key: string]: FunnelResourceData | FunnelResourceData[] | ResourceWithMetadata | ResourceWithMetadata[] | undefined;
+} & TCustom;
+/**
+ * Typed resources structure for funnel actions
+ *
+ * 💡 RESOURCE PROTOCOL: Flexible & Scalable
+ *
+ * The system supports multiple patterns for maximum flexibility:
+ *
+ * 1. **Simple Pattern** (Default - Backward Compatible):
+ *    ```typescript
+ *    resources: { order: { id: '123' } }
+ *    ```
+ *
+ * 2. **Aliasing Pattern** (For Hot + Named Context):
+ *    ```typescript
+ *    resources: {
+ *      order: { id: '123' },      // Hot context (latest)
+ *      mainOrder: { id: '123' }   // Named (persistent)
+ *    }
+ *    ```
+ *
+ * 3. **Collection Pattern** (For Multiple Instances):
+ *    ```typescript
+ *    resources: {
+ *      orders: [
+ *        { id: 'main', label: 'Initial Order' },
+ *        { id: 'upsell1', label: 'Upsell #1' }
+ *      ]
+ *    }
+ *    ```
+ *
+ * 4. **Metadata Pattern** (For Versioning/Tracking):
+ *    ```typescript
+ *    resources: {
+ *      order: {
+ *        data: { id: '123', amount: 100 },
+ *        meta: { version: '2.0', source: 'checkout' }
+ *      }
+ *    }
+ *    ```
+ *
+ * 5. **Namespaced Pattern** (For Collision Prevention):
+ *    ```typescript
+ *    resources: {
+ *      'checkout:order': { id: '123' },
+ *      'subscription:order': { id: '456' }
+ *    }
+ *    ```
+ *
+ * 6. **Typed Pattern** (For Strict Type Safety):
+ *    ```typescript
+ *    interface StrictResources {
+ *      order: Order;  // Your interface
+ *      customer: Customer;
+ *    }
+ *    funnel.next<StrictResources>({ ... })
+ *    ```
+ *
+ * All patterns work together - choose what fits your use case!
+ */
+export interface FunnelActionResources<TCustom = {}> {
+    /**
+     * Resource map - infinitely extensible
+     * - Standard keys provide IntelliSense
+     * - Custom keys allowed via index signature
+     * - Supports single resources, collections, and metadata
+     * - Optional: pass generic for strict typing
+     */
+    resources?: FunnelResourceMap<TCustom>;
+    /**
+     * Legacy top-level data (backward compatible)
+     * Will be automatically migrated to resources by orchestrator
+     */
+    [key: string]: any;
+}
+export interface DirectNavigationActionData extends FunnelActionResources {
     targetStepId: string;
 }
-export interface BackNavigationActionData {
+export interface BackNavigationActionData extends FunnelActionResources {
     targetStepId: string;
 }
-export interface PaymentSuccessActionData {
+export interface PaymentSuccessActionData extends FunnelActionResources {
     payment: {
         id: string;
         status: string;
@@ -53,34 +242,30 @@ export interface PaymentSuccessActionData {
         currency: string;
         [key: string]: any;
     };
-    [key: string]: any;
 }
-export interface PaymentFailedActionData {
+export interface PaymentFailedActionData extends FunnelActionResources {
     payment: {
         id: string;
         status: string;
         error?: string;
         [key: string]: any;
     };
-    [key: string]: any;
 }
-export interface OfferAcceptedActionData {
+export interface OfferAcceptedActionData extends FunnelActionResources {
     offer: {
         accepted: boolean;
         offerId?: string;
         [key: string]: any;
     };
-    [key: string]: any;
 }
-export interface OfferDeclinedActionData {
+export interface OfferDeclinedActionData extends FunnelActionResources {
     offer: {
         declined: boolean;
         offerId?: string;
         [key: string]: any;
     };
-    [key: string]: any;
 }
-export interface CartUpdatedActionData {
+export interface CartUpdatedActionData extends FunnelActionResources {
     cart: {
         hasSpecificItem?: boolean;
         itemIds?: string[];
@@ -88,13 +273,11 @@ export interface CartUpdatedActionData {
         total?: number;
         [key: string]: any;
     };
-    [key: string]: any;
 }
-export interface FormSubmitActionData {
+export interface FormSubmitActionData extends FunnelActionResources {
     form?: {
         [key: string]: any;
     };
-    [key: string]: any;
 }
 /**
  * Base properties shared by all FunnelAction types
@@ -149,7 +332,10 @@ export type FunnelAction = BaseFunnelAction & (({
     data: NextAction<CartUpdatedActionData>;
 }) | ({
     type: FunnelActionType.CUSTOM;
-    data: NextAction<any>;
+    data: NextAction<FunnelActionResources>;
+}) | ({
+    type: string;
+    data?: NextAction<FunnelActionResources>;
 }));
 export interface FunnelNavigationAction {
     type: 'redirect' | 'replace' | 'push' | 'external' | 'none';
@@ -167,7 +353,33 @@ export interface FunnelNavigationResult {
         timestamp: string;
     };
 }
-export interface SimpleFunnelContext {
+/**
+ * Funnel context available to plugins
+ * Contains current state, resources, and metadata about the funnel session
+ *
+ * @example Basic usage
+ * ```typescript
+ * const context = await funnel.getContext();
+ * const orderId = context.resources?.order?.id;
+ * ```
+ *
+ * @example Typed usage (opt-in strict typing)
+ * ```typescript
+ * interface MyResources {
+ *   order: Order;
+ *   customer: Customer;
+ * }
+ * const context = await funnel.getContext<MyResources>();
+ * const total = context.resources?.order.amount; // ✅ Type-safe!
+ * ```
+ *
+ * @example Collection access
+ * ```typescript
+ * const allOrders = context.resources?.orders; // FunnelResourceData[]
+ * const mainOrder = allOrders?.find(o => o.id === 'main');
+ * ```
+ */
+export interface SimpleFunnelContext<TCustom = {}> {
     customerId: string;
     storeId: string;
     sessionId: string;
@@ -179,8 +391,27 @@ export interface SimpleFunnelContext {
      * 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;
+    /**
+     * Typed resources map - infinitely extensible
+     * - Single resources, collections, or wrapped with metadata
+     * - Pass generic for strict typing: SimpleFunnelContext<MyResources>
+     * - Standard keys provide IntelliSense, custom keys always allowed
+     */
+    resources?: FunnelResourceMap<TCustom>;
+    /**
+     * Legacy/Custom metadata
+     * For backward compatibility and flexible unstructured data
+     */
     metadata?: Record<string, any>;
 }
 export interface FunnelInitializeRequest {
@@ -193,6 +424,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;