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

package/dist/hooks/useAuth.d.ts

@@ -1,4 +1,5 @@
 import type { RawUserData } from '@explorins/pers-sdk/core';
+import { AccountOwnerType } from '@explorins/pers-sdk/core';
 import type { UserDTO, AdminDTO, SessionAuthContextResponseDTO } from '@explorins/pers-shared';
 export type { RawUserData };
 /**
@@ -42,7 +43,7 @@ export declare const useAuth: () => {
     isInitialized: boolean;
     isAuthenticated: boolean;
     user: UserDTO | AdminDTO | null;
-    login: (jwtToken: string, userType?: 'user' | 'admin') => Promise<SessionAuthContextResponseDTO>;
+    login: (jwtToken: string, userType?: AccountOwnerType) => Promise<SessionAuthContextResponseDTO>;
     loginWithRawData: (rawUserData: RawUserData) => Promise<void>;
     logout: () => Promise<void>;
     refreshUserData: () => Promise<void>;

package/dist/hooks/useAuth.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useAuth.d.ts","sourceRoot":"","sources":["../../src/hooks/useAuth.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAC5D,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,6BAA6B,EAAE,MAAM,wBAAwB,CAAC;AAG/F,YAAY,EAAE,WAAW,EAAE,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,OAAO;;;;sBA0ByB,MAAM,aAAY,MAAM,GAAG,OAAO,KAAY,QAAQ,6BAA6B,CAAC;oCAuCtE,WAAW,KAAG,QAAQ,IAAI,CAAC;kBAuC/C,QAAQ,IAAI,CAAC;;0BA0BL,QAAQ,OAAO,CAAC;gCAmBV,QAAQ,OAAO,CAAC;mCAqBX,MAAM;qBAmBtB,QAAQ,IAAI,CAAC;wBAoBV,QAAQ,OAAO,CAAC;CAwB5D,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG,UAAU,CAAC,OAAO,OAAO,CAAC,CAAC"}
+{"version":3,"file":"useAuth.d.ts","sourceRoot":"","sources":["../../src/hooks/useAuth.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAC5D,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAC5D,OAAO,KAAK,EAAE,OAAO,EAAE,QAAQ,EAAE,6BAA6B,EAAE,MAAM,wBAAwB,CAAC;AAG/F,YAAY,EAAE,WAAW,EAAE,CAAC;AAE5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AACH,eAAO,MAAM,OAAO;;;;sBA0ByB,MAAM,aAAY,gBAAgB,KAA2B,QAAQ,6BAA6B,CAAC;oCAuCrF,WAAW,KAAG,QAAQ,IAAI,CAAC;kBAuC/C,QAAQ,IAAI,CAAC;;0BA0BL,QAAQ,OAAO,CAAC;gCAmBV,QAAQ,OAAO,CAAC;mCAqBX,MAAM;qBAmBtB,QAAQ,IAAI,CAAC;wBAoBV,QAAQ,OAAO,CAAC;CAwB5D,CAAC;AAEF,MAAM,MAAM,QAAQ,GAAG,UAAU,CAAC,OAAO,OAAO,CAAC,CAAC"}

package/dist/hooks/useAuth.js

@@ -1,5 +1,6 @@
 import { useCallback } from 'react';
 import { usePersSDK } from '../providers/PersSDKProvider';
+import { AccountOwnerType } from '@explorins/pers-sdk/core';
 /**
  * React hook for authentication operations in the PERS SDK
  *
@@ -43,18 +44,18 @@ export const useAuth = () => {
      * Authenticates a user with a JWT token
      *
      * @param jwtToken - The JWT token to authenticate with
-     * @param userType - The type of user ('user' | 'admin'), defaults to 'user'
+     * @param userType - The type of user (AccountOwnerType), defaults to USER
      * @returns Promise resolving to session auth context with user data
      * @throws Error if SDK is not initialized or authentication fails
      *
      * @example
      * ```typescript
      * const { login } = useAuth();
-     * const result = await login(jwtToken, 'user');
+     * const result = await login(jwtToken, AccountOwnerType.USER);
      * console.log('Logged in user:', result.user);
      * ```
      */
-    const login = useCallback(async (jwtToken, userType = 'user') => {
+    const login = useCallback(async (jwtToken, userType = AccountOwnerType.USER) => {
         if (!sdk || !authProvider) {
             throw new Error('SDK not initialized. Call initialize() first.');
         }

package/dist/index.js

@@ -27127,7 +27127,7 @@ class AuthService {
     async loginTenantAdmin(jwt) {
         const response = await this.authApi.loginTenantAdmin(jwt);
         if (this.authProvider && response.accessToken) {
-            await this.storeTokens(response.accessToken, response.refreshToken, 'admin', jwt);
+            await this.storeTokens(response.accessToken, response.refreshToken, exports.AccountOwnerType.TENANT, jwt);
         }
         return response;
     }
@@ -27137,7 +27137,7 @@ class AuthService {
     async loginUser(jwt) {
         const response = await this.authApi.loginUser(jwt);
         if (this.authProvider && response.accessToken) {
-            await this.storeTokens(response.accessToken, response.refreshToken, 'user', jwt);
+            await this.storeTokens(response.accessToken, response.refreshToken, exports.AccountOwnerType.USER, jwt);
         }
         return response;
     }
@@ -27168,7 +27168,7 @@ class AuthService {
     async loginBusiness(jwt, options) {
         const response = await this.authApi.loginBusiness(jwt, options);
         if (this.authProvider && response.accessToken) {
-            await this.storeTokens(response.accessToken, response.refreshToken, 'business', jwt);
+            await this.storeTokens(response.accessToken, response.refreshToken, exports.AccountOwnerType.BUSINESS, jwt);
         }
         return response;
     }
@@ -27178,7 +27178,7 @@ class AuthService {
     async loginUserWithRawData(rawLoginData) {
         const response = await this.authApi.loginUnAuthenticated(rawLoginData);
         if (this.authProvider && response.accessToken) {
-            await this.storeTokens(response.accessToken, response.refreshToken, 'user');
+            await this.storeTokens(response.accessToken, response.refreshToken, exports.AccountOwnerType.USER);
         }
         return response;
     }
@@ -27660,7 +27660,7 @@ class DPoPManager {
 class DefaultAuthProvider {
     constructor(config = {}) {
         this.config = config;
-        this.authType = config.authType || 'user';
+        this.authType = config.authType || exports.AccountOwnerType.USER;
         const storage = config.storage || this.createStorage();
         this.tokenManager = new AuthTokenManager(storage);
         if (config.dpop?.enabled) {
@@ -27793,7 +27793,7 @@ class PersApiClient {
         // Auto-create auth provider if none provided
         if (!this.mergedConfig.authProvider) {
             this.mergedConfig.authProvider = new DefaultAuthProvider({
-                authType: this.mergedConfig.authType || 'user',
+                authType: this.mergedConfig.authType || exports.AccountOwnerType.USER,
                 projectKey: this.mergedConfig.apiProjectKey,
                 storage: this.mergedConfig.authStorage, // Support custom storage
                 dpop: {
@@ -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) {
@@ -28374,9 +28382,9 @@ class AuthManager {
      * console.log('Admin authenticated:', authResult.admin.email);
      * ```
      */
-    async loginWithToken(jwtToken, userType = 'user') {
+    async loginWithToken(jwtToken, userType = exports.AccountOwnerType.USER) {
         const authService = this.apiClient.getAuthService();
-        const result = userType === 'admin'
+        const result = userType === exports.AccountOwnerType.TENANT
             ? await authService.loginTenantAdmin(jwtToken)
             : await authService.loginUser(jwtToken);
         this.events?.emitSuccess({
@@ -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);
         }
     }
 }
@@ -34324,7 +34375,7 @@ function createReactNativeAuthProvider(projectKey, config = {}) {
     if (!projectKey || typeof projectKey !== 'string') {
         throw new Error('createReactNativeAuthProvider: projectKey is required and must be a string');
     }
-    const { keyPrefix = `pers_${projectKey.slice(0, 8)}_`, debug = false, customStorage, authType = 'user', dpop } = config;
+    const { keyPrefix = `pers_${projectKey.slice(0, 8)}_`, debug = false, customStorage, authType = exports.AccountOwnerType.USER, dpop } = config;
     // Platform-specific storage selection
     const tokenStorage = customStorage || (isWebPlatform
         ? new LocalStorageTokenStorage()
@@ -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,
@@ -34738,18 +34853,18 @@ const useAuth = () => {
      * Authenticates a user with a JWT token
      *
      * @param jwtToken - The JWT token to authenticate with
-     * @param userType - The type of user ('user' | 'admin'), defaults to 'user'
+     * @param userType - The type of user (AccountOwnerType), defaults to USER
      * @returns Promise resolving to session auth context with user data
      * @throws Error if SDK is not initialized or authentication fails
      *
      * @example
      * ```typescript
      * const { login } = useAuth();
-     * const result = await login(jwtToken, 'user');
+     * const result = await login(jwtToken, AccountOwnerType.USER);
      * console.log('Logged in user:', result.user);
      * ```
      */
-    const login = react.useCallback(async (jwtToken, userType = 'user') => {
+    const login = react.useCallback(async (jwtToken, userType = exports.AccountOwnerType.USER) => {
         if (!sdk || !authProvider) {
             throw new Error('SDK not initialized. Call initialize() first.');
         }