@fluxo-dev/api-client-base 25.4.2 → 26.1.1

package/index.cjs.js

@@ -2667,6 +2667,10 @@ let HttpClient$1 = class HttpClient {
       return config;
     }));
     this._axiosInstance.interceptors.response.use(response => response.data, error => {
+      if (error.code === 'ERR_NETWORK') return Promise.reject({
+        code: "ERR_NETWORK",
+        message: "Il server non è raggiungibile."
+      });
       if (error.response.status === 401) ;
       return Promise.reject({
         code: error.response.status,
@@ -9698,6 +9702,8 @@ class SessionHubService {
     this.eventHandlers = new Map();
     this.reconnectTimeoutId = null;
     this.isManualStop = false; // Flag to prevent reconnection after manual stop (e.g., logout)
+    this.hasReachedMaxAttempts = false; // Flag to track if max attempts reached
+    this.useAutomaticReconnect = true; // Flag to control automatic reconnection behavior
     this.hubUrl = `${baseUrl}/ws/session`;
     this.getAccessToken = getAccessToken;
   }
@@ -9723,27 +9729,50 @@ class SessionHubService {
         const deviceId = DeviceIdManager.getDeviceId();
         // Aggiungi device-id come query parameter all'URL
         const hubUrlWithDeviceId = `${this.hubUrl}?deviceId=${encodeURIComponent(deviceId)}`;
-        this.connection = new HubConnectionBuilder().withUrl(hubUrlWithDeviceId, {
+        const builder = new HubConnectionBuilder().withUrl(hubUrlWithDeviceId, {
           accessTokenFactory: () => this.getAccessToken(),
           transport: HttpTransportType.WebSockets,
           withCredentials: false
-        }).withAutomaticReconnect({
-          nextRetryDelayInMilliseconds: retryContext => {
-            // Exponential backoff: 0, 2, 10, 30 seconds, then 30 seconds
-            if (retryContext.previousRetryCount === 0) return 0;
-            if (retryContext.previousRetryCount === 1) return 2000;
-            if (retryContext.previousRetryCount === 2) return 10000;
-            return 30000;
-          }
-        }).configureLogging(LogLevel.Information).build();
+        });
+        // Conditionally add automatic reconnect based on flag
+        if (this.useAutomaticReconnect) {
+          builder.withAutomaticReconnect({
+            nextRetryDelayInMilliseconds: retryContext => {
+              // Track attempts using SignalR's counter
+              this.reconnectAttempts = retryContext.previousRetryCount + 1;
+              // Stop after max attempts
+              if (retryContext.previousRetryCount >= this.maxReconnectAttempts) {
+                console.warn(`SessionHub: Max automatic reconnection attempts (${this.maxReconnectAttempts}) reached`);
+                this.hasReachedMaxAttempts = true;
+                this.useAutomaticReconnect = false; // Disable for next connection
+                return null; // Stop automatic reconnection
+              }
+              // Exponential backoff: 0, 2, 10 seconds, then 5 seconds
+              if (retryContext.previousRetryCount === 0) return 0;
+              if (retryContext.previousRetryCount === 1) return 2000;
+              if (retryContext.previousRetryCount === 2) return 10000;
+              return this.reconnectDelay;
+            }
+          });
+        }
+        this.connection = builder.configureLogging(LogLevel.Information).build();
         this.setupConnectionHandlers();
         this.reattachEventHandlers();
         yield this.connection.start();
         console.info('SessionHub: Connection established successfully with device-id:', deviceId);
         this.reconnectAttempts = 0;
+        this.hasReachedMaxAttempts = false;
+        // Re-enable automatic reconnect for future disconnections
+        this.useAutomaticReconnect = true;
       } catch (error) {
         console.error('SessionHub: Error starting connection', error);
-        this.scheduleReconnect();
+        // Only schedule reconnect if in automatic mode
+        if (this.useAutomaticReconnect && !this.hasReachedMaxAttempts) {
+          this.scheduleReconnect();
+        } else {
+          // Manual mode: just set flag for UI
+          this.hasReachedMaxAttempts = true;
+        }
       }
     });
   }
@@ -9861,6 +9890,51 @@ class SessionHubService {
     var _a, _b;
     return (_b = (_a = this.connection) === null || _a === void 0 ? void 0 : _a.connectionId) !== null && _b !== void 0 ? _b : null;
   }
+  /**
+   * Get current reconnection attempts count
+   */
+  get currentReconnectAttempts() {
+    return this.reconnectAttempts;
+  }
+  /**
+   * Get max reconnection attempts limit
+   */
+  get maxReconnectAttemptsLimit() {
+    return this.maxReconnectAttempts;
+  }
+  /**
+   * Check if max reconnection attempts have been reached
+   */
+  get hasReachedMaxReconnectAttempts() {
+    return this.hasReachedMaxAttempts;
+  }
+  /**
+   * Manually retry connection - performs single connection attempt without automatic retries
+   * User must click retry button again if connection fails
+   */
+  manualRetry() {
+    return __awaiter(this, void 0, void 0, function* () {
+      console.info('SessionHub: Manual retry initiated by user');
+      // Reset counters and flags
+      this.reconnectAttempts = 0;
+      this.hasReachedMaxAttempts = false;
+      this.isManualStop = false;
+      this.useAutomaticReconnect = false; // Force manual mode - no automatic retries
+      // Cancel any pending reconnection attempt
+      if (this.reconnectTimeoutId) {
+        clearTimeout(this.reconnectTimeoutId);
+        this.reconnectTimeoutId = null;
+      }
+      // Attempt to start connection (will be without automatic reconnect)
+      try {
+        yield this.start();
+      } catch (error) {
+        console.error('SessionHub: Manual retry failed', error);
+        // Set flag so UI shows retry button again
+        this.hasReachedMaxAttempts = true;
+      }
+    });
+  }
   /**
    * Setup connection lifecycle handlers
    */
@@ -9868,14 +9942,30 @@ class SessionHubService {
     if (!this.connection) return;
     this.connection.onclose(error => {
       console.warn('SessionHub: Connection closed', error);
-      this.scheduleReconnect();
+      // Don't schedule reconnect if in manual mode - user must click retry button
+      if (!this.useAutomaticReconnect) {
+        console.info('SessionHub: In manual mode - waiting for user to retry');
+        this.hasReachedMaxAttempts = true;
+        return;
+      }
+      // In automatic mode, check if we've reached max attempts
+      if (this.reconnectAttempts >= this.maxReconnectAttempts) {
+        console.error('SessionHub: Max reconnection attempts reached');
+        this.hasReachedMaxAttempts = true;
+        this.useAutomaticReconnect = false;
+      } else {
+        // Schedule next reconnect attempt
+        this.scheduleReconnect();
+      }
     });
     this.connection.onreconnecting(error => {
-      console.warn('SessionHub: Attempting to reconnect...', error);
+      console.warn(`SessionHub: Attempting to reconnect... (attempt ${this.reconnectAttempts} of ${this.maxReconnectAttempts})`, error);
     });
     this.connection.onreconnected(connectionId => {
       console.info(`SessionHub: Reconnected successfully. ConnectionId: ${connectionId}`);
       this.reconnectAttempts = 0;
+      this.hasReachedMaxAttempts = false;
+      this.useAutomaticReconnect = true; // Re-enable automatic reconnect
     });
   }
   /**
@@ -9900,6 +9990,8 @@ class SessionHubService {
     }
     if (this.reconnectAttempts >= this.maxReconnectAttempts) {
       console.error('SessionHub: Max reconnection attempts reached. Giving up.');
+      this.hasReachedMaxAttempts = true;
+      this.useAutomaticReconnect = false; // Disable automatic reconnect
       return;
     }
     this.reconnectAttempts++;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fluxo-dev/api-client-base",
-  "version": "25.4.2",
+  "version": "26.1.1",
   "type": "commonjs",
   "peerDependencies": {
     "react": "^18.3.1",
@@ -8,7 +8,7 @@
     "react-router-dom": "^6.11.2",
     "react-redux": "^8.0.5",
     "@reduxjs/toolkit": "^1.9.1",
-    "@fluxo-dev/state": "^25.4.2"
+    "@fluxo-dev/state": "^26.1.1"
   },
   "main": "./index.cjs.js",
   "types": "./index.cjs.d.ts"

package/src/lib/session-hub/session-hub.service.d.ts

@@ -13,6 +13,8 @@ export declare class SessionHubService {
     private eventHandlers;
     private reconnectTimeoutId;
     private isManualStop;
+    private hasReachedMaxAttempts;
+    private useAutomaticReconnect;
     constructor(baseUrl: string, getAccessToken: () => string);
     getConnectedUsers(): Promise<{
         userId: string;
@@ -75,6 +77,23 @@ export declare class SessionHubService {
      * Get the connection ID
      */
     get connectionId(): string | null;
+    /**
+     * Get current reconnection attempts count
+     */
+    get currentReconnectAttempts(): number;
+    /**
+     * Get max reconnection attempts limit
+     */
+    get maxReconnectAttemptsLimit(): number;
+    /**
+     * Check if max reconnection attempts have been reached
+     */
+    get hasReachedMaxReconnectAttempts(): boolean;
+    /**
+     * Manually retry connection - performs single connection attempt without automatic retries
+     * User must click retry button again if connection fails
+     */
+    manualRetry(): Promise<void>;
     /**
      * Setup connection lifecycle handlers
      */