@explorins/pers-sdk-react-native 2.1.2 → 2.1.3

package/dist/index.js

@@ -6828,8 +6828,7 @@ const DEFAULT_PERS_CONFIG = {
     timeout: 30000,
     retries: 3,
     tokenRefreshMargin: 60, // Refresh tokens 60 seconds before expiry
-    backgroundRefreshThreshold: 30, // Use background refresh if >30s remaining
-    autoRestoreSession: true // Automatically restore session on initialization
+    backgroundRefreshThreshold: 30 // Use background refresh if >30s remaining
 };
 /**
  * Internal function to construct API root from environment
@@ -7139,8 +7138,12 @@ class AuthService {
                 await extendedProvider.setProviderToken(providerToken);
             }
             if (authType && extendedProvider.setAuthType) {
+                console.log('[AuthService] Storing auth type:', authType);
                 await extendedProvider.setAuthType(authType);
             }
+            else {
+                console.warn('[AuthService] Auth type not stored - authType:', authType, 'has setAuthType:', !!extendedProvider.setAuthType);
+            }
             // Emit authenticated status on successful token storage
             await this.emitAuthStatus(AuthStatus.AUTHENTICATED);
         }
@@ -7159,8 +7162,15 @@ class TokenRefreshManager {
         this.authService = authService;
         this.authProvider = authProvider;
         this.tokenRefreshMarginSeconds = 120; // 2 minutes
+        this.lastValidationTime = 0;
+        this.validationCacheDurationMs = 30000; // 30 seconds
     }
     async ensureValidToken() {
+        const now = Date.now();
+        // Skip validation if we checked recently (within cache duration)
+        if (now - this.lastValidationTime < this.validationCacheDurationMs) {
+            return;
+        }
         try {
             const token = await this.authProvider.getToken();
             if (!token) {
@@ -7171,6 +7181,14 @@ class TokenRefreshManager {
                 if (!refreshSuccess) {
                     await this.authService.handleAuthFailure();
                 }
+                else {
+                    // Update validation time on successful refresh
+                    this.lastValidationTime = now;
+                }
+            }
+            else {
+                // Token is valid, update validation time
+                this.lastValidationTime = now;
             }
         }
         catch (error) {
@@ -7254,42 +7272,77 @@ class MemoryTokenStorage {
     }
 }
 /**
- * Token manager for authentication tokens
+ * Token manager for authentication tokens with memory caching
  */
 class AuthTokenManager {
     constructor(storage = new LocalStorageTokenStorage()) {
         this.storage = storage;
+        this.cache = {};
     }
     async getAccessToken() {
+        // Return cached value if available
+        if (this.cache.accessToken !== undefined) {
+            return this.cache.accessToken;
+        }
         const val = await this.storage.get(AUTH_STORAGE_KEYS.ACCESS_TOKEN);
         // Ensure we return string for tokens
-        return typeof val === 'string' ? val : null;
+        const token = typeof val === 'string' ? val : null;
+        this.cache.accessToken = token;
+        return token;
     }
     async setAccessToken(token) {
+        this.cache.accessToken = token;
         await this.storage.set(AUTH_STORAGE_KEYS.ACCESS_TOKEN, token);
     }
     async getRefreshToken() {
+        // Return cached value if available
+        if (this.cache.refreshToken !== undefined) {
+            return this.cache.refreshToken;
+        }
         const val = await this.storage.get(AUTH_STORAGE_KEYS.REFRESH_TOKEN);
-        return typeof val === 'string' ? val : null;
+        const token = typeof val === 'string' ? val : null;
+        this.cache.refreshToken = token;
+        return token;
     }
     async setRefreshToken(token) {
+        this.cache.refreshToken = token;
         await this.storage.set(AUTH_STORAGE_KEYS.REFRESH_TOKEN, token);
     }
     async getProviderToken() {
+        // Return cached value if available
+        if (this.cache.providerToken !== undefined) {
+            return this.cache.providerToken;
+        }
         const val = await this.storage.get(AUTH_STORAGE_KEYS.PROVIDER_TOKEN);
-        return typeof val === 'string' ? val : null;
+        const token = typeof val === 'string' ? val : null;
+        this.cache.providerToken = token;
+        return token;
     }
     async setProviderToken(token) {
+        this.cache.providerToken = token;
         await this.storage.set(AUTH_STORAGE_KEYS.PROVIDER_TOKEN, token);
     }
     async getAuthType() {
+        // Return cached value if available
+        if (this.cache.authType !== undefined) {
+            return this.cache.authType;
+        }
         const authType = await this.storage.get(AUTH_STORAGE_KEYS.AUTH_TYPE);
-        return typeof authType === 'string' ? authType : null;
+        const type = typeof authType === 'string' ? authType : null;
+        this.cache.authType = type;
+        return type;
     }
     async setAuthType(authType) {
+        this.cache.authType = authType;
         await this.storage.set(AUTH_STORAGE_KEYS.AUTH_TYPE, authType);
     }
     async setTokens(accessToken, refreshToken, providerToken) {
+        // Update cache for all tokens
+        this.cache.accessToken = accessToken;
+        if (refreshToken)
+            this.cache.refreshToken = refreshToken;
+        if (providerToken)
+            this.cache.providerToken = providerToken;
         await this.setAccessToken(accessToken);
         if (refreshToken)
             await this.setRefreshToken(refreshToken);
@@ -7297,13 +7350,23 @@ class AuthTokenManager {
             await this.setProviderToken(providerToken);
     }
     async clearAllTokens() {
+        // Clear cache
+        this.cache = {};
         await this.storage.clear();
     }
     async hasAccessToken() {
+        // Use cached value if available to avoid storage read
+        if (this.cache.accessToken !== undefined) {
+            return !!this.cache.accessToken;
+        }
         const token = await this.getAccessToken();
         return !!token;
     }
     async hasRefreshToken() {
+        // Use cached value if available to avoid storage read
+        if (this.cache.refreshToken !== undefined) {
+            return !!this.cache.refreshToken;
+        }
         const token = await this.getRefreshToken();
         return !!token;
     }
@@ -7531,6 +7594,7 @@ class DPoPManager {
 class DefaultAuthProvider {
     constructor(config = {}) {
         this.config = config;
+        this.authTypeCache = null;
         this.authType = config.authType || exports.AccountOwnerType.USER;
         const storage = config.storage || this.createStorage();
         this.tokenManager = new AuthTokenManager(storage);
@@ -7591,6 +7655,15 @@ class DefaultAuthProvider {
     }
     async setAccessToken(token) {
         await this.tokenManager.setAccessToken(token);
+        // Invalidate cache when token changes
+        this.authTypeCache = null;
+        // Eager DPoP key generation after login
+        if (this.dpopManager) {
+            // Fire and forget - generate keys in background
+            this.dpopManager.ensureKeyPair().catch(err => {
+                console.warn('[DefaultAuthProvider] DPoP key generation failed:', err);
+            });
+        }
     }
     async setRefreshToken(token) {
         await this.tokenManager.setRefreshToken(token);
@@ -7600,16 +7673,51 @@ class DefaultAuthProvider {
     }
     async clearTokens() {
         await this.tokenManager.clearAllTokens();
+        // Invalidate cache on clear
+        this.authTypeCache = null;
         if (this.dpopManager) {
             await this.dpopManager.clearKeys();
         }
     }
     async setTokens(accessToken, refreshToken, providerToken) {
         await this.tokenManager.setTokens(accessToken, refreshToken, providerToken);
+        // Invalidate cache when tokens change
+        this.authTypeCache = null;
     }
     async hasValidToken() {
         return this.tokenManager.hasAccessToken();
     }
+    async getAuthType() {
+        // Read from JWT instead of separate storage for single source of truth
+        const token = await this.tokenManager.getAccessToken();
+        if (!token) {
+            this.authTypeCache = null;
+            return null;
+        }
+        // Return cached result if token hasn't changed
+        if (this.authTypeCache && this.authTypeCache.token === token) {
+            return this.authTypeCache.type;
+        }
+        try {
+            // Decode JWT payload (without verification - we just need to read the claim)
+            const parts = token.split('.');
+            if (parts.length !== 3) {
+                console.warn('[DefaultAuthProvider] Invalid JWT format');
+                return null;
+            }
+            const payloadJson = atob(parts[1]);
+            const payload = JSON.parse(payloadJson);
+            // Use accountOwnerType from AuthJWTPayload interface
+            const authType = payload.accountType || null;
+            // Cache result with token signature
+            this.authTypeCache = { token, type: authType };
+            return authType;
+        }
+        catch (error) {
+            console.warn('[DefaultAuthProvider] Failed to parse auth type from JWT:', error);
+            return null;
+        }
+    }
 }
 
 /**
@@ -13351,78 +13459,71 @@ class PersSDK {
         // Initialize event emitter and wire to API client for error events
         this._events = new PersEventEmitter();
         this.apiClient.setEvents(this._events);
-        // Initialize domain managers (pass events to managers that emit success events)
-        this._auth = new AuthManager(this.apiClient, this._events);
-        this._users = new UserManager(this.apiClient, this._events);
-        this._userStatus = new UserStatusManager(this.apiClient);
-        this._tokens = new TokenManager(this.apiClient);
-        this._businesses = new BusinessManager(this.apiClient, this._events);
-        this._campaigns = new CampaignManager(this.apiClient, this._events);
-        this._redemptions = new RedemptionManager(this.apiClient, this._events);
-        this._transactions = new TransactionManager(this.apiClient, this._events);
-        this._purchases = new PurchaseManager(this.apiClient);
-        this._files = new FileManager(this.apiClient);
-        this._tenants = new TenantManager(this.apiClient);
-        this._apiKeys = new ApiKeyManager(this.apiClient);
-        this._analytics = new AnalyticsManager(this.apiClient);
-        this._donations = new DonationManager(this.apiClient);
-        // Automatically restore session if enabled and tokens exist
-        if (config.autoRestoreSession !== false) {
-            this.restoreSessionIfTokensExist().catch(err => {
-                console.warn('[PersSDK] Failed to restore session on initialization:', err);
-            });
-        }
     }
     /**
-     * Restore user session if valid tokens exist in storage
+     * Restore user session from stored tokens
      *
-     * This method is called automatically during SDK initialization when
-     * `autoRestoreSession` is enabled (default). It checks for stored tokens
-     * and fetches user data to restore the authentication state.
+     * Call this method after SDK initialization to restore the user's session
+     * if valid tokens exist. This is useful for maintaining login state across
+     * app restarts.
+     *
+     * **Important:** Only works for USER and BUSINESS accounts. Admin/tenant
+     * accounts don't support user data fetching, so this will return null for them
+     * (though their tokens remain valid for API calls).
      *
      * Emits auth domain success event when session is restored.
      *
-     * @internal
-     * @returns Promise that resolves when session is restored or determined to be invalid
+     * @returns Promise resolving to User data if session restored, null if no session or admin account
+     * @throws {PersError} If token validation or user fetch fails
+     *
+     * @example
+     * ```typescript
+     * // Call after initial render for better perceived performance
+     * const user = await sdk.restoreSession();
+     * if (user) {
+     *   console.log('Welcome back,', user.name);
+     * }
+     * ```
      */
-    async restoreSessionIfTokensExist() {
-        try {
-            const hasToken = await this._auth.hasValidAuth();
-            if (hasToken) {
-                console.log('[PersSDK] Valid tokens found, restoring session...');
-                try {
-                    // Fetch user data to validate tokens and restore session
-                    const userData = await this._auth.getCurrentUser();
-                    console.log('[PersSDK] Session restored successfully');
-                    // Emit event through proper event emitter
-                    // Send minimal data (just userId) - consumers can fetch full user if needed
-                    this._events.emitSuccess({
-                        type: 'session_restored',
-                        domain: 'authentication',
-                        userMessage: 'Session restored successfully',
-                        details: { userId: userData.id }
-                    });
-                }
-                catch (error) {
-                    // Tokens exist but are invalid (expired, revoked, etc.)
-                    console.warn('[PersSDK] Failed to restore session, tokens may be invalid:', error);
-                    await this._auth.clearAuth();
-                    // Emit restoration failed event
-                    this._events.emitError({
-                        type: 'session_restoration_failed',
-                        domain: 'authentication',
-                        userMessage: 'Session restoration failed',
-                        code: 'SESSION_INVALID',
-                        details: { error }
-                    });
-                }
-            }
-            else {
-                console.log('[PersSDK] No valid tokens found');
+    async restoreSession() {
+        const hasToken = await this.auth.hasValidAuth();
+        if (!hasToken) {
+            return null;
+        }
+        // Check auth type - only restore session for user and business accounts
+        const authProvider = this.apiClient.getConfig().authProvider;
+        if (authProvider?.getAuthType) {
+            const authType = await authProvider.getAuthType();
+            if (authType === exports.AccountOwnerType.TENANT) {
+                // Admin sessions don't support getCurrentUser(), skip restoration
+                // Tokens are valid and will be used for API calls
+                return null;
             }
         }
+        try {
+            // Fetch user data to validate tokens and restore session
+            const userData = await this.auth.getCurrentUser();
+            // Emit event through proper event emitter
+            this._events.emitSuccess({
+                type: 'session_restored',
+                domain: 'authentication',
+                userMessage: 'Session restored successfully',
+                details: { userId: userData.id }
+            });
+            return userData;
+        }
         catch (error) {
-            console.warn('[PersSDK] Error during session restoration:', error);
+            // Tokens exist but are invalid (expired, revoked, etc.)
+            await this.auth.clearAuth();
+            // Emit restoration failed event
+            this._events.emitError({
+                type: 'session_restoration_failed',
+                domain: 'authentication',
+                userMessage: 'Session restoration failed',
+                code: 'SESSION_INVALID',
+                details: { error }
+            });
+            throw error;
         }
     }
     /**
@@ -13511,6 +13612,9 @@ class PersSDK {
      * @see {@link AuthManager} for detailed documentation
      */
     get auth() {
+        if (!this._auth) {
+            this._auth = new AuthManager(this.apiClient, this._events);
+        }
         return this._auth;
     }
     /**
@@ -13524,6 +13628,9 @@ class PersSDK {
      * ```
      */
     get users() {
+        if (!this._users) {
+            this._users = new UserManager(this.apiClient, this._events);
+        }
         return this._users;
     }
     /**
@@ -13537,6 +13644,9 @@ class PersSDK {
      * ```
      */
     get userStatus() {
+        if (!this._userStatus) {
+            this._userStatus = new UserStatusManager(this.apiClient);
+        }
         return this._userStatus;
     }
     /**
@@ -13550,6 +13660,9 @@ class PersSDK {
      * ```
      */
     get tokens() {
+        if (!this._tokens) {
+            this._tokens = new TokenManager(this.apiClient);
+        }
         return this._tokens;
     }
     /**
@@ -13563,6 +13676,9 @@ class PersSDK {
      * ```
      */
     get businesses() {
+        if (!this._businesses) {
+            this._businesses = new BusinessManager(this.apiClient, this._events);
+        }
         return this._businesses;
     }
     /**
@@ -13576,6 +13692,9 @@ class PersSDK {
      * ```
      */
     get campaigns() {
+        if (!this._campaigns) {
+            this._campaigns = new CampaignManager(this.apiClient, this._events);
+        }
         return this._campaigns;
     }
     /**
@@ -13589,6 +13708,9 @@ class PersSDK {
      * ```
      */
     get redemptions() {
+        if (!this._redemptions) {
+            this._redemptions = new RedemptionManager(this.apiClient, this._events);
+        }
         return this._redemptions;
     }
     /**
@@ -13602,6 +13724,9 @@ class PersSDK {
      * ```
      */
     get transactions() {
+        if (!this._transactions) {
+            this._transactions = new TransactionManager(this.apiClient, this._events);
+        }
         return this._transactions;
     }
     /**
@@ -13615,6 +13740,9 @@ class PersSDK {
      * ```
      */
     get purchases() {
+        if (!this._purchases) {
+            this._purchases = new PurchaseManager(this.apiClient);
+        }
         return this._purchases;
     }
     /**
@@ -13628,6 +13756,9 @@ class PersSDK {
      * ```
      */
     get files() {
+        if (!this._files) {
+            this._files = new FileManager(this.apiClient);
+        }
         return this._files;
     }
     /**
@@ -13641,6 +13772,9 @@ class PersSDK {
      * ```
      */
     get tenants() {
+        if (!this._tenants) {
+            this._tenants = new TenantManager(this.apiClient);
+        }
         return this._tenants;
     }
     /**
@@ -13665,6 +13799,9 @@ class PersSDK {
      * ```
      */
     get apiKeys() {
+        if (!this._apiKeys) {
+            this._apiKeys = new ApiKeyManager(this.apiClient);
+        }
         return this._apiKeys;
     }
     /**
@@ -13676,6 +13813,9 @@ class PersSDK {
      * ```
      */
     get analytics() {
+        if (!this._analytics) {
+            this._analytics = new AnalyticsManager(this.apiClient);
+        }
         return this._analytics;
     }
     /**
@@ -13687,6 +13827,9 @@ class PersSDK {
      * ```
      */
     get donations() {
+        if (!this._donations) {
+            this._donations = new DonationManager(this.apiClient);
+        }
         return this._donations;
     }
     /**
@@ -14581,11 +14724,19 @@ const SDKContext = react.createContext(null);
 // Provider component
 const PersSDKProvider = ({ children, config }) => {
     const initializingRef = react.useRef(false);
+    // State refs for stable functions to read current values
+    const sdkRef = react.useRef(null);
+    const isInitializedRef = react.useRef(false);
+    const isAuthenticatedRef = react.useRef(false);
     const [sdk, setSdk] = react.useState(null);
     const [authProvider, setAuthProvider] = react.useState(null);
     const [isInitialized, setIsInitialized] = react.useState(false);
     const [isAuthenticated, setIsAuthenticated] = react.useState(false);
     const [user, setUser] = react.useState(null);
+    // Keep state refs in sync immediately (not in useEffect to avoid race conditions)
+    sdkRef.current = sdk;
+    isInitializedRef.current = isInitialized;
+    isAuthenticatedRef.current = isAuthenticated;
     const initialize = react.useCallback(async (config) => {
         // Prevent multiple initializations
         if (isInitialized || initializingRef.current) {
@@ -14652,18 +14803,40 @@ const PersSDKProvider = ({ children, config }) => {
         }
     }, [config, isInitialized, initialize]);
     const refreshUserData = react.useCallback(async () => {
-        if (!sdk || !isAuthenticated || !isInitialized) {
-            throw new Error('SDK not initialized or not authenticated. Cannot refresh user data.');
+        // Read from refs to get current values
+        const currentSdk = sdkRef.current;
+        const currentIsInitialized = isInitializedRef.current;
+        if (!currentSdk || !currentIsInitialized) {
+            throw new Error('SDK not initialized. Cannot refresh user data.');
         }
         try {
-            const freshUserData = await sdk.users.getCurrentUser();
+            const freshUserData = await currentSdk.users.getCurrentUser();
             setUser(freshUserData);
         }
         catch (error) {
             console.error('Failed to refresh user data:', error);
             throw error;
         }
-    }, [sdk, isAuthenticated, isInitialized]);
+    }, []); // No dependencies - reads from refs
+    const restoreSession = react.useCallback(async () => {
+        // Read from refs to get current values
+        const currentSdk = sdkRef.current;
+        const currentIsInitialized = isInitializedRef.current;
+        if (!currentSdk || !currentIsInitialized) {
+            throw new Error('SDK not initialized. Call initialize() first.');
+        }
+        try {
+            const userData = await currentSdk.restoreSession();
+            if (userData) {
+                setAuthenticationState(userData, true);
+            }
+            return userData;
+        }
+        catch (error) {
+            console.error('[PersSDK] Failed to restore session:', error);
+            throw error;
+        }
+    }, [setAuthenticationState]); // Depends on setAuthenticationState
     // Listen for authentication events from core SDK
     // Set up immediately when SDK is created (don't wait for isInitialized)
     // to catch session_restored events that fire during SDK initialization
@@ -14676,13 +14849,18 @@ const PersSDKProvider = ({ children, config }) => {
             // Session restored successfully - sync React state
             if (event.type === 'session_restored') {
                 console.log('[PersSDK] Session restoration event received, syncing state...');
-                sdk.users.getCurrentUser()
-                    .then(userData => {
-                    setAuthenticationState(userData, true);
-                })
-                    .catch(error => {
-                    console.error('[PersSDK] Failed to sync restored session:', error);
-                });
+                // Read user from event details if available, otherwise fetch
+                const userId = event.details?.userId;
+                if (userId) {
+                    // User ID available, fetch user data
+                    sdk.users.getCurrentUser()
+                        .then(userData => {
+                        setAuthenticationState(userData, true);
+                    })
+                        .catch(error => {
+                        console.error('[PersSDK] Failed to sync restored session:', error);
+                    });
+                }
             }
             // Session restoration failed or auth error - clear React state
             if (event.type === 'session_restoration_failed' || event.code === 'AUTH_FAILED') {
@@ -14720,28 +14898,17 @@ const PersSDKProvider = ({ children, config }) => {
     const contextValue = react.useMemo(() => ({
         // Main SDK instance
         sdk,
-        // Manager shortcuts for convenience
-        auth: sdk?.auth || null,
-        users: sdk?.users || null,
-        tokens: sdk?.tokens || null,
-        businesses: sdk?.businesses || null,
-        campaigns: sdk?.campaigns || null,
-        redemptions: sdk?.redemptions || null,
-        transactions: sdk?.transactions || null,
-        purchases: sdk?.purchases || null,
-        tenants: sdk?.tenants || null,
-        analytics: sdk?.analytics || null,
-        donations: sdk?.donations || null,
         // Platform-specific providers
         authProvider,
         // State
         isInitialized,
         isAuthenticated,
         user,
-        // Methods
+        // Methods - expose functions directly, not through refs
         initialize,
         setAuthenticationState,
         refreshUserData,
+        restoreSession,
     }), [
         sdk,
         authProvider,
@@ -14750,7 +14917,8 @@ const PersSDKProvider = ({ children, config }) => {
         user,
         initialize,
         setAuthenticationState,
-        refreshUserData
+        refreshUserData,
+        restoreSession
     ]);
     return (jsxRuntime.jsx(SDKContext.Provider, { value: contextValue, children: children }));
 };
@@ -36091,7 +36259,7 @@ const useWeb3 = () => {
  */
 function useTokenBalances(options) {
     const { accountAddress, availableTokens = [], autoLoad = true, refreshInterval = 0 } = options;
-    const { isAuthenticated } = usePersSDK();
+    const { isAuthenticated, sdk } = usePersSDK();
     const web3 = useWeb3();
     const [tokenBalances, setTokenBalances] = react.useState([]);
     const [isLoading, setIsLoading] = react.useState(false);
@@ -36193,15 +36361,28 @@ function useTokenBalances(options) {
             loadBalances();
         }
     }, [autoLoad, isAvailable, availableTokens.length, loadBalances]);
-    // Optional auto-refresh interval
+    // Event-driven refresh: listen for transaction events instead of polling
     react.useEffect(() => {
-        if (refreshInterval > 0 && isAvailable && availableTokens.length > 0) {
-            const intervalId = setInterval(() => {
+        if (!sdk || refreshInterval <= 0 || !isAvailable)
+            return;
+        // Subscribe to transaction domain events
+        const unsubscribe = sdk.events.subscribe((event) => {
+            if (event.domain === 'transaction' && event.type === 'transaction_completed') {
+                console.log('[useTokenBalances] Transaction completed, refreshing balances...');
                 loadBalances();
-            }, refreshInterval);
-            return () => clearInterval(intervalId);
-        }
-    }, [refreshInterval, isAvailable, availableTokens.length, loadBalances]);
+            }
+        }, { domains: ['transaction'] });
+        // Also set up a fallback polling interval (much longer than before)
+        // This handles cases where events might be missed
+        const fallbackInterval = Math.max(refreshInterval, 60000); // Minimum 1 minute
+        const intervalId = setInterval(() => {
+            loadBalances();
+        }, fallbackInterval);
+        return () => {
+            unsubscribe();
+            clearInterval(intervalId);
+        };
+    }, [sdk, refreshInterval, isAvailable, loadBalances]);
     return {
         tokenBalances,
         isLoading,