@fluxo-dev/api-client-base 1.0.0 → 25.1.2

package/index.cjs.js

@@ -2867,118 +2867,231 @@ class FluxoStateDispatcher {
   }
 }
 
+// Costanti per la gestione del refresh token
+const REFRESH_TOKEN_SAFETY_MARGIN_MS = 30000; // 30 secondi prima della scadenza
 class AuthService {
   constructor() {
-    RefreshTokenManager.Init(this.refreshToken, this.logout);
+    this.isRefreshingToken = false;
+    console.log("🔐 AuthService: Inizializzazione");
+    RefreshTokenManager.Init(() => this.refreshToken(), () => this.logout());
   }
   setup() {
     return __awaiter(this, void 0, void 0, function* () {
+      console.log("🔐 AuthService: Setup iniziato");
       yield this.tryAutoLogin();
+      console.log("🔐 AuthService: Setup completato");
     });
   }
   tryAutoLogin() {
     return __awaiter(this, void 0, void 0, function* () {
+      console.log("🔐 AuthService: Tentativo di auto-login");
       const accessToken = localStorage.getItem(LocalStorageConstants.accessToken);
-      if (accessToken) {
+      if (!accessToken) {
+        console.log("🔐 AuthService: Nessun access token trovato in localStorage, eseguo logout");
+        this.logout();
+        return;
+      }
+      try {
+        console.log("🔐 AuthService: Access token trovato, decodifica in corso");
         const decoded = o(accessToken);
         if (!decoded) {
+          console.log("🔐 AuthService: Decodifica del token fallita, eseguo logout");
           this.logout();
           return;
         }
-        if (decoded.exp <= new Date().getTime() / 1000) {
+        const currentTimeInSeconds = Math.floor(Date.now() / 1000);
+        console.log(`🔐 AuthService: Token exp: ${decoded.exp}, ora attuale (sec): ${currentTimeInSeconds}`);
+        if (decoded.exp <= currentTimeInSeconds) {
+          console.log("🔐 AuthService: Token scaduto, richiedo refresh");
           yield this.refreshToken();
         } else {
-          // Avvio il timeout indicando il tempo di attesa come scadenza token - 30 secondi.
-          // pertanto, 30 secondi prima della scadenza del token, Fluxo richiederà un nuovo token grazie al refresh token.
-          RefreshTokenManager.Instance.start(AuthService.getJwtTokenRemainingLifetime() - 30000);
+          console.log("🔐 AuthService: Token valido, calcolo tempo rimanente");
+          // Avvio il timeout 30 secondi prima della scadenza del token
+          const remainingLifetimeMs = AuthService.getJwtTokenRemainingLifetime();
+          if (remainingLifetimeMs) {
+            const timeoutMs = remainingLifetimeMs - REFRESH_TOKEN_SAFETY_MARGIN_MS;
+            console.log(`🔐 AuthService: Tempo rimanente: ${remainingLifetimeMs}ms, imposto refresh tra ${timeoutMs}ms`);
+            RefreshTokenManager.Instance.start(timeoutMs);
+          } else {
+            console.log("🔐 AuthService: Impossibile calcolare tempo rimanente per il token");
+          }
         }
-        FluxoStateDispatcher.dispatchAutoLoginSucceded(localStorage.getItem(LocalStorageConstants.userData));
+        const userData = localStorage.getItem(LocalStorageConstants.userData);
+        if (userData) {
+          console.log("🔐 AuthService: Dati utente trovati, dispatch auto-login riuscito");
+          FluxoStateDispatcher.dispatchAutoLoginSucceded(userData);
+        } else {
+          console.log("🔐 AuthService: Dati utente mancanti nel localStorage");
+        }
+      } catch (error) {
+        console.error("🔐 AuthService: Errore durante l'auto-login", error);
+        // Se c'è un errore nel decodificare il token, facciamo logout
+        this.logout();
       }
     });
   }
   login(username, password) {
     return __awaiter(this, void 0, void 0, function* () {
+      console.log(`🔐 AuthService: Tentativo di login per utente: ${username}`);
       try {
-        const data = yield HttpClient.Instance().client.post('/identity/authenticate', {
+        console.log("🔐 AuthService: Invio richiesta di autenticazione");
+        const response = yield HttpClient.Instance().client.post('/identity/authenticate', {
           username,
           password
         }, {
           withCredentials: true
         });
+        const data = response;
+        console.log("🔐 AuthService: Login riuscito, token ricevuto");
         localStorage.setItem(LocalStorageConstants.accessToken, data.token);
         localStorage.setItem(LocalStorageConstants.userData, JSON.stringify(data.userData));
-        RefreshTokenManager.Instance.start(AuthService.getJwtTokenRemainingLifetime() - 60);
+        console.log("🔐 AuthService: Token e dati utente salvati in localStorage");
+        const remainingLifetimeMs = AuthService.getJwtTokenRemainingLifetime();
+        if (remainingLifetimeMs) {
+          const timeoutMs = remainingLifetimeMs - REFRESH_TOKEN_SAFETY_MARGIN_MS;
+          console.log(`🔐 AuthService: Imposto refresh token tra ${timeoutMs}ms`);
+          RefreshTokenManager.Instance.start(timeoutMs);
+        } else {
+          console.log("🔐 AuthService: Impossibile calcolare tempo rimanente per il token");
+        }
+        console.log("🔐 AuthService: Dispatch evento login utente");
         FluxoStateDispatcher.dispatchUserLogin({
           data
         });
-      } catch (err) {
+        return true;
+      } catch (error) {
+        console.error("🔐 AuthService: Errore durante il login", error);
         FluxoStateDispatcher.dispatchUserLogin(null);
+        return false;
       }
     });
   }
   logout() {
+    console.log("🔐 AuthService: Esecuzione logout");
     RefreshTokenManager.Instance.stop();
     localStorage.removeItem(LocalStorageConstants.accessToken);
     localStorage.removeItem(LocalStorageConstants.userData);
+    console.log("🔐 AuthService: Token e dati utente rimossi da localStorage");
+    console.log("🔐 AuthService: Dispatch evento logout utente");
     FluxoStateDispatcher.dispatchUserLogout();
   }
   refreshToken() {
     return __awaiter(this, void 0, void 0, function* () {
+      console.log("🔐 AuthService: Tentativo di refresh token");
+      // Previeni multiple richieste di refresh contemporaneamente
+      if (this.isRefreshingToken) {
+        console.log("🔐 AuthService: Refresh già in corso, richiesta ignorata");
+        return false;
+      }
+      this.isRefreshingToken = true;
+      console.log("🔐 AuthService: Flag isRefreshingToken impostato a true");
       try {
-        const data = yield HttpClient.Instance().client.post('/identity/refresh-token', {}, {
+        console.log("🔐 AuthService: Invio richiesta di refresh token");
+        const response = yield HttpClient.Instance().client.post('/identity/refresh-token', {}, {
           withCredentials: true
         });
+        const data = response;
+        console.log("🔐 AuthService: Refresh token riuscito, nuovo token ricevuto");
         localStorage.setItem(LocalStorageConstants.accessToken, data.token);
         localStorage.setItem(LocalStorageConstants.userData, JSON.stringify(data.userData));
+        console.log("🔐 AuthService: Nuovo token e dati utente salvati in localStorage");
         RefreshTokenManager.Instance.stop();
-        RefreshTokenManager.Instance.start(AuthService.getJwtTokenRemainingLifetime() - 10000);
-      } catch (err) {
-        localStorage.removeItem(LocalStorageConstants.accessToken);
-        localStorage.removeItem(LocalStorageConstants.userData);
+        console.log("🔐 AuthService: Timeout precedente fermato");
+        const remainingLifetimeMs = AuthService.getJwtTokenRemainingLifetime();
+        if (remainingLifetimeMs) {
+          const timeoutMs = remainingLifetimeMs - REFRESH_TOKEN_SAFETY_MARGIN_MS;
+          console.log(`🔐 AuthService: Imposto nuovo refresh token tra ${timeoutMs}ms`);
+          RefreshTokenManager.Instance.start(timeoutMs);
+        } else {
+          console.log("🔐 AuthService: Impossibile calcolare tempo rimanente per il nuovo token");
+        }
+        this.isRefreshingToken = false;
+        console.log("🔐 AuthService: Flag isRefreshingToken reimpostato a false");
+        return true;
+      } catch (error) {
+        console.error("🔐 AuthService: Errore durante il refresh token", error);
+        this.isRefreshingToken = false;
+        console.log("🔐 AuthService: Flag isRefreshingToken reimpostato a false dopo errore");
         this.logout();
+        return false;
       }
     });
   }
   static getJwtTokenRemainingLifetime() {
+    console.log("🔐 AuthService: Calcolo tempo rimanente del token");
     const token = localStorage.getItem(LocalStorageConstants.accessToken);
     if (!token) {
-      throw new Error('Called getJwtTokenRemainingLifetime but no access token found');
+      console.warn('🔐 AuthService: Called getJwtTokenRemainingLifetime but no access token found');
+      return null;
+    }
+    try {
+      const decoded = o(token);
+      const expTimeInSeconds = decoded.exp;
+      const currentTimeInMs = Date.now();
+      const expTimeInMs = expTimeInSeconds * 1000;
+      const diffMs = expTimeInMs - currentTimeInMs;
+      console.log(`🔐 AuthService: Token scade in ${diffMs}ms (${Math.round(diffMs / 1000 / 60)} minuti)`);
+      return diffMs <= 0 ? 0 : diffMs;
+    } catch (error) {
+      console.error('🔐 AuthService: Error decoding JWT token', error);
+      return null;
     }
-    const decoded = o(token);
-    const exp = +decoded.exp;
-    const dateNow = new Date(Date.now()).getTime();
-    const diff = exp * 1000 - dateNow;
-    return diff <= 0 ? 0 : diff;
   }
 }
 class RefreshTokenManager {
-  constructor(action, onErrorCallback) {
-    this.event = new Event('build');
-    this._refreshTokenInterval = null;
-    this._actionOnTimeout = action;
+  constructor(refreshAction, onErrorCallback) {
+    this._refreshTokenTimeout = null;
+    console.log("🔄 RefreshTokenManager: Inizializzazione");
+    this._refreshTokenAction = refreshAction;
     this._onErrorCallback = onErrorCallback;
   }
-  static Init(actionOnTimeout, onErrorCallback) {
-    this._instance = new this(actionOnTimeout, onErrorCallback);
+  static Init(refreshAction, onErrorCallback) {
+    console.log("🔄 RefreshTokenManager: Init chiamato");
+    if (!this._instance) {
+      console.log("🔄 RefreshTokenManager: Creazione nuova istanza");
+      this._instance = new RefreshTokenManager(refreshAction, onErrorCallback);
+    } else {
+      console.log("🔄 RefreshTokenManager: Istanza già esistente");
+    }
   }
   static get Instance() {
-    if (!this._instance) throw new Error('RefreshTokenManager not initialized');
+    if (!this._instance) {
+      console.error("🔄 RefreshTokenManager: Tentativo di accesso all'istanza prima dell'inizializzazione");
+      throw new Error('RefreshTokenManager not initialized');
+    }
     return this._instance;
   }
   start(timeoutMs) {
-    console.info('   - start refresh token:' + timeoutMs + 'ms');
-    if (this._actionOnTimeout === undefined) throw new Error('RefreshTokenManager not initialized');
-    this._refreshTokenInterval = setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+    // Arrotonda il timeout a un valore positivo
+    const safeTimeoutMs = Math.max(1000, Math.floor(timeoutMs));
+    console.log(`🔄 RefreshTokenManager: Avvio refresh token in: ${safeTimeoutMs}ms (${Math.round(safeTimeoutMs / 1000 / 60)} minuti)`);
+    // Assicuriamoci di fermare qualsiasi timeout precedente
+    this.stop();
+    this._refreshTokenTimeout = setTimeout(() => __awaiter(this, void 0, void 0, function* () {
+      console.log("🔄 RefreshTokenManager: Timeout scaduto, esecuzione refresh token");
       try {
-        yield this._actionOnTimeout();
-      } catch (err) {
+        const success = yield this._refreshTokenAction();
+        console.log(`🔄 RefreshTokenManager: Refresh token completato con ${success ? 'successo' : 'fallimento'}`);
+        if (!success) {
+          console.log("🔄 RefreshTokenManager: Chiamata callback di errore");
+          this._onErrorCallback();
+        }
+      } catch (error) {
+        console.error('🔄 RefreshTokenManager: Errore durante refresh token', error);
+        console.log("🔄 RefreshTokenManager: Chiamata callback di errore dopo eccezione");
         this._onErrorCallback();
       }
-    }), timeoutMs);
+    }), safeTimeoutMs);
   }
   stop() {
-    console.info('   - stop refresh token');
-    clearInterval(this._refreshTokenInterval);
+    console.log('🔄 RefreshTokenManager: Stop refresh token');
+    if (this._refreshTokenTimeout) {
+      console.log('🔄 RefreshTokenManager: Cancellazione timeout esistente');
+      clearTimeout(this._refreshTokenTimeout);
+      this._refreshTokenTimeout = null;
+    } else {
+      console.log('🔄 RefreshTokenManager: Nessun timeout attivo da cancellare');
+    }
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fluxo-dev/api-client-base",
-  "version": "1.0.0",
+  "version": "25.1.2",
   "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": "^1.0.0"
+    "@fluxo-dev/state": "^25.1.2"
   },
   "main": "./index.cjs.js",
   "types": "./index.cjs.d.ts"

package/src/lib/auth/auth-service.d.ts

@@ -1,9 +1,10 @@
 export declare class AuthService {
+    private isRefreshingToken;
     constructor();
     setup(): Promise<void>;
     private tryAutoLogin;
-    login(username: string, password: string): Promise<any>;
+    login(username: string, password: string): Promise<boolean>;
     logout(): void;
-    refreshToken(): Promise<any>;
+    refreshToken(): Promise<boolean>;
     static getJwtTokenRemainingLifetime(): number | null;
 }