@tagadapay/plugin-sdk 2.6.17 → 2.7.0

package/dist/v2/react/hooks/useCustomerInfos.js

@@ -0,0 +1,53 @@
+'use client';
+/**
+ * useCustomerInfos - Hook to fetch customer information (v2)
+ * Fetches customer infos from `/api/v1/customers/{customerId}` with `storeId` param
+ */
+import { useQuery } from '@tanstack/react-query';
+import { useMemo } from 'react';
+import { CustomerResource } from '../../core/resources/customer';
+import { useTagadaContext } from '../providers/TagadaProvider';
+import { getGlobalApiClient } from './useApiQuery';
+import { usePluginConfig } from './usePluginConfig';
+export function useCustomerInfos(options = {}) {
+    const { storeId } = usePluginConfig();
+    const { isSessionInitialized } = useTagadaContext();
+    const { customerId = null, enabled = true } = options;
+    // Create customer resource client
+    const customerResource = useMemo(() => {
+        try {
+            return new CustomerResource(getGlobalApiClient());
+        }
+        catch (error) {
+            throw new Error('Failed to initialize customer resource: ' +
+                (error instanceof Error ? error.message : 'Unknown error'));
+        }
+    }, []);
+    // Determine if query should be enabled
+    const isEnabled = useMemo(() => {
+        return Boolean(enabled && customerId && storeId && isSessionInitialized);
+    }, [enabled, customerId, storeId, isSessionInitialized]);
+    // Create query key
+    const queryKey = useMemo(() => ['customer-infos', { customerId, storeId }], [customerId, storeId]);
+    // Fetch customer infos using TanStack Query
+    const { data = null, isLoading, error, refetch, } = useQuery({
+        queryKey,
+        enabled: isEnabled,
+        queryFn: async () => {
+            if (!customerId || !storeId) {
+                return null;
+            }
+            return await customerResource.getCustomerInfos(customerId, storeId);
+        },
+        staleTime: 5 * 60 * 1000, // 5 minutes
+        refetchOnWindowFocus: false,
+    });
+    return {
+        data,
+        isLoading,
+        error,
+        refetch: async () => {
+            await refetch();
+        },
+    };
+}

package/dist/v2/react/hooks/useCustomerOrders.d.ts

@@ -0,0 +1,17 @@
+/**
+ * useCustomerOrders - Hook to fetch customer orders (v2)
+ */
+import { OrderWithRelations } from '../../core/resources/customer';
+export interface UseCustomerOrdersOptions {
+    customerId?: string | null;
+    enabled?: boolean;
+}
+export interface UseCustomerOrdersResult {
+    data: {
+        orders: OrderWithRelations[];
+    } | null;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+}
+export declare function useCustomerOrders(options?: UseCustomerOrdersOptions): UseCustomerOrdersResult;

package/dist/v2/react/hooks/useCustomerOrders.js

@@ -0,0 +1,51 @@
+/**
+ * useCustomerOrders - Hook to fetch customer orders (v2)
+ */
+import { useQuery } from '@tanstack/react-query';
+import { useMemo } from 'react';
+import { CustomerResource } from '../../core/resources/customer';
+import { useTagadaContext } from '../providers/TagadaProvider';
+import { getGlobalApiClient } from './useApiQuery';
+import { usePluginConfig } from './usePluginConfig';
+export function useCustomerOrders(options = {}) {
+    const { storeId } = usePluginConfig();
+    const { isSessionInitialized } = useTagadaContext();
+    const { customerId = null, enabled = true } = options;
+    // Create customer resource client
+    const customerResource = useMemo(() => {
+        try {
+            return new CustomerResource(getGlobalApiClient());
+        }
+        catch (error) {
+            throw new Error('Failed to initialize customer resource: ' +
+                (error instanceof Error ? error.message : 'Unknown error'));
+        }
+    }, []);
+    // Determine if query should be enabled
+    const isEnabled = useMemo(() => {
+        return Boolean(enabled && customerId && storeId && isSessionInitialized);
+    }, [enabled, customerId, storeId, isSessionInitialized]);
+    // Create query key
+    const queryKey = useMemo(() => ['customer-orders', { customerId, storeId }], [customerId, storeId]);
+    // Fetch customer orders using TanStack Query
+    const { data = null, isLoading, error, refetch, } = useQuery({
+        queryKey,
+        enabled: isEnabled,
+        queryFn: async () => {
+            if (!customerId || !storeId) {
+                return null;
+            }
+            return await customerResource.getCustomerOrders(customerId, storeId);
+        },
+        staleTime: 5 * 60 * 1000, // 5 minutes
+        refetchOnWindowFocus: false,
+    });
+    return {
+        data,
+        isLoading,
+        error,
+        refetch: async () => {
+            await refetch();
+        },
+    };
+}

package/dist/v2/react/hooks/useCustomerSubscriptions.d.ts

@@ -0,0 +1,23 @@
+/**
+ * useCustomerSubscriptions - Hook to manage customer subscriptions (v2)
+ */
+import { SubscriptionsResponse } from '../../core/resources/customer';
+export interface UseCustomerSubscriptionsOptions {
+    customerId?: string | null;
+    enabled?: boolean;
+}
+export interface UseCustomerSubscriptionsResult {
+    data: SubscriptionsResponse | null;
+    isLoading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+    resumeSubscription: (subscriptionId: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    cancelSubscription: (subscriptionId: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+}
+export declare function useCustomerSubscriptions(options?: UseCustomerSubscriptionsOptions): UseCustomerSubscriptionsResult;

package/dist/v2/react/hooks/useCustomerSubscriptions.js

@@ -0,0 +1,94 @@
+/**
+ * useCustomerSubscriptions - Hook to manage customer subscriptions (v2)
+ */
+import { useMutation, useQuery, useQueryClient } from '@tanstack/react-query';
+import { useCallback, useMemo } from 'react';
+import { CustomerResource } from '../../core/resources/customer';
+import { useTagadaContext } from '../providers/TagadaProvider';
+import { getGlobalApiClient } from './useApiQuery';
+export function useCustomerSubscriptions(options = {}) {
+    const { isSessionInitialized } = useTagadaContext();
+    const queryClient = useQueryClient();
+    const { customerId = null, enabled = true } = options;
+    // Create customer resource client
+    const customerResource = useMemo(() => {
+        try {
+            return new CustomerResource(getGlobalApiClient());
+        }
+        catch (error) {
+            throw new Error('Failed to initialize customer resource: ' +
+                (error instanceof Error ? error.message : 'Unknown error'));
+        }
+    }, []);
+    // Determine if query should be enabled
+    const isEnabled = useMemo(() => {
+        return Boolean(enabled && customerId && isSessionInitialized);
+    }, [enabled, customerId, isSessionInitialized]);
+    // Create query key
+    const queryKey = useMemo(() => ['customer-subscriptions', { customerId }], [customerId]);
+    // Fetch customer subscriptions using TanStack Query
+    const { data = null, isLoading, error, refetch, } = useQuery({
+        queryKey,
+        enabled: isEnabled,
+        queryFn: async () => {
+            if (!customerId) {
+                return null;
+            }
+            return await customerResource.getCustomerSubscriptions();
+        },
+        staleTime: 5 * 60 * 1000, // 5 minutes
+        refetchOnWindowFocus: false,
+    });
+    // Resume subscription mutation
+    const resumeMutation = useMutation({
+        mutationFn: async (subscriptionId) => {
+            return await customerResource.resumeSubscription(subscriptionId);
+        },
+        onSuccess: () => {
+            // Invalidate and refetch subscriptions
+            void queryClient.invalidateQueries({ queryKey });
+        },
+    });
+    // Cancel subscription mutation
+    const cancelMutation = useMutation({
+        mutationFn: async (subscriptionId) => {
+            return await customerResource.cancelSubscription(subscriptionId);
+        },
+        onSuccess: () => {
+            // Invalidate and refetch subscriptions
+            void queryClient.invalidateQueries({ queryKey });
+        },
+    });
+    // Resume subscription
+    const resumeSubscription = useCallback(async (subscriptionId) => {
+        try {
+            await resumeMutation.mutateAsync(subscriptionId);
+            return { success: true };
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : 'Failed to resume subscription';
+            return { success: false, error: errorMessage };
+        }
+    }, [resumeMutation]);
+    // Cancel subscription
+    const cancelSubscription = useCallback(async (subscriptionId) => {
+        try {
+            await cancelMutation.mutateAsync(subscriptionId);
+            return { success: true };
+        }
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : 'Failed to cancel subscription';
+            return { success: false, error: errorMessage };
+        }
+    }, [cancelMutation]);
+    return {
+        data,
+        isLoading,
+        error,
+        refetch: async () => {
+            await refetch();
+        },
+        resumeSubscription,
+        cancelSubscription,
+    };
+}

package/dist/v2/react/hooks/useLogin.d.ts

@@ -0,0 +1,53 @@
+export interface UseLoginOptions {
+    /**
+     * Callback when login is successful
+     */
+    onSuccess?: (token: string) => void;
+    /**
+     * Callback when an error occurs
+     */
+    onError?: (error: Error) => void;
+}
+export interface UseLoginResult {
+    /**
+     * Request verification code for email
+     */
+    requestCode: (email: string) => Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /**
+     * Verify code and complete login
+     */
+    verifyCode: (email: string, code: string) => Promise<{
+        success: boolean;
+        token?: string;
+        sessionId?: string;
+        error?: string;
+    }>;
+    /**
+     * Combined loading state (true if either request or verify is loading)
+     */
+    isLoading: boolean;
+    /**
+     * Loading state for request code
+     */
+    isRequestingCode: boolean;
+    /**
+     * Loading state for verify code
+     */
+    isVerifyingCode: boolean;
+    /**
+     * Combined error state
+     */
+    error: Error | null;
+    /**
+     * Error from request code
+     */
+    requestCodeError: Error | null;
+    /**
+     * Error from verify code
+     */
+    verifyCodeError: Error | null;
+}
+export declare function useLogin(options?: UseLoginOptions): UseLoginResult;

package/dist/v2/react/hooks/useLogin.js

@@ -0,0 +1,75 @@
+'use client';
+/**
+ * useLogin - Hook for authentication (v2)
+ * Handles email/code authentication flow
+ */
+import { useMutation } from '@tanstack/react-query';
+import { useCallback, useMemo } from 'react';
+import { setClientToken } from '../../../react/utils/tokenStorage';
+import { SessionResource } from '../../core/resources/session';
+import { getGlobalApiClient } from './useApiQuery';
+import { usePluginConfig } from './usePluginConfig';
+export function useLogin(options = {}) {
+    const { onSuccess, onError } = options;
+    const { storeId } = usePluginConfig();
+    // Create session resource client
+    const sessionResource = useMemo(() => {
+        try {
+            return new SessionResource(getGlobalApiClient());
+        }
+        catch (error) {
+            throw new Error('Failed to initialize session resource: ' +
+                (error instanceof Error ? error.message : 'Unknown error'));
+        }
+    }, []);
+    // Request code mutation
+    const requestCodeMutation = useMutation({
+        mutationFn: async (email) => {
+            if (!storeId) {
+                throw new Error('Store ID not found. Make sure the TagadaProvider is properly configured.');
+            }
+            return await sessionResource.requestCode(email, storeId);
+        },
+        onError: (error) => {
+            console.error('[SDK] Failed to request code:', error);
+            onError?.(error);
+        },
+    });
+    // Verify code mutation
+    const verifyCodeMutation = useMutation({
+        mutationFn: async ({ email, code }) => {
+            if (!storeId) {
+                throw new Error('Store ID not found. Make sure the TagadaProvider is properly configured.');
+            }
+            const result = await sessionResource.verifyCode(email, code, storeId);
+            if (result.success && result.token) {
+                // Store the token
+                setClientToken(result.token);
+                // Call success callback
+                onSuccess?.(result.token);
+            }
+            return result;
+        },
+        onError: (error) => {
+            console.error('[SDK] Failed to verify code:', error);
+            onError?.(error);
+        },
+    });
+    // Action functions
+    const requestCode = useCallback(async (email) => {
+        return await requestCodeMutation.mutateAsync(email);
+    }, [requestCodeMutation]);
+    const verifyCode = useCallback(async (email, code) => {
+        return await verifyCodeMutation.mutateAsync({ email, code });
+    }, [verifyCodeMutation]);
+    return {
+        requestCode,
+        verifyCode,
+        isLoading: requestCodeMutation.isPending || verifyCodeMutation.isPending,
+        isRequestingCode: requestCodeMutation.isPending,
+        isVerifyingCode: verifyCodeMutation.isPending,
+        error: requestCodeMutation.error || verifyCodeMutation.error,
+        requestCodeError: requestCodeMutation.error,
+        verifyCodeError: verifyCodeMutation.error,
+    };
+}

package/dist/v2/react/hooks/useTranslation.js

@@ -29,7 +29,7 @@ export const useTranslation = (options = {}) => {
         // Check for language query parameter
         if (typeof window !== 'undefined') {
             const urlParams = new URLSearchParams(window.location.search);
-            const langFromQuery = urlParams.get('language');
+            const langFromQuery = urlParams.get('locale');
             if (langFromQuery)
                 return langFromQuery;
         }

package/dist/v2/react/index.d.ts

@@ -6,17 +6,22 @@ export { ExpressPaymentMethodsProvider } from './providers/ExpressPaymentMethods
 export { TagadaProvider, useTagadaContext } from './providers/TagadaProvider';
 export { ApplePayButton } from './components/ApplePayButton';
 export { GooglePayButton } from './components/GooglePayButton';
+export { useAuth } from './hooks/useAuth';
 export { useCheckoutToken } from './hooks/useCheckoutToken';
+export { useClubOffers } from './hooks/useClubOffers';
+export { useCustomer } from './hooks/useCustomer';
+export { useCustomerInfos } from './hooks/useCustomerInfos';
+export { useCustomerOrders } from './hooks/useCustomerOrders';
+export { useCustomerSubscriptions } from './hooks/useCustomerSubscriptions';
 export { useExpressPaymentMethods } from './hooks/useExpressPaymentMethods';
 export { useGeoLocation } from './hooks/useGeoLocation';
 export { useGoogleAutocomplete } from './hooks/useGoogleAutocomplete';
 export { getAvailableLanguages, useCountryOptions, useISOData, useLanguageImport, useRegionOptions } from './hooks/useISOData';
+export { useLogin } from './hooks/useLogin';
 export { usePluginConfig } from './hooks/usePluginConfig';
-export { useTranslation } from './hooks/useTranslation';
 export { queryKeys, useApiMutation, useApiQuery, useInvalidateQuery, usePreloadQuery } from './hooks/useApiQuery';
 export { useCheckoutQuery as useCheckout } from './hooks/useCheckoutQuery';
 export { useCurrency } from './hooks/useCurrency';
-export { useDiscountQuery as useDiscount } from './hooks/useDiscountQuery';
 export { useDiscountsQuery as useDiscounts } from './hooks/useDiscountsQuery';
 export { useOffersQuery as useOffers } from './hooks/useOffersQuery';
 export { useOrderBumpQuery as useOrderBump } from './hooks/useOrderBumpQuery';
@@ -29,19 +34,25 @@ export { useShippingRatesQuery as useShippingRates } from './hooks/useShippingRa
 export { useStoreConfigQuery as useStoreConfig } from './hooks/useStoreConfigQuery';
 export { useThreeds } from './hooks/useThreeds';
 export { useThreedsModal } from './hooks/useThreedsModal';
+export { useTranslation } from './hooks/useTranslation';
 export { useVipOffersQuery as useVipOffers } from './hooks/useVipOffersQuery';
 export { useFunnel, useSimpleFunnel } from './hooks/useFunnel';
 export type { UseCheckoutTokenOptions, UseCheckoutTokenResult } from './hooks/useCheckoutToken';
+export type { ClubOffer, ClubOfferItem, ClubOfferLineItem, ClubOfferSummary, UseClubOffersOptions, UseClubOffersResult } from './hooks/useClubOffers';
+export type { UseCustomerResult } from './hooks/useCustomer';
+export type { UseCustomerInfosOptions, UseCustomerInfosResult } from './hooks/useCustomerInfos';
+export type { UseCustomerOrdersOptions, UseCustomerOrdersResult } from './hooks/useCustomerOrders';
+export type { UseCustomerSubscriptionsOptions, UseCustomerSubscriptionsResult } from './hooks/useCustomerSubscriptions';
 export type { ExpressPaymentMethodsContextType, ExpressPaymentMethodsProviderProps } from './hooks/useExpressPaymentMethods';
+export type { UseLoginOptions, UseLoginResult } from './hooks/useLogin';
 export type { ApplePayButtonProps } from './components/ApplePayButton';
 export type { GooglePayButtonProps } from './components/GooglePayButton';
 export type { GeoLocationData, UseGeoLocationOptions, UseGeoLocationReturn } from './hooks/useGeoLocation';
 export type { ExtractedAddress, GooglePlaceDetails, GooglePrediction, UseGoogleAutocompleteOptions, UseGoogleAutocompleteResult } from './hooks/useGoogleAutocomplete';
 export type { ISOCountry, ISORegion, UseISODataResult } from './hooks/useISOData';
 export type { UsePluginConfigOptions, UsePluginConfigResult } from './hooks/usePluginConfig';
-export type { TranslateFunction, TranslationText, UseTranslationOptions, UseTranslationResult } from './hooks/useTranslation';
+export type { TranslateFunction, UseTranslationOptions, UseTranslationResult } from './hooks/useTranslation';
 export type { UseCheckoutQueryOptions as UseCheckoutOptions, UseCheckoutQueryResult as UseCheckoutResult } from './hooks/useCheckoutQuery';
-export type { StoreDiscount, UseDiscountQueryOptions as UseDiscountOptions, UseDiscountQueryResult as UseDiscountResult } from './hooks/useDiscountQuery';
 export type { UseDiscountsQueryOptions as UseDiscountsOptions, UseDiscountsQueryResult as UseDiscountsResult } from './hooks/useDiscountsQuery';
 export type { FunnelEvent, FunnelNavigationAction, FunnelNavigationResult, SimpleFunnelContext, UseFunnelOptions, UseFunnelResult } from './hooks/useFunnel';
 export type { UseOffersQueryOptions as UseOffersOptions, UseOffersQueryResult as UseOffersResult } from './hooks/useOffersQuery';

package/dist/v2/react/index.js

@@ -9,18 +9,23 @@ export { TagadaProvider, useTagadaContext } from './providers/TagadaProvider';
 export { ApplePayButton } from './components/ApplePayButton';
 export { GooglePayButton } from './components/GooglePayButton';
 // Hooks
+export { useAuth } from './hooks/useAuth';
 export { useCheckoutToken } from './hooks/useCheckoutToken';
+export { useClubOffers } from './hooks/useClubOffers';
+export { useCustomer } from './hooks/useCustomer';
+export { useCustomerInfos } from './hooks/useCustomerInfos';
+export { useCustomerOrders } from './hooks/useCustomerOrders';
+export { useCustomerSubscriptions } from './hooks/useCustomerSubscriptions';
 export { useExpressPaymentMethods } from './hooks/useExpressPaymentMethods';
 export { useGeoLocation } from './hooks/useGeoLocation';
 export { useGoogleAutocomplete } from './hooks/useGoogleAutocomplete';
 export { getAvailableLanguages, useCountryOptions, useISOData, useLanguageImport, useRegionOptions } from './hooks/useISOData';
+export { useLogin } from './hooks/useLogin';
 export { usePluginConfig } from './hooks/usePluginConfig';
-export { useTranslation } from './hooks/useTranslation';
 // TanStack Query hooks (recommended)
 export { queryKeys, useApiMutation, useApiQuery, useInvalidateQuery, usePreloadQuery } from './hooks/useApiQuery';
 export { useCheckoutQuery as useCheckout } from './hooks/useCheckoutQuery';
 export { useCurrency } from './hooks/useCurrency';
-export { useDiscountQuery as useDiscount } from './hooks/useDiscountQuery';
 export { useDiscountsQuery as useDiscounts } from './hooks/useDiscountsQuery';
 export { useOffersQuery as useOffers } from './hooks/useOffersQuery';
 export { useOrderBumpQuery as useOrderBump } from './hooks/useOrderBumpQuery';
@@ -33,6 +38,7 @@ export { useShippingRatesQuery as useShippingRates } from './hooks/useShippingRa
 export { useStoreConfigQuery as useStoreConfig } from './hooks/useStoreConfigQuery';
 export { useThreeds } from './hooks/useThreeds';
 export { useThreedsModal } from './hooks/useThreedsModal';
+export { useTranslation } from './hooks/useTranslation';
 export { useVipOffersQuery as useVipOffers } from './hooks/useVipOffersQuery';
 // Funnel hooks
 export { useFunnel, useSimpleFunnel } from './hooks/useFunnel';

package/dist/v2/react/providers/TagadaProvider.d.ts

@@ -1,6 +1,3 @@
-/**
- * TagadaProvider - Main provider component for the Tagada Pay React SDK
- */
 import { ReactNode } from 'react';
 import { PluginConfig, RawPluginConfig } from '../../../react/hooks/usePluginConfig';
 import { ApiService } from '../../../react/services/apiService';

package/dist/v2/react/providers/TagadaProvider.js

@@ -3,9 +3,8 @@ import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-run
 /**
  * TagadaProvider - Main provider component for the Tagada Pay React SDK
  */
-import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState, } from 'react';
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
-import { default as DebugDrawer } from '../components/DebugDrawer';
+import { createContext, useCallback, useContext, useEffect, useMemo, useRef, useState, } from 'react';
 import { detectEnvironment, getEnvironmentConfig } from '../../../react/config/environment';
 import { ApiService } from '../../../react/services/apiService';
 import { collectDeviceInfo, getBrowserLocale, getUrlParams } from '../../../react/utils/deviceInfo';
@@ -13,8 +12,9 @@ import { decodeJWTClient, isTokenExpired } from '../../../react/utils/jwtDecoder
 import { convertCurrency, formatMoney, formatMoneyWithoutSymbol, formatSimpleMoney, getCurrencyInfo, minorUnitsToMajorUnits, moneyStringOrNumberToMinorUnits, } from '../../../react/utils/money';
 import { clearClientToken, getClientToken, setClientToken } from '../../../react/utils/tokenStorage';
 import { ApiClient } from '../../core/resources/apiClient';
-import { setGlobalApiClient, getGlobalApiClientOrNull } from '../hooks/useApiQuery';
 import { loadPluginConfig } from '../../core/utils/pluginConfig';
+import { default as DebugDrawer } from '../components/DebugDrawer';
+import { setGlobalApiClient } from '../hooks/useApiQuery';
 // Professional, subtle loading component for initialization
 const InitializationLoader = () => (_jsxs("div", { style: {
         position: 'fixed',
@@ -207,8 +207,9 @@ rawPluginConfig, }) {
         }
         return service;
     });
-    // Initialize TanStack Query API client (global setup only)
-    useEffect(() => {
+    // Initialize TanStack Query API client synchronously during provider initialization
+    // This ensures the global client is available immediately for hooks that use it in useMemo
+    const [apiClient] = useState(() => {
         const client = new ApiClient({
             baseURL: environmentConfig.apiConfig.baseUrl,
             headers: {
@@ -217,24 +218,40 @@ rawPluginConfig, }) {
         });
         // Set the global client for TanStack Query hooks
         setGlobalApiClient(client);
-        console.log('[SDK] ApiClient initialized with baseURL:', environmentConfig.apiConfig.baseUrl);
-    }, [environmentConfig]);
+        // Check for existing token and set it immediately
+        const existingToken = getClientToken();
+        if (existingToken && !isTokenExpired(existingToken)) {
+            client.updateToken(existingToken);
+            console.log('[SDK] ApiClient initialized with existing token:', existingToken.substring(0, 8) + '...');
+        }
+        else {
+            console.log('[SDK] ApiClient initialized with baseURL:', environmentConfig.apiConfig.baseUrl);
+        }
+        return client;
+    });
+    // Update API client when environment config changes
+    useEffect(() => {
+        apiClient.updateConfig({
+            baseURL: environmentConfig.apiConfig.baseUrl,
+            headers: {
+                'Content-Type': 'application/json',
+            },
+        });
+        console.log('[SDK] ApiClient config updated with baseURL:', environmentConfig.apiConfig.baseUrl);
+    }, [environmentConfig, apiClient]);
     // Sync token updates between ApiService and ApiClient
     useEffect(() => {
-        const client = getGlobalApiClientOrNull();
-        if (client) {
-            // Always use the token from ApiService as the source of truth
-            const currentToken = apiService.getCurrentToken();
-            if (currentToken && typeof currentToken === 'string') {
-                client.updateToken(currentToken);
-                console.log('[SDK] Token synced to ApiClient:', currentToken.substring(0, 8) + '...');
-            }
-            else {
-                client.updateToken(null);
-                console.log('[SDK] Token cleared from ApiClient');
-            }
+        // Always use the token from ApiService as the source of truth
+        const currentToken = apiService.getCurrentToken();
+        if (currentToken && typeof currentToken === 'string') {
+            apiClient.updateToken(currentToken);
+            console.log('[SDK] Token synced to ApiClient:', currentToken.substring(0, 8) + '...');
+        }
+        else {
+            apiClient.updateToken(null);
+            console.log('[SDK] Token cleared from ApiClient');
         }
-    }, [token, apiService]);
+    }, [token, apiService, apiClient]);
     // Update API service when config or token changes
     useEffect(() => {
         apiService.updateConfig(environmentConfig);
@@ -378,12 +395,6 @@ rawPluginConfig, }) {
                 console.debug('[SDK][DEBUG] Auth state:', authState);
             }
             console.debug('[SDK] Session initialized successfully');
-            // Update token to ApiClient immediately
-            const client = getGlobalApiClientOrNull();
-            if (client && token) {
-                client.updateToken(token);
-                console.log('[SDK] Token updated to ApiClient:', token.substring(0, 8) + '...');
-            }
             setIsInitialized(true);
             setIsSessionInitialized(true); // Mark CMS session as ready
             setIsLoading(false);
@@ -425,6 +436,10 @@ rawPluginConfig, }) {
             setClientToken(response.token);
             // Update the API service with the new token
             apiService.updateToken(response.token);
+            // IMPORTANT: Immediately sync token to API client before marking session as ready
+            // This ensures any queries that become enabled after isSessionInitialized=true have the token
+            apiClient.updateToken(response.token);
+            console.log('[SDK] Token immediately synced to ApiClient:', response.token.substring(0, 8) + '...');
             // Decode the token to get session data
             const decodedSession = decodeJWTClient(response.token);
             if (decodedSession) {
@@ -441,12 +456,6 @@ rawPluginConfig, }) {
                 setIsLoading(false);
             }
             console.log('[SDK] ✅ Phase 3 Complete - Session initialization completed successfully');
-            // Update token to ApiClient immediately
-            const client = getGlobalApiClientOrNull();
-            if (client && token) {
-                client.updateToken(token);
-                console.log('[SDK] Token updated to ApiClient:', token.substring(0, 8) + '...');
-            }
             setIsSessionInitialized(true); // Mark CMS session as ready
         }
         catch (error) {
@@ -508,6 +517,9 @@ rawPluginConfig, }) {
                     setToken(tokenToUse);
                     // Update the API service with the token
                     apiService.updateToken(tokenToUse);
+                    // IMPORTANT: Immediately sync token to API client
+                    apiClient.updateToken(tokenToUse);
+                    console.log('[SDK] Token immediately synced to ApiClient:', tokenToUse.substring(0, 8) + '...');
                     // Decode token to get session data
                     const decodedSession = decodeJWTClient(tokenToUse);
                     if (decodedSession) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tagadapay/plugin-sdk",
-  "version": "2.6.17",
+  "version": "2.7.0",
   "description": "Modern React SDK for building Tagada Pay plugins",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",