@tagadapay/plugin-sdk 1.0.2

package/dist/react/services/apiService.js

@@ -0,0 +1,168 @@
+'use client';
+import axios from 'axios';
+export class ApiService {
+    constructor(options) {
+        this.config = options.environmentConfig;
+        this.token = options.token || null;
+        this.onTokenUpdate = options.onTokenUpdate;
+        this.onTokenClear = options.onTokenClear;
+    }
+    updateToken(token) {
+        this.token = token;
+    }
+    updateConfig(config) {
+        this.config = config;
+    }
+    /**
+     * Store the store ID in localStorage
+     */
+    storeStoreId(storeId) {
+        try {
+            if (typeof window !== 'undefined' && window.localStorage) {
+                window.localStorage.setItem('tagada_store_id', storeId);
+            }
+        }
+        catch (error) {
+            console.warn('[SDK] Failed to store store ID in localStorage:', error);
+        }
+    }
+    /**
+     * Get the store ID from localStorage
+     */
+    getStoredStoreId() {
+        try {
+            if (typeof window !== 'undefined' && window.localStorage) {
+                return window.localStorage.getItem('tagada_store_id');
+            }
+        }
+        catch (error) {
+            console.warn('[SDK] Failed to get store ID from localStorage:', error);
+        }
+        return null;
+    }
+    /**
+     * Make an authenticated request to the API
+     */
+    async fetch(endpoint, options = {}) {
+        const { method = 'GET', body, headers = {}, params, skipAuth = false, captureErrors = true } = options;
+        // Build the full URL
+        const url = `${this.config.apiConfig.baseUrl}${endpoint}`;
+        // If auth is required and token is not available, throw an error
+        if (!skipAuth && !this.token) {
+            throw new Error('No authentication token available');
+        }
+        try {
+            // Prepare headers
+            const requestHeaders = {
+                'Content-Type': 'application/json',
+                ...headers,
+            };
+            // Add CMS token to headers if available and not skipped
+            if (!skipAuth && this.token) {
+                requestHeaders['x-cms-token'] = this.token;
+            }
+            // Create axios config
+            const config = {
+                method,
+                url,
+                headers: requestHeaders,
+                params,
+                data: body ? (typeof body === 'string' ? body : JSON.stringify(body)) : undefined,
+            };
+            console.log(`[SDK] Making ${method} request to: ${url}`);
+            if (body) {
+                console.log(`[SDK] Request body:`, body);
+            }
+            // Make the request
+            const response = await axios(config);
+            // Check for X-TGD-STOREID header in response and store it
+            const storeIdHeader = response.headers['x-tgd-storeid'] || response.headers['X-TGD-STOREID'];
+            if (storeIdHeader && typeof storeIdHeader === 'string') {
+                console.log(`[SDK] Store ID received from header: ${storeIdHeader}`);
+                this.storeStoreId(storeIdHeader);
+            }
+            console.log(`[SDK] Response status: ${response.status}`);
+            console.log(`[SDK] Response data:`, response.data);
+            return response.data;
+        }
+        catch (error) {
+            if (captureErrors) {
+                console.error(`[SDK] Request failed: ${method} ${url}`, error);
+            }
+            if (axios.isAxiosError(error)) {
+                const axiosError = error;
+                if (axiosError.response?.status === 401) {
+                    // Token might be expired, clear it
+                    if (this.onTokenClear) {
+                        this.onTokenClear();
+                    }
+                }
+                throw new Error(`API request failed: ${axiosError.response?.status} ${axiosError.response?.statusText}`);
+            }
+            throw error;
+        }
+    }
+    /**
+     * Create an anonymous token for the given store
+     */
+    async createAnonymousToken(storeId) {
+        const response = await this.fetch('/api/v1/cms/session/anonymous', {
+            method: 'POST',
+            body: {
+                storeId,
+                role: 'anonymous',
+            },
+            skipAuth: true, // Skip auth for anonymous token creation
+        });
+        return response;
+    }
+    /**
+     * Initialize a CMS session with device info and user data
+     */
+    async initializeSession(sessionData) {
+        console.debug('[API] Initializing session');
+        return this.fetch('/api/v1/cms/session/init', {
+            method: 'POST',
+            body: sessionData,
+            skipAuth: false, // Use the token for session initialization
+        });
+    }
+    /**
+     * Get customer profile
+     */
+    async getCustomerProfile(customerId) {
+        return this.fetch(`/api/v1/customer/profile/${customerId}`);
+    }
+    /**
+     * Get session status
+     */
+    async getSessionStatus(sessionId) {
+        return this.fetch(`/api/v1/customer/session/${sessionId}`, {
+            method: 'GET',
+        });
+    }
+    /**
+     * Update customer information (email, marketing preferences)
+     */
+    async updateCustomer(customerId, data) {
+        return this.fetch(`/api/v1/customers/${customerId}`, {
+            method: 'POST',
+            body: { data },
+        });
+    }
+    /**
+     * Update customer and checkout session information in one request
+     */
+    async updateCustomerAndSessionInfo(checkoutSessionId, data) {
+        return this.fetch(`/api/v1/checkout-sessions/${checkoutSessionId}/customer-and-session-info`, {
+            method: 'POST',
+            body: data,
+        });
+    }
+    /**
+     * Clear the authentication token
+     */
+    clearToken() {
+        this.updateToken(null);
+    }
+}

package/dist/react/types.d.ts

@@ -0,0 +1,151 @@
+/**
+ * Types for the Tagada Pay React SDK
+ */
+export type Environment = 'production' | 'development' | 'local';
+export interface ApiConfig {
+    baseUrl: string;
+    endpoints: {
+        checkout: {
+            sessionInit: string;
+            sessionStatus: string;
+        };
+        customer: {
+            profile: string;
+            session: string;
+        };
+        store: {
+            config: string;
+        };
+    };
+}
+export interface EnvironmentConfig {
+    environment: Environment;
+    apiConfig: ApiConfig;
+}
+export interface Customer {
+    id: string;
+    email?: string;
+    firstName?: string;
+    lastName?: string;
+    phone?: string;
+    isAuthenticated: boolean;
+    role: 'authenticated' | 'anonymous';
+}
+export interface Session {
+    sessionId: string;
+    storeId: string;
+    accountId: string;
+    customerId: string;
+    role: 'authenticated' | 'anonymous';
+    isValid: boolean;
+    isLoading: boolean;
+}
+export interface AuthState {
+    isAuthenticated: boolean;
+    isLoading: boolean;
+    customer: Customer | null;
+    session: Session | null;
+}
+export interface Locale {
+    locale: string;
+    language: string;
+    region: string;
+    messages?: Record<string, string>;
+}
+export interface Currency {
+    code: string;
+    symbol: string;
+    name: string;
+}
+export interface Store {
+    id: string;
+    name: string;
+    domain: string;
+    currency: string;
+    locale: string;
+    presentmentCurrencies: string[];
+    chargeCurrencies: string[];
+}
+export interface PickupPoint {
+    id: string;
+    name: string;
+    country: string;
+    postal_code: string;
+    city: string;
+    address: string;
+    address2?: string;
+    house_number?: string;
+    phone?: string;
+    email?: string;
+    latitude?: number;
+    longitude?: number;
+    opening_hours?: string;
+    extra_info?: string;
+}
+export interface OrderItem {
+    id: string;
+    productId: string;
+    variantId: string;
+    quantity: number;
+    unitAmount: number;
+    amount: number;
+    adjustedAmount: number;
+    currency: string;
+    recurring?: boolean;
+    interval?: 'day' | 'week' | 'month' | 'year' | null;
+    intervalCount?: number | null;
+    orderLineItemProduct?: {
+        name: string;
+    };
+    orderLineItemVariant?: {
+        name: string;
+        imageUrl: string | null;
+    };
+    subscriptionSettings?: {
+        trial?: boolean;
+    };
+}
+export interface OrderSummary {
+    currency: string;
+    totalPromotionAmount: number;
+    totalTaxAmount: number;
+    shippingCost: number;
+    shippingCostIsFree: boolean;
+    subtotalAmount: number;
+    subtotalAdjustedAmount: number;
+    totalAdjustedAmount: number;
+    adjustments?: {
+        type: string;
+        amount: number;
+        description: string;
+    }[];
+}
+export interface OrderAddress {
+    firstName: string;
+    lastName: string;
+    address1: string;
+    address2?: string;
+    city: string;
+    state: string;
+    postal: string;
+    country: string;
+    phone?: string;
+}
+export interface Order {
+    id: string;
+    currency: string;
+    paidAmount: number;
+    status: string;
+    createdAt: string;
+    metadata?: Record<string, any>;
+    items: OrderItem[];
+    summaries?: OrderSummary[];
+    shippingAddress?: OrderAddress;
+    billingAddress?: OrderAddress;
+    pickupAddress?: PickupPoint;
+    checkoutSession?: {
+        returnUrl?: string;
+        [key: string]: any;
+    };
+    relatedOrders?: Order[];
+}

package/dist/react/types.js

@@ -0,0 +1,4 @@
+/**
+ * Types for the Tagada Pay React SDK
+ */
+export {};

package/dist/react/utils/__tests__/urlUtils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/react/utils/__tests__/urlUtils.test.js

@@ -0,0 +1,189 @@
+import { extractCheckoutToken, extractCheckoutTokenFromCurrentUrl, extractCheckoutTokenFromPath, isValidCheckoutToken, extractAndValidateCheckoutToken, getCheckoutToken, buildCheckoutUrl, hasCheckoutToken, } from '../urlUtils';
+// Mock window.location for testing
+const mockLocation = (href) => {
+    Object.defineProperty(window, 'location', {
+        value: { href },
+        writable: true,
+    });
+};
+describe('URL Utilities', () => {
+    const validToken = '0cb592d75aae75e337b7b784f6624dbf';
+    const anotherValidToken = '1234567890abcdef1234567890abcdef';
+    describe('extractCheckoutToken', () => {
+        it('should extract token from full URL', () => {
+            const url = `https://example.com/checkout/${validToken}`;
+            expect(extractCheckoutToken(url)).toBe(validToken);
+        });
+        it('should extract token from path', () => {
+            const path = `/checkout/${validToken}`;
+            expect(extractCheckoutToken(path)).toBe(validToken);
+        });
+        it('should extract token from anywhere in path', () => {
+            const path = `/some/path/${validToken}/other/path`;
+            expect(extractCheckoutToken(path)).toBe(validToken);
+        });
+        it('should extract token from token only', () => {
+            expect(extractCheckoutToken(validToken)).toBe(validToken);
+        });
+        it('should return null for invalid URLs', () => {
+            expect(extractCheckoutToken('https://example.com/checkout')).toBeNull();
+            expect(extractCheckoutToken('invalid-token')).toBeNull();
+            expect(extractCheckoutToken('')).toBeNull();
+            expect(extractCheckoutToken(null)).toBeNull();
+            expect(extractCheckoutToken(undefined)).toBeNull();
+        });
+        it('should normalize token to lowercase', () => {
+            const upperCaseToken = validToken.toUpperCase();
+            expect(extractCheckoutToken(upperCaseToken)).toBe(validToken);
+        });
+        it('should handle multiple tokens and return first match', () => {
+            const path = `/path/${validToken}/another/${anotherValidToken}`;
+            expect(extractCheckoutToken(path)).toBe(validToken);
+        });
+    });
+    describe('extractCheckoutTokenFromCurrentUrl', () => {
+        beforeEach(() => {
+            // Reset window.location mock
+            delete window.location;
+        });
+        it('should extract token from current URL', () => {
+            mockLocation(`https://example.com/checkout/${validToken}`);
+            expect(extractCheckoutTokenFromCurrentUrl()).toBe(validToken);
+        });
+        it('should return null when no token in URL', () => {
+            mockLocation('https://example.com/checkout');
+            expect(extractCheckoutTokenFromCurrentUrl()).toBeNull();
+        });
+        it('should return null in server environment', () => {
+            const originalWindow = global.window;
+            delete global.window;
+            expect(extractCheckoutTokenFromCurrentUrl()).toBeNull();
+            global.window = originalWindow;
+        });
+    });
+    describe('extractCheckoutTokenFromPath', () => {
+        it('should extract token from pathname', () => {
+            const pathname = `/checkout/${validToken}`;
+            expect(extractCheckoutTokenFromPath(pathname)).toBe(validToken);
+        });
+        it('should return null for invalid pathnames', () => {
+            expect(extractCheckoutTokenFromPath('')).toBeNull();
+            expect(extractCheckoutTokenFromPath(null)).toBeNull();
+            expect(extractCheckoutTokenFromPath(undefined)).toBeNull();
+        });
+    });
+    describe('isValidCheckoutToken', () => {
+        it('should validate correct token format', () => {
+            expect(isValidCheckoutToken(validToken)).toBe(true);
+            expect(isValidCheckoutToken(anotherValidToken)).toBe(true);
+        });
+        it('should reject invalid token formats', () => {
+            expect(isValidCheckoutToken('invalid-token')).toBe(false);
+            expect(isValidCheckoutToken('1234567890abcdef')).toBe(false); // Too short
+            expect(isValidCheckoutToken('1234567890abcdef1234567890abcdef1234567890abcdef')).toBe(false); // Too long
+            expect(isValidCheckoutToken('')).toBe(false);
+            expect(isValidCheckoutToken(null)).toBe(false);
+            expect(isValidCheckoutToken(undefined)).toBe(false);
+        });
+        it('should accept uppercase tokens', () => {
+            expect(isValidCheckoutToken(validToken.toUpperCase())).toBe(true);
+        });
+    });
+    describe('extractAndValidateCheckoutToken', () => {
+        it('should extract and validate valid token', () => {
+            const url = `https://example.com/checkout/${validToken}`;
+            expect(extractAndValidateCheckoutToken(url)).toBe(validToken);
+        });
+        it('should return null for invalid token', () => {
+            const url = 'https://example.com/checkout/invalid-token';
+            expect(extractAndValidateCheckoutToken(url)).toBeNull();
+        });
+        it('should return null when no token found', () => {
+            const url = 'https://example.com/checkout';
+            expect(extractAndValidateCheckoutToken(url)).toBeNull();
+        });
+    });
+    describe('getCheckoutToken', () => {
+        beforeEach(() => {
+            delete window.location;
+        });
+        it('should get token from current URL first', () => {
+            mockLocation(`https://example.com/checkout/${validToken}`);
+            const token = getCheckoutToken({
+                currentUrl: true,
+                specificUrl: `https://other.com/checkout/${anotherValidToken}`,
+                fallbackToken: 'fallback-token',
+            });
+            expect(token).toBe(validToken);
+        });
+        it('should fall back to specific URL when current URL has no token', () => {
+            mockLocation('https://example.com/checkout');
+            const token = getCheckoutToken({
+                currentUrl: true,
+                specificUrl: `https://other.com/checkout/${validToken}`,
+                fallbackToken: 'fallback-token',
+            });
+            expect(token).toBe(validToken);
+        });
+        it('should fall back to fallback token when others fail', () => {
+            mockLocation('https://example.com/checkout');
+            const token = getCheckoutToken({
+                currentUrl: true,
+                specificUrl: 'https://other.com/checkout',
+                fallbackToken: validToken,
+            });
+            expect(token).toBe(validToken);
+        });
+        it('should return null when all sources fail', () => {
+            mockLocation('https://example.com/checkout');
+            const token = getCheckoutToken({
+                currentUrl: true,
+                specificUrl: 'https://other.com/checkout',
+                fallbackToken: 'invalid-token',
+            });
+            expect(token).toBeNull();
+        });
+        it('should skip current URL when disabled', () => {
+            mockLocation(`https://example.com/checkout/${validToken}`);
+            const token = getCheckoutToken({
+                currentUrl: false,
+                specificUrl: `https://other.com/checkout/${anotherValidToken}`,
+            });
+            expect(token).toBe(anotherValidToken);
+        });
+    });
+    describe('buildCheckoutUrl', () => {
+        it('should build correct checkout URL', () => {
+            const baseUrl = 'https://example.com/checkout';
+            const url = buildCheckoutUrl(baseUrl, validToken);
+            expect(url).toBe(`https://example.com/checkout/${validToken}`);
+        });
+        it('should handle base URL with trailing slash', () => {
+            const baseUrl = 'https://example.com/checkout/';
+            const url = buildCheckoutUrl(baseUrl, validToken);
+            expect(url).toBe(`https://example.com/checkout/${validToken}`);
+        });
+        it('should throw error for invalid base URL', () => {
+            expect(() => buildCheckoutUrl('', validToken)).toThrow('Invalid base URL or checkout token');
+            expect(() => buildCheckoutUrl(null, validToken)).toThrow('Invalid base URL or checkout token');
+        });
+        it('should throw error for invalid token', () => {
+            expect(() => buildCheckoutUrl('https://example.com/checkout', 'invalid-token')).toThrow('Invalid base URL or checkout token');
+            expect(() => buildCheckoutUrl('https://example.com/checkout', '')).toThrow('Invalid base URL or checkout token');
+        });
+    });
+    describe('hasCheckoutToken', () => {
+        it('should return true when URL contains valid token', () => {
+            const url = `https://example.com/checkout/${validToken}`;
+            expect(hasCheckoutToken(url)).toBe(true);
+        });
+        it('should return false when URL has no token', () => {
+            const url = 'https://example.com/checkout';
+            expect(hasCheckoutToken(url)).toBe(false);
+        });
+        it('should return false when URL has invalid token', () => {
+            const url = 'https://example.com/checkout/invalid-token';
+            expect(hasCheckoutToken(url)).toBe(false);
+        });
+    });
+});

package/dist/react/utils/deviceInfo.d.ts

@@ -0,0 +1,39 @@
+export interface DeviceInfo {
+    userAgent: {
+        browser: {
+            name: string;
+            version: string;
+        };
+        os: {
+            name: string;
+            version: string;
+        };
+        device?: {
+            type: string;
+            model: string;
+        };
+    };
+    screenResolution: {
+        width: number;
+        height: number;
+    };
+    timeZone: string;
+}
+/**
+ * Get browser locale
+ */
+export declare function getBrowserLocale(): string;
+/**
+ * Collect all device information
+ */
+export declare function collectDeviceInfo(): DeviceInfo;
+/**
+ * Get URL parameters for session initialization
+ */
+export declare function getUrlParams(): {
+    locale?: string;
+    currency?: string;
+    utmSource?: string;
+    utmMedium?: string;
+    utmCampaign?: string;
+};