@tagadapay/plugin-sdk 2.8.8 → 2.8.10

package/dist/v2/core/client.js

@@ -0,0 +1,430 @@
+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;
+        // Track initialization state to prevent infinite loops
+        this.isInitializingSession = false;
+        this.lastSessionInitError = null;
+        this.sessionInitRetryCount = 0;
+        this.MAX_SESSION_INIT_RETRIES = 3;
+        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;
+        }
+        // Prevent infinite loop: Don't re-initialize if we're currently initializing
+        if (this.isInitializingSession) {
+            if (this.state.debugMode) {
+                console.log(`[TagadaClient ${this.instanceId}] Session initialization in progress, skipping storage change`);
+            }
+            return;
+        }
+        // Prevent infinite loop: Don't retry if we've hit max retries
+        if (this.sessionInitRetryCount >= this.MAX_SESSION_INIT_RETRIES && this.lastSessionInitError) {
+            if (this.state.debugMode) {
+                console.error(`[TagadaClient ${this.instanceId}] Max session init retries reached, giving up`, this.lastSessionInitError);
+            }
+            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) {
+        // Prevent concurrent anonymous token creation
+        if (this.isInitializingSession) {
+            if (this.state.debugMode) {
+                console.log(`[TagadaClient ${this.instanceId}] Session initialization in progress, skipping anonymous token creation`);
+            }
+            return;
+        }
+        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) {
+        // Prevent concurrent initialization attempts
+        if (this.isInitializingSession) {
+            if (this.state.debugMode) {
+                console.log(`[TagadaClient ${this.instanceId}] Session initialization already in progress, skipping`);
+            }
+            return;
+        }
+        this.isInitializingSession = true;
+        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);
+            // Success - reset error tracking
+            this.lastSessionInitError = null;
+            this.sessionInitRetryCount = 0;
+            // 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) {
+            // Track error and increment retry count
+            this.lastSessionInitError = error;
+            this.sessionInitRetryCount++;
+            console.error(`[TagadaClient] Error initializing session (attempt ${this.sessionInitRetryCount}/${this.MAX_SESSION_INIT_RETRIES}):`, error);
+            this.updateState({
+                isInitialized: true,
+                isLoading: false,
+            });
+        }
+        finally {
+            // Always release the lock
+            this.isInitializingSession = 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,36 @@
+import { ApiConfig, Environment, EnvironmentConfig } from '../types';
+/**
+ * ⚠️ IMPORTANT: Runtime Environment Detection
+ *
+ * This SDK uses RUNTIME hostname detection, NOT build-time environment variables.
+ * This ensures the SDK always connects to the correct API based on where it's deployed.
+ *
+ * - Production domains → production API
+ * - Dev/staging domains → development API
+ * - Localhost/local IPs → local API (with optional override via window.__TAGADA_ENV__)
+ *
+ * Build-time .env variables (VITE_*, REACT_APP_*, NEXT_PUBLIC_*) are IGNORED
+ * to prevent incorrect API connections when plugins are deployed to different environments.
+ */
+/**
+ * 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 and URL patterns at RUNTIME
+ * ⚠️ IMPORTANT: Ignores build-time .env variables to ensure correct detection in all environments
+ * .env variables are ONLY used for local development via window.__TAGADA_ENV__
+ */
+export declare function detectEnvironment(): Environment;

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

@@ -0,0 +1,155 @@
+/**
+ * ⚠️ IMPORTANT: Runtime Environment Detection
+ *
+ * This SDK uses RUNTIME hostname detection, NOT build-time environment variables.
+ * This ensures the SDK always connects to the correct API based on where it's deployed.
+ *
+ * - Production domains → production API
+ * - Dev/staging domains → development API
+ * - Localhost/local IPs → local API (with optional override via window.__TAGADA_ENV__)
+ *
+ * Build-time .env variables (VITE_*, REACT_APP_*, NEXT_PUBLIC_*) are IGNORED
+ * to prevent incorrect API connections when plugins are deployed to different environments.
+ */
+/**
+ * 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 and URL patterns at RUNTIME
+ * ⚠️ IMPORTANT: Ignores build-time .env variables to ensure correct detection in all environments
+ * .env variables are ONLY used for local development via window.__TAGADA_ENV__
+ */
+export function detectEnvironment() {
+    // Check if we're in browser
+    if (typeof window === 'undefined') {
+        return 'local'; // SSR fallback
+    }
+    const hostname = window.location.hostname;
+    const href = window.location.href;
+    // 1. Check for LOCAL environment first (highest priority for dev)
+    // 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') {
+        // For local development, allow override via window.__TAGADA_ENV__ (injected by dev server)
+        if (typeof window !== 'undefined' && window?.__TAGADA_ENV__?.TAGADA_ENVIRONMENT) {
+            const override = window.__TAGADA_ENV__.TAGADA_ENVIRONMENT.toLowerCase();
+            if (override === 'production' || override === 'development' || override === 'local') {
+                console.log(`[SDK] Local override detected: ${override}`);
+                return override;
+            }
+        }
+        return 'local';
+    }
+    // 2. Production: deployed to production domains
+    if (hostname === 'app.tagadapay.com' ||
+        hostname.includes('tagadapay.com') ||
+        hostname.includes('yourproductiondomain.com')) {
+        return 'production';
+    }
+    // 3. Development: deployed to staging/dev domains or has dev indicators
+    if (hostname === 'app.tagadapay.dev' ||
+        hostname.includes('tagadapay.dev') ||
+        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';
+    }
+    // 4. Default fallback for unknown domains (production is safest)
+    console.warn(`[SDK] Unknown domain: ${hostname}, defaulting to production`);
+    return 'production';
+}