@explorins/pers-sdk-react-native 1.5.21 → 1.5.22

package/dist/index.js

@@ -22632,17 +22632,21 @@ class ErrorUtils {
         if (typeof error !== 'object' || error === null)
             return false;
         const err = error;
-        const apiError = err?.error || err?.response?.data || err;
-        const status = err?.status || err?.response?.status || err?.statusCode;
-        // Explicit token expired messages
+        // Check for explicit token expired indicators
+        if (err?.code === 'TOKEN_EXPIRED' || err?.errorCode === 'TOKEN_EXPIRED') {
+            return true;
+        }
+        // Check in response data
+        const apiError = err?.response?.data || err;
         if (apiError?.code === 'TOKEN_EXPIRED' || apiError?.errorCode === 'TOKEN_EXPIRED') {
             return true;
         }
-        // Any 401 Unauthorized error should be treated as token expiration for auth flows
+        // Any 401 error is treated as token expiration
+        const status = err?.status || err?.statusCode || err?.response?.status;
         if (status === 401) {
             return true;
         }
-        // Check for token-related messages in other error formats
+        // Check for token-related messages
         const message = apiError?.message || err?.message || '';
         if (message && typeof message === 'string') {
             const lowerMessage = message.toLowerCase();
@@ -22659,8 +22663,9 @@ class ErrorUtils {
         if (typeof error !== 'object' || error === null)
             return 'Unknown error';
         const err = error;
-        const apiError = err?.error || err?.response?.data || err;
-        return apiError?.message || apiError?.detail || err?.message || 'Request failed';
+        // Try structured error first
+        const apiError = err?.response?.data || err;
+        return apiError?.message || apiError?.detail || apiError?.userMessage || err?.message || 'Request failed';
     }
     /**
      * Fast status code extraction
@@ -22669,6 +22674,7 @@ class ErrorUtils {
         if (typeof error !== 'object' || error === null)
             return null;
         const err = error;
+        // Direct properties first
         return err?.status || err?.statusCode || err?.response?.status || null;
     }
     /**
@@ -22678,11 +22684,14 @@ class ErrorUtils {
         if (typeof error !== 'object' || error === null)
             return false;
         const err = error;
-        // Check explicit retryable property first (fastest)
+        // Check explicit retryable property
+        const apiError = err?.response?.data || err;
+        if (typeof apiError?.retryable === 'boolean')
+            return apiError.retryable;
         if (typeof err?.retryable === 'boolean')
             return err.retryable;
-        // Fast status-based check
-        const status = ErrorUtils.getStatus(error);
+        // Status-based check
+        const status = this.getStatus(error);
         return status === null || status >= 500 || status === 429;
     }
     /**
@@ -22694,6 +22703,11 @@ class ErrorUtils {
             // Try to extract structured error response from HTTP error
             if (error && typeof error === 'object') {
                 const httpError = error;
+                // Use centralized parsing for React Native HTTP client format
+                const parsedError = this.parseHttpClientError(error);
+                if (parsedError && typeof parsedError === 'object') {
+                    return parsedError;
+                }
                 // Check if error has response data (common in HTTP clients)
                 if (httpError.response?.data) {
                     return httpError.response.data;
@@ -22729,6 +22743,38 @@ class ErrorUtils {
             };
         }
     }
+    /**
+     * Parse React Native HTTP client error format
+     * Handles format: "HTTP 401: Unauthorized - {json}"
+     */
+    static parseHttpClientError(error) {
+        try {
+            if (typeof error === 'object' && error !== null) {
+                const err = error;
+                const message = err?.message || '';
+                if (typeof message === 'string' && message.includes('HTTP') && message.includes(' - ')) {
+                    // Extract JSON part after " - "
+                    const jsonStart = message.lastIndexOf(' - ');
+                    if (jsonStart !== -1) {
+                        const jsonStr = message.substring(jsonStart + 3);
+                        if (jsonStr.trim()) {
+                            try {
+                                return JSON.parse(jsonStr);
+                            }
+                            catch {
+                                // If JSON parsing fails, return the raw string as message
+                                return { message: jsonStr };
+                            }
+                        }
+                    }
+                }
+            }
+            return null;
+        }
+        catch {
+            return null;
+        }
+    }
     /**
      * Check if error is from PERS API (uses @explorins/pers-shared format)
      */
@@ -26091,13 +26137,11 @@ class TokenRefreshManager {
             if (isTokenExpired(token, this.tokenRefreshMarginSeconds)) {
                 const refreshSuccess = await this.attemptInternalRefresh();
                 if (!refreshSuccess) {
-                    // Failed to refresh - delegate cleanup to AuthService  
                     await this.authService.handleAuthFailure();
                 }
             }
         }
         catch (error) {
-            // Delegate token cleanup to AuthService for consistency
             await this.authService.handleAuthFailure();
         }
     }
@@ -26107,7 +26151,6 @@ class TokenRefreshManager {
             return true;
         }
         catch (error) {
-            // Check if this is a 401 error and set auth failure flag
             const isAuthError = error && typeof error === 'object' && 'status' in error && error.status === 401;
             if (isAuthError) {
                 await this.authService.handleAuthFailure();
@@ -26368,7 +26411,6 @@ class PersApiClient {
     async ensureInitialized() {
         if (this.initializationPromise) {
             await this.initializationPromise;
-            // Clear after successful initialization to prevent holding references
             this.initializationPromise = null;
         }
     }
@@ -26384,8 +26426,9 @@ class PersApiClient {
         }
         const { retryCount = 0, responseType = 'json', bypassAuth = false } = options || {};
         const url = `${this.apiRoot}${endpoint}`;
-        // Proactive token validation for optimal performance
+        // SMART TOKEN VALIDATION: Only check if we suspect the token might be expired
         if (!bypassAuth && this.mergedConfig.authProvider && retryCount === 0) {
+            // Fire-and-forget validation - don't block the request unless we know there's an issue
             this.ensureValidToken().catch(error => {
                 console.debug('[PersApiClient] Background token validation failed:', error);
             });
@@ -26437,7 +26480,7 @@ class PersApiClient {
                         }
                     }
                     catch (refreshError) {
-                        // Refresh failed - let auth service handle it
+                        // console.error('[PersApiClient] Token refresh failed:', refreshError);
                     }
                 }
                 // Auth failure - let AuthService handle cleanup and notify app
@@ -31828,18 +31871,18 @@ class ReactNativeHttpClient {
         try {
             const response = await fetch(fullUrl, config);
             if (!response.ok) {
-                // Try to get error details from response
-                let errorMessage = `HTTP ${response.status}: ${response.statusText}`;
+                // Get raw error response for ErrorUtils to handle
+                let errorText = '';
                 try {
-                    const errorBody = await response.text();
-                    if (errorBody) {
-                        errorMessage += ` - ${errorBody}`;
-                    }
+                    errorText = await response.text();
                 }
                 catch (e) {
                     // Ignore errors when reading error body
                 }
-                throw new Error(errorMessage);
+                // Create simple error with HTTP status and raw response
+                const httpError = new Error(`HTTP ${response.status}: ${response.statusText} - ${errorText}`);
+                httpError.status = response.status;
+                throw httpError;
             }
             // Handle different response types
             switch (options?.responseType) {