@tagadapay/plugin-sdk 2.8.8 → 2.8.9

package/dist/v2/core/client.js

@@ -0,0 +1,386 @@
+import { ApiClient } from './resources/apiClient';
+import { detectEnvironment, getEnvironmentConfig } from './config/environment';
+import { loadPluginConfig } from './utils/pluginConfig';
+import { collectDeviceInfo, getBrowserLocale, getUrlParams } from './utils/deviceInfo';
+import { decodeJWTClient, isTokenExpired } from './utils/jwtDecoder';
+import { getClientToken, setClientToken } from './utils/tokenStorage';
+import { EventDispatcher } from './utils/eventDispatcher';
+export class TagadaClient {
+    constructor(config = {}) {
+        this.eventDispatcher = new EventDispatcher();
+        this.tokenPromise = null;
+        this.tokenResolver = null;
+        this.config = config;
+        this.instanceId = Math.random().toString(36).substr(2, 9);
+        this.boundHandleStorageChange = this.handleStorageChange.bind(this);
+        if (this.config.debugMode) {
+            console.log(`[TagadaClient ${this.instanceId}] Initializing...`);
+        }
+        // Initialize default state
+        const env = this.resolveEnvironment();
+        const envConfig = getEnvironmentConfig(env);
+        this.state = {
+            auth: {
+                isAuthenticated: false,
+                isLoading: false,
+                customer: null,
+                session: null,
+            },
+            session: null,
+            customer: null,
+            locale: {
+                locale: 'en-US',
+                language: 'en',
+                region: 'US',
+                messages: {},
+            },
+            currency: {
+                code: 'USD',
+                symbol: '$',
+                name: 'US Dollar',
+            },
+            store: null,
+            environment: envConfig,
+            isLoading: true,
+            isInitialized: false,
+            isSessionInitialized: false,
+            pluginConfig: { basePath: '/', config: {} },
+            pluginConfigLoading: !config.rawPluginConfig,
+            debugMode: config.debugMode ?? env !== 'production',
+            token: null,
+        };
+        // Initialize API Client
+        this.apiClient = new ApiClient({
+            baseURL: envConfig.apiConfig.baseUrl,
+        });
+        // Setup token waiting mechanism
+        this.apiClient.setTokenProvider(this.waitForToken.bind(this));
+        // Listen for storage changes (cross-tab sync)
+        if (typeof window !== 'undefined') {
+            window.addEventListener('storage', this.boundHandleStorageChange);
+        }
+        // Start initialization
+        this.initialize();
+    }
+    /**
+     * Cleanup client resources
+     */
+    destroy() {
+        if (typeof window !== 'undefined') {
+            window.removeEventListener('storage', this.boundHandleStorageChange);
+        }
+        if (this.state.debugMode) {
+            console.log(`[TagadaClient ${this.instanceId}] Destroyed`);
+        }
+        this.eventDispatcher.clear();
+    }
+    /**
+     * Handle storage changes (e.g. token update in another tab)
+     */
+    handleStorageChange() {
+        const storedToken = getClientToken();
+        // Avoid unnecessary re-initialization if token hasn't changed
+        if (storedToken === this.state.token) {
+            if (this.state.debugMode) {
+                console.log(`[TagadaClient ${this.instanceId}] Token unchanged (ignoring event)`);
+            }
+            return;
+        }
+        // Re-run initialization when token may have changed
+        if (this.state.debugMode) {
+            console.log(`[TagadaClient ${this.instanceId}] Storage changed, re-initializing token...`);
+        }
+        this.initializeToken();
+    }
+    /**
+     * Subscribe to state changes
+     */
+    subscribe(listener) {
+        return this.eventDispatcher.subscribe(listener);
+    }
+    /**
+     * Get current state
+     */
+    getState() {
+        return this.state;
+    }
+    /**
+     * Update state and notify listeners
+     */
+    updateState(updates) {
+        this.state = { ...this.state, ...updates };
+        this.eventDispatcher.notify(this.state);
+    }
+    /**
+     * Resolve environment
+     */
+    resolveEnvironment() {
+        if (this.config.environment)
+            return this.config.environment;
+        return detectEnvironment();
+    }
+    /**
+     * Main initialization flow
+     */
+    async initialize() {
+        try {
+            // 1. Load Plugin Config
+            await this.initializePluginConfig();
+            // 2. Initialize Token (Background or Blocking based on config)
+            if (this.state.pluginConfig.storeId) {
+                await this.initializeToken();
+            }
+            else {
+                console.warn('[TagadaClient] No store ID found in plugin config. Skipping token initialization.');
+                this.updateState({ isLoading: false, isInitialized: true });
+            }
+        }
+        catch (error) {
+            console.error('[TagadaClient] Initialization failed:', error);
+            this.updateState({ isLoading: false, isInitialized: true });
+        }
+    }
+    /**
+     * Load plugin configuration
+     */
+    async initializePluginConfig() {
+        if (!this.state.pluginConfigLoading)
+            return;
+        try {
+            const configVariant = this.config.localConfig || 'default';
+            const config = await loadPluginConfig(configVariant, this.config.rawPluginConfig);
+            this.updateState({
+                pluginConfig: config,
+                pluginConfigLoading: false,
+            });
+            if (this.state.debugMode) {
+                console.log('[TagadaClient] Plugin config loaded:', config);
+            }
+        }
+        catch (error) {
+            console.error('[TagadaClient] Failed to load plugin config:', error);
+            this.updateState({
+                pluginConfig: { basePath: '/', config: {} },
+                pluginConfigLoading: false,
+            });
+        }
+    }
+    /**
+     * Initialize token and session
+     */
+    async initializeToken() {
+        // Check for existing token in URL or storage
+        const existingToken = getClientToken();
+        const urlParams = new URLSearchParams(typeof window !== 'undefined' ? window.location.search : '');
+        const queryToken = urlParams.get('token');
+        if (this.state.debugMode) {
+            console.log(`[TagadaClient ${this.instanceId}] Initializing token...`, {
+                hasExistingToken: !!existingToken,
+                hasQueryToken: !!queryToken
+            });
+        }
+        let tokenToUse = null;
+        let shouldPersist = false;
+        if (queryToken) {
+            tokenToUse = queryToken;
+            shouldPersist = true;
+        }
+        else if (existingToken && !isTokenExpired(existingToken)) {
+            tokenToUse = existingToken;
+        }
+        if (tokenToUse) {
+            this.setToken(tokenToUse);
+            // Persist token if it came from query (updates localStorage and fires event)
+            // We do this AFTER setToken so state is updated and handleStorageChange sees match
+            if (shouldPersist) {
+                if (this.state.debugMode) {
+                    console.log(`[TagadaClient ${this.instanceId}] Persisting query token to storage...`);
+                }
+                setClientToken(tokenToUse);
+            }
+            const decodedSession = decodeJWTClient(tokenToUse);
+            if (decodedSession) {
+                this.updateState({ session: decodedSession });
+                await this.initializeSession(decodedSession);
+            }
+            else {
+                console.error('[TagadaClient] Failed to decode token');
+                this.updateState({ isInitialized: true, isLoading: false });
+            }
+        }
+        else {
+            // Create anonymous token
+            const storeId = this.state.pluginConfig.storeId;
+            if (storeId) {
+                if (this.state.debugMode) {
+                    console.log(`[TagadaClient ${this.instanceId}] Creating anonymous token for store:`, storeId);
+                }
+                await this.createAnonymousToken(storeId);
+            }
+            else {
+                this.updateState({ isInitialized: true, isLoading: false });
+            }
+        }
+    }
+    /**
+     * Set token and resolve waiting requests
+     */
+    setToken(token) {
+        this.apiClient.updateToken(token);
+        this.updateState({ token });
+        // Notify waiting requests
+        if (this.tokenResolver) {
+            this.tokenResolver(token);
+            this.tokenPromise = null;
+            this.tokenResolver = null;
+        }
+        else {
+            // If we set a token but no one was waiting, ensure future requests don't wait unnecessarily
+            // Actually, if we have a token, the provider won't be called by ApiClient logic if we handle it right.
+            // But to be safe, if we set a token, we can pre-resolve the promise if it exists.
+            // Wait, if tokenPromise exists, tokenResolver must exist.
+        }
+    }
+    /**
+     * Wait for token to be available
+     */
+    waitForToken() {
+        if (this.apiClient.getCurrentToken()) {
+            return Promise.resolve(this.apiClient.getCurrentToken());
+        }
+        if (!this.tokenPromise) {
+            this.tokenPromise = new Promise((resolve) => {
+                this.tokenResolver = resolve;
+            });
+        }
+        return this.tokenPromise;
+    }
+    /**
+     * Create anonymous token
+     */
+    async createAnonymousToken(storeId) {
+        try {
+            if (this.state.debugMode)
+                console.log('[TagadaClient] Creating anonymous token for store:', storeId);
+            // We use fetch directly or ApiClient with skipAuth to avoid waiting for itself
+            const response = await this.apiClient.post('/api/v1/cms/session/anonymous', { storeId, role: 'anonymous' }, { skipAuth: true });
+            this.setToken(response.token);
+            setClientToken(response.token);
+            const decodedSession = decodeJWTClient(response.token);
+            if (decodedSession) {
+                this.updateState({ session: decodedSession });
+                await this.initializeSession(decodedSession);
+            }
+            this.updateState({ isSessionInitialized: true });
+        }
+        catch (error) {
+            console.error('[TagadaClient] Failed to create anonymous token:', error);
+            this.updateState({ isInitialized: true, isLoading: false });
+        }
+    }
+    /**
+     * Initialize session
+     */
+    async initializeSession(sessionData) {
+        try {
+            if (this.state.debugMode) {
+                console.log(`[TagadaClient ${this.instanceId}] Initializing session...`, { sessionId: sessionData.sessionId });
+            }
+            const deviceInfo = collectDeviceInfo();
+            const urlParams = getUrlParams();
+            const browserLocale = getBrowserLocale();
+            const sessionInitData = {
+                storeId: sessionData.storeId,
+                accountId: sessionData.accountId,
+                customerId: sessionData.customerId,
+                role: sessionData.role,
+                browserLocale,
+                queryLocale: urlParams.locale,
+                queryCurrency: urlParams.currency,
+                utmSource: urlParams.utmSource,
+                utmMedium: urlParams.utmMedium,
+                utmCampaign: urlParams.utmCampaign,
+                browser: deviceInfo.userAgent.browser.name,
+                browserVersion: deviceInfo.userAgent.browser.version,
+                os: deviceInfo.userAgent.os.name,
+                osVersion: deviceInfo.userAgent.os.version,
+                deviceType: deviceInfo.userAgent.device?.type,
+                deviceModel: deviceInfo.userAgent.device?.model,
+                screenWidth: deviceInfo.screenResolution.width,
+                screenHeight: deviceInfo.screenResolution.height,
+                timeZone: deviceInfo.timeZone,
+            };
+            const response = await this.apiClient.post('/api/v1/cms/session/init', sessionInitData);
+            // Update state with session data
+            this.updateSessionState(response, sessionData);
+            this.updateState({
+                isInitialized: true,
+                isSessionInitialized: true,
+                isLoading: false,
+            });
+            if (this.state.debugMode)
+                console.log('[TagadaClient] Session initialized successfully');
+        }
+        catch (error) {
+            console.error('[TagadaClient] Error initializing session:', error);
+            this.updateState({
+                isInitialized: true,
+                isLoading: false,
+            });
+        }
+    }
+    updateSessionState(response, sessionData) {
+        // Update Store
+        if (response.store) {
+            const storeData = response.store;
+            const storeConfig = {
+                ...response.store,
+                presentmentCurrencies: storeData.presentmentCurrencies || [response.store.currency || 'USD'],
+                chargeCurrencies: storeData.chargeCurrencies || [response.store.currency || 'USD'],
+            };
+            this.updateState({ store: storeConfig });
+        }
+        // Update Locale
+        const localeConfig = {
+            locale: response.locale,
+            language: response.locale.split('-')[0],
+            region: response.locale.split('-')[1] ?? 'US',
+            messages: response.messages ?? {},
+        };
+        this.updateState({ locale: localeConfig });
+        // Update Currency
+        if (response.store) {
+            const currencyConfig = {
+                code: response.store.currency,
+                symbol: this.getCurrencySymbol(response.store.currency),
+                name: this.getCurrencyName(response.store.currency),
+            };
+            this.updateState({ currency: currencyConfig });
+        }
+        // Update Customer & Auth
+        const authState = {
+            isAuthenticated: response.customer?.isAuthenticated ?? false,
+            isLoading: false,
+            customer: response.customer ?? null,
+            session: sessionData,
+        };
+        this.updateState({
+            customer: response.customer ?? null,
+            auth: authState
+        });
+    }
+    // Helper methods
+    getCurrencySymbol(code) {
+        const symbols = {
+            USD: '$', EUR: '€', GBP: '£', JPY: '¥', CAD: 'C$', AUD: 'A$',
+        };
+        return symbols[code] || code;
+    }
+    getCurrencyName(code) {
+        const names = {
+            USD: 'US Dollar', EUR: 'Euro', GBP: 'British Pound',
+            JPY: 'Japanese Yen', CAD: 'Canadian Dollar', AUD: 'Australian Dollar',
+        };
+        return names[code] || code;
+    }
+}

package/dist/v2/core/config/environment.d.ts

@@ -0,0 +1,22 @@
+import { ApiConfig, Environment, EnvironmentConfig } from '../types';
+/**
+ * Environment configurations for different deployment environments
+ */
+export declare const ENVIRONMENT_CONFIGS: Record<Environment, ApiConfig>;
+/**
+ * Get the environment configuration based on the current environment
+ */
+export declare function getEnvironmentConfig(environment?: Environment): EnvironmentConfig;
+/**
+ * Build a complete API URL from environment config and endpoint path
+ */
+export declare function buildApiUrl(config: EnvironmentConfig, endpointPath: string): string;
+/**
+ * Get a specific endpoint URL
+ */
+export declare function getEndpointUrl(config: EnvironmentConfig, category: keyof ApiConfig['endpoints'], endpoint: string): string;
+/**
+ * Auto-detect environment based on hostname, URL patterns, and deployment context
+ * Works with any build tool or deployment system
+ */
+export declare function detectEnvironment(): Environment;

package/dist/v2/core/config/environment.js

@@ -0,0 +1,140 @@
+import { resolveEnvValue } from '../utils/env';
+/**
+ * Environment configurations for different deployment environments
+ */
+export const ENVIRONMENT_CONFIGS = {
+    production: {
+        baseUrl: 'https://app.tagadapay.com',
+        endpoints: {
+            checkout: {
+                sessionInit: '/api/v1/checkout/session/init',
+                sessionStatus: '/api/v1/checkout/session/status',
+            },
+            customer: {
+                profile: '/api/v1/customer/profile',
+                session: '/api/v1/customer/session',
+            },
+            store: {
+                config: '/api/v1/store/config',
+            },
+        },
+    },
+    development: {
+        baseUrl: 'https://app.tagadapay.dev',
+        endpoints: {
+            checkout: {
+                sessionInit: '/api/v1/checkout/session/init',
+                sessionStatus: '/api/v1/checkout/session/status',
+            },
+            customer: {
+                profile: '/api/v1/customer/profile',
+                session: '/api/v1/customer/session',
+            },
+            store: {
+                config: '/api/v1/store/config',
+            },
+        },
+    },
+    local: {
+        baseUrl: 'http://app.localhost:3000',
+        endpoints: {
+            checkout: {
+                sessionInit: '/api/v1/checkout/session/init',
+                sessionStatus: '/api/v1/checkout/session/status',
+            },
+            customer: {
+                profile: '/api/v1/customer/profile',
+                session: '/api/v1/customer/session',
+            },
+            store: {
+                config: '/api/v1/store/config',
+            },
+        },
+    },
+};
+/**
+ * Get the environment configuration based on the current environment
+ */
+export function getEnvironmentConfig(environment = 'local') {
+    const apiConfig = ENVIRONMENT_CONFIGS[environment];
+    if (!apiConfig) {
+        console.warn(`Unknown environment: ${environment}. Falling back to local.`);
+        return {
+            environment: 'local',
+            apiConfig: ENVIRONMENT_CONFIGS.local,
+        };
+    }
+    return {
+        environment,
+        apiConfig,
+    };
+}
+/**
+ * Build a complete API URL from environment config and endpoint path
+ */
+export function buildApiUrl(config, endpointPath) {
+    return `${config.apiConfig.baseUrl}${endpointPath}`;
+}
+/**
+ * Get a specific endpoint URL
+ */
+export function getEndpointUrl(config, category, endpoint) {
+    const categoryEndpoints = config.apiConfig.endpoints[category];
+    const endpointPath = categoryEndpoints[endpoint];
+    if (!endpointPath) {
+        throw new Error(`Endpoint not found: ${category}.${endpoint}`);
+    }
+    return buildApiUrl(config, endpointPath);
+}
+/**
+ * Auto-detect environment based on hostname, URL patterns, and deployment context
+ * Works with any build tool or deployment system
+ */
+export function detectEnvironment() {
+    // 1. Check environment variables first
+    const envVar = resolveEnvValue('TAGADA_ENVIRONMENT') || resolveEnvValue('TAGADA_ENV');
+    if (envVar) {
+        const normalized = envVar.toLowerCase();
+        if (normalized === 'production' || normalized === 'development' || normalized === 'local') {
+            return normalized;
+        }
+    }
+    // Check if we're in browser
+    if (typeof window === 'undefined') {
+        return 'local'; // SSR fallback
+    }
+    const hostname = window.location.hostname;
+    const href = window.location.href;
+    // Production: deployed to production domains
+    if (hostname === 'app.tagadapay.com' ||
+        hostname.includes('tagadapay.com') ||
+        hostname.includes('yourproductiondomain.com')) {
+        return 'production';
+    }
+    // Development: deployed to staging/dev domains or has dev indicators
+    if (hostname === 'app.tagadapay.dev' ||
+        hostname.includes('tagadapay.dev') || // ✅ app.tagadapay.dev and subdomains
+        hostname.includes('vercel.app') ||
+        hostname.includes('netlify.app') ||
+        hostname.includes('surge.sh') ||
+        hostname.includes('github.io') ||
+        hostname.includes('herokuapp.com') ||
+        hostname.includes('railway.app') ||
+        href.includes('?env=dev') ||
+        href.includes('?dev=true') ||
+        href.includes('#dev')) {
+        return 'development';
+    }
+    // Local: localhost, local IPs, or local domains
+    if (hostname === 'localhost' ||
+        hostname.startsWith('127.') ||
+        hostname.startsWith('192.168.') ||
+        hostname.startsWith('10.') ||
+        hostname.includes('.local') ||
+        hostname === '' ||
+        hostname === '0.0.0.0') {
+        return 'local';
+    }
+    // Default fallback for unknown domains (safer to use development)
+    return 'production';
+}

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,23 @@
  * 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;
     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>;