@explorins/pers-sdk-react-native 2.0.4 → 2.0.5

package/dist/index.js

@@ -27823,12 +27823,20 @@ class PersApiClient {
     /**
      * Ensures valid authentication token before making requests
      *
-     * Delegates to TokenRefreshManager for centralized token logic.
-     * Called without await for optimal performance - requests proceed immediately
-     * while token validation/refresh happens in background.
+     * Validates the current token and automatically refreshes if expired or near expiration.
+     * Uses a 120-second margin - tokens are refreshed if they expire within 2 minutes.
+     *
+     * This method is called automatically before each request but can also be called
+     * manually when needed (e.g., app resume from background).
      *
-     * @private
      * @returns Promise that resolves when token validation is complete
+     * @throws Error if token refresh fails
+     *
+     * @example
+     * ```typescript
+     * // Validate tokens when app becomes active
+     * await apiClient.ensureValidToken();
+     * ```
      */
     async ensureValidToken() {
         if (!this.mergedConfig.authProvider) {
@@ -28572,6 +28580,39 @@ class AuthManager {
         const authService = this.apiClient.getAuthService();
         await authService.clearTokens();
     }
+    /**
+     * Ensure authentication token is valid
+     *
+     * Checks if the current token is expired or about to expire and automatically
+     * refreshes it if needed. This is useful for ensuring valid authentication
+     * before performing critical operations or when app resumes from background.
+     *
+     * Uses a 120-second margin - tokens are refreshed if they expire within 2 minutes.
+     *
+     * @returns Promise that resolves when token is validated/refreshed
+     *
+     * @example App Resume (React Native)
+     * ```typescript
+     * AppState.addEventListener('change', async (state) => {
+     *   if (state === 'active') {
+     *     // Validate tokens when app returns from background
+     *     await sdk.auth.ensureValidToken().catch(console.error);
+     *   }
+     * });
+     * ```
+     *
+     * @example Before Critical Operation
+     * ```typescript
+     * async function processPayment() {
+     *   // Ensure token is valid before payment
+     *   await sdk.auth.ensureValidToken();
+     *   const result = await sdk.purchases.createPurchase(paymentData);
+     * }
+     * ```
+     */
+    async ensureValidToken() {
+        return this.apiClient.ensureValidToken();
+    }
     /**
      * Check if SDK has valid authentication
      *
@@ -34118,19 +34159,24 @@ class AsyncStorageTokenStorage {
     }
     async set(key, value) {
         try {
-            await this.asyncStorage.setItem(`${this.keyPrefix}${key}`, value);
+            const fullKey = `${this.keyPrefix}${key}`;
+            await this.asyncStorage.setItem(fullKey, value);
+            console.log(`[AsyncStorage] Token stored: ${key}`);
         }
         catch (error) {
-            console.error(`Failed to store token ${key}:`, error);
+            console.error(`[AsyncStorage] Failed to store token ${key}:`, error);
             throw new Error(`Token storage failed: ${error}`);
         }
     }
     async get(key) {
         try {
-            return await this.asyncStorage.getItem(`${this.keyPrefix}${key}`);
+            const fullKey = `${this.keyPrefix}${key}`;
+            const value = await this.asyncStorage.getItem(fullKey);
+            console.log(`[AsyncStorage] Token retrieved: ${key} - ${value ? 'exists' : 'null'}`);
+            return value;
         }
         catch (error) {
-            console.error(`Failed to retrieve token ${key}:`, error);
+            console.error(`[AsyncStorage] Failed to retrieve token ${key}:`, error);
             return null;
         }
     }
@@ -34147,11 +34193,16 @@ class AsyncStorageTokenStorage {
             const allKeys = await this.asyncStorage.getAllKeys();
             const ourKeys = allKeys.filter(key => key.startsWith(this.keyPrefix));
             if (ourKeys.length > 0) {
+                console.log(`[AsyncStorage] Clearing ${ourKeys.length} token(s):`, ourKeys);
                 await this.asyncStorage.multiRemove(ourKeys);
+                console.log('[AsyncStorage] All tokens cleared successfully');
+            }
+            else {
+                console.log('[AsyncStorage] No tokens to clear');
             }
         }
         catch (error) {
-            console.error('Failed to clear token storage:', error);
+            console.error('[AsyncStorage] Failed to clear token storage:', error);
         }
     }
 }
@@ -34649,6 +34700,70 @@ const PersSDKProvider = ({ children, config }) => {
             throw error;
         }
     }, [sdk, isAuthenticated, isInitialized]);
+    // Listen for authentication status changes and refresh user data when tokens are renewed
+    react.useEffect(() => {
+        if (!authProvider || !isInitialized)
+            return;
+        // Access the config object with proper type safety
+        const providerConfig = authProvider.config;
+        if (!providerConfig)
+            return;
+        // Set up auth status change handler
+        const originalHandler = providerConfig.onAuthStatusChange;
+        const authStatusHandler = async (status) => {
+            console.log('[PersSDK] Auth status changed:', status);
+            // Call original handler first if it exists
+            if (originalHandler) {
+                await originalHandler(status);
+            }
+            // If token was refreshed successfully and user is authenticated, reload user data
+            if (status === 'authenticated' && isAuthenticated && sdk) {
+                try {
+                    console.log('[PersSDK] Token refreshed, reloading user data...');
+                    await refreshUserData();
+                }
+                catch (error) {
+                    console.error('[PersSDK] Failed to refresh user data after token renewal:', error);
+                }
+            }
+            // If authentication failed, clear state
+            if (status === 'auth_failed') {
+                console.log('[PersSDK] Authentication failed, clearing state');
+                setAuthenticationState(null, false);
+            }
+        };
+        // Inject our handler into the auth provider config
+        providerConfig.onAuthStatusChange = authStatusHandler;
+        // Cleanup
+        return () => {
+            if (originalHandler) {
+                providerConfig.onAuthStatusChange = originalHandler;
+            }
+        };
+    }, [authProvider, isInitialized, isAuthenticated, sdk, refreshUserData, setAuthenticationState]);
+    // iOS/Android: Monitor app state and validate tokens when app becomes active
+    react.useEffect(() => {
+        if (!sdk || reactNative.Platform.OS === 'web') {
+            return;
+        }
+        const handleAppStateChange = async (nextAppState) => {
+            if (nextAppState === 'active' && isAuthenticated) {
+                console.log('[PersSDK] App became active - validating tokens');
+                try {
+                    // Trigger token validation when app resumes from background
+                    // This ensures tokens are checked after extended inactivity
+                    await sdk.auth.ensureValidToken();
+                }
+                catch (error) {
+                    console.warn('[PersSDK] Token validation failed on app resume:', error);
+                }
+            }
+        };
+        const subscription = reactNative.AppState.addEventListener('change', handleAppStateChange);
+        return () => {
+            subscription?.remove();
+        };
+    }, [sdk, isAuthenticated]);
     const contextValue = react.useMemo(() => ({
         // Main SDK instance
         sdk,