@uxland/primary-shell 7.43.1 → 7.43.2

package/dist/primary/shell/src/api/session-refresh-timer/session-refresh-timer.d.ts

@@ -1,5 +1,4 @@
 import { ActivityMonitor } from '../activity-monitor/activity-monitor';
-import { PrimariaBroker } from '../broker/primaria-broker';
 import { TokenManager } from '../token-manager/token-manager';
 export interface SessionRefreshTimer {
     start: () => void;
@@ -8,13 +7,12 @@ export interface SessionRefreshTimer {
 export declare class SessionRefreshTimerImpl implements SessionRefreshTimer {
     private readonly tokenManager;
     private readonly activityMonitor;
-    private readonly broker;
     private intervalId;
     private isRefreshing;
-    constructor(tokenManager: TokenManager, activityMonitor: ActivityMonitor, broker: PrimariaBroker);
+    constructor(tokenManager: TokenManager, activityMonitor: ActivityMonitor);
     start: () => void;
     stop: () => void;
     private getTokenExpiry;
     private checkAndRefresh;
 }
-export declare const createSessionRefreshTimer: (tokenManager: TokenManager, activityMonitor: ActivityMonitor, broker: PrimariaBroker) => SessionRefreshTimer;
+export declare const createSessionRefreshTimer: (tokenManager: TokenManager, activityMonitor: ActivityMonitor) => SessionRefreshTimer;

package/dist/primary/shell/src/api/token-manager/token-manager.d.ts

@@ -1,13 +1,16 @@
+import { PrimariaBroker } from '../broker/primaria-broker';
 export interface TokenManager {
     setInitialTokens: (access_token: string, refresh_token: string) => void;
     getToken: () => string;
     refreshToken: () => Promise<string>;
 }
 export declare class TokenManagerImpl implements TokenManager {
+    private readonly broker;
+    constructor(broker: PrimariaBroker);
     getUrlParams: () => URLSearchParams;
     private initToken;
     setInitialTokens: (access_token: string, refresh_token: string) => void;
     getToken: () => string;
     refreshToken: () => Promise<string>;
 }
-export declare const createTokenManager: () => TokenManagerImpl;
+export declare const createTokenManager: (broker: PrimariaBroker) => TokenManagerImpl;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uxland/primary-shell",
-  "version": "7.43.1",
+  "version": "7.43.2",
   "description": "Primaria Shell",
   "author": "UXLand <dev@uxland.es>",
   "homepage": "https://github.com/uxland/harmonix/tree/app#readme",

package/src/api/api.ts

@@ -44,10 +44,10 @@ export interface PrimariaApi extends HarmonixApi {
 
 const regionManager: RegionManager = createRegionManager("primaria");
 export const PrimariaRegionHost: any = createRegionHost(regionManager as any);
-const tokenManager = createTokenManager();
+const tokenManager = createTokenManager(broker);
 const userManager = createUserManager(tokenManager);
 export const activityMonitor = createActivityMonitor();
-export const sessionRefreshTimer = createSessionRefreshTimer(tokenManager, activityMonitor, broker);
+export const sessionRefreshTimer = createSessionRefreshTimer(tokenManager, activityMonitor);
 const globalStateManager: PrimariaGlobalStateManager = createGlobalStateManager(broker);
 const contextManager = createContextManager();
 const pluginBusyManager = new PluginBusyManagerImpl();

package/src/api/http-client/http-client.test.ts

@@ -28,7 +28,7 @@ describe("HTTP Client", () => {
 
   describe("Without validateMpid", () => {
     beforeEach(() => {
-      tokenManager = createTokenManager();
+      tokenManager = createTokenManager(broker);
       axiosInstance = createAxiosInstance(tokenManager, broker);
       axiosMockInstance = new AxiosMockAdapter(axiosInstance);
       axiosMockInstance.reset();
@@ -91,10 +91,7 @@ describe("HTTP Client", () => {
       );
 
       expect(axiosMockInstance.history.get?.length).toBe(1); // No retry happened
-      expect(brokerSpy).toHaveBeenCalledWith(BROKER_EVENTS.shell.refreshTokenFailed, expect.any(Object));
-      expect(brokerSpy).toHaveBeenCalledWith(BROKER_EVENTS.shell.refreshTokenFailed, {
-        request: expect.objectContaining({ url: "/api/clinical-course" }),
-      });
+      expect(brokerSpy).toHaveBeenCalledWith(BROKER_EVENTS.shell.refreshTokenFailed, {});
     });
 
     it("should fail request with error != 401 and should not retry", async () => {
@@ -113,7 +110,7 @@ describe("HTTP Client", () => {
   describe.skip("With validateMpid", () => {
     const validTokenHeaders = { "x-catsalut-mpid": "5ec74c7b-5aa5-4a84-b3b4-f02eddfdf6dc" };
     beforeEach(() => {
-      tokenManager = createTokenManager();
+      tokenManager = createTokenManager(broker);
       axiosInstance = createAxiosInstance(tokenManager, broker, true);
       axiosMockInstance = new AxiosMockAdapter(axiosInstance);
       axiosMockInstance.reset();
@@ -200,10 +197,7 @@ describe("HTTP Client", () => {
       );
 
       expect(axiosMockInstance.history.get?.length).toBe(1); // No retry happened
-      expect(brokerSpy).toHaveBeenCalledWith(BROKER_EVENTS.shell.refreshTokenFailed, expect.any(Object));
-      expect(brokerSpy).toHaveBeenCalledWith(BROKER_EVENTS.shell.refreshTokenFailed, {
-        request: expect.objectContaining({ url: "/api/clinical-course" }),
-      });
+      expect(brokerSpy).toHaveBeenCalledWith(BROKER_EVENTS.shell.refreshTokenFailed, {});
     });
 
     it("should fail request with error != 401 and should not retry", async () => {

package/src/api/http-client/http-client.ts

@@ -69,9 +69,6 @@ export const createAxiosInstance = (
           return instance(originalRequest);
         } catch (refreshError) {
           console.error("Error refreshing token:", refreshError);
-          broker.publish(BROKER_EVENTS.shell.refreshTokenFailed, {
-            request: originalRequest,
-          });
           return Promise.reject(error);
         }
       }

package/src/api/session-refresh-timer/session-refresh-timer.test.ts

@@ -1,5 +1,4 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import { BROKER_EVENTS } from "../broker/broker-events";
 import { SessionRefreshTimerImpl } from "./session-refresh-timer";
 
 const createJwt = (exp: number): string => {
@@ -23,20 +22,9 @@ const createMockActivityMonitor = (lastActivity = Date.now()) => ({
   getLastActivityTimestamp: vi.fn().mockReturnValue(lastActivity),
 });
 
-const createMockBroker = () => ({
-  publish: vi.fn().mockResolvedValue(undefined),
-  subscribe: vi.fn(),
-  send: vi.fn(),
-  registerRequest: vi.fn(),
-  events: BROKER_EVENTS,
-});
-
 describe("SessionRefreshTimer", () => {
-  let mockBroker: ReturnType<typeof createMockBroker>;
-
   beforeEach(() => {
     vi.useFakeTimers();
-    mockBroker = createMockBroker();
   });
 
   afterEach(() => {
@@ -48,11 +36,7 @@ describe("SessionRefreshTimer", () => {
     const tokenManager = createMockTokenManager({
       getToken: vi.fn().mockReturnValue(createJwt(Math.floor(Date.now() / 1000) + 60)),
     });
-    const timer = new SessionRefreshTimerImpl(
-      tokenManager,
-      createMockActivityMonitor(0),
-      mockBroker,
-    );
+    const timer = new SessionRefreshTimerImpl(tokenManager, createMockActivityMonitor(0));
 
     timer.start();
     await vi.advanceTimersByTimeAsync(30_000);
@@ -64,11 +48,7 @@ describe("SessionRefreshTimer", () => {
     const tokenManager = createMockTokenManager({
       getToken: vi.fn().mockReturnValue(createJwt(Math.floor(Date.now() / 1000) + 3600)),
     });
-    const timer = new SessionRefreshTimerImpl(
-      tokenManager,
-      createMockActivityMonitor(),
-      mockBroker,
-    );
+    const timer = new SessionRefreshTimerImpl(tokenManager, createMockActivityMonitor());
 
     timer.start();
     await vi.advanceTimersByTimeAsync(30_000);
@@ -80,11 +60,7 @@ describe("SessionRefreshTimer", () => {
     const tokenManager = createMockTokenManager({
       getToken: vi.fn().mockReturnValue(createJwt(Math.floor(Date.now() / 1000) + 60)),
     });
-    const timer = new SessionRefreshTimerImpl(
-      tokenManager,
-      createMockActivityMonitor(),
-      mockBroker,
-    );
+    const timer = new SessionRefreshTimerImpl(tokenManager, createMockActivityMonitor());
 
     timer.start();
     await vi.advanceTimersByTimeAsync(30_000);
@@ -96,11 +72,7 @@ describe("SessionRefreshTimer", () => {
     const tokenManager = createMockTokenManager({
       getToken: vi.fn().mockReturnValue(createJwt(Math.floor(Date.now() / 1000) - 60)),
     });
-    const timer = new SessionRefreshTimerImpl(
-      tokenManager,
-      createMockActivityMonitor(),
-      mockBroker,
-    );
+    const timer = new SessionRefreshTimerImpl(tokenManager, createMockActivityMonitor());
 
     timer.start();
     await vi.advanceTimersByTimeAsync(30_000);
@@ -108,23 +80,6 @@ describe("SessionRefreshTimer", () => {
     expect(tokenManager.refreshToken).toHaveBeenCalledTimes(1);
   });
 
-  it("should publish refreshTokenFailed when refresh throws", async () => {
-    const tokenManager = createMockTokenManager({
-      getToken: vi.fn().mockReturnValue(createJwt(Math.floor(Date.now() / 1000) - 60)),
-      refreshToken: vi.fn().mockRejectedValue(new Error("Refresh failed")),
-    });
-    const timer = new SessionRefreshTimerImpl(
-      tokenManager,
-      createMockActivityMonitor(),
-      mockBroker,
-    );
-
-    timer.start();
-    await vi.advanceTimersByTimeAsync(30_000);
-
-    expect(mockBroker.publish).toHaveBeenCalledWith(BROKER_EVENTS.shell.refreshTokenFailed, {});
-  });
-
   it("should not trigger concurrent refreshes", async () => {
     let resolveRefresh!: () => void;
     const tokenManager = createMockTokenManager({
@@ -133,11 +88,7 @@ describe("SessionRefreshTimer", () => {
         () => new Promise((resolve) => { resolveRefresh = () => resolve("new_token"); }),
       ),
     });
-    const timer = new SessionRefreshTimerImpl(
-      tokenManager,
-      createMockActivityMonitor(),
-      mockBroker,
-    );
+    const timer = new SessionRefreshTimerImpl(tokenManager, createMockActivityMonitor());
 
     timer.start();
     await vi.advanceTimersByTimeAsync(30_000);

package/src/api/session-refresh-timer/session-refresh-timer.ts

@@ -1,7 +1,5 @@
 import { jwtDecode } from "jwt-decode";
 import { ActivityMonitor } from "../activity-monitor/activity-monitor";
-import { BROKER_EVENTS } from "../broker/broker-events";
-import { PrimariaBroker } from "../broker/primaria-broker";
 import { TokenManager } from "../token-manager/token-manager";
 
 const CHECK_INTERVAL_MS = 30_000;
@@ -20,7 +18,6 @@ export class SessionRefreshTimerImpl implements SessionRefreshTimer {
   constructor(
     private readonly tokenManager: TokenManager,
     private readonly activityMonitor: ActivityMonitor,
-    private readonly broker: PrimariaBroker,
   ) {}
 
   start = () => {
@@ -64,7 +61,7 @@ export class SessionRefreshTimerImpl implements SessionRefreshTimer {
       try {
         await this.tokenManager.refreshToken();
       } catch {
-        this.broker.publish(BROKER_EVENTS.shell.refreshTokenFailed, {});
+        // tokenManager.refreshToken() publishes refreshTokenFailed via broker on failure
       } finally {
         this.isRefreshing = false;
       }
@@ -75,5 +72,4 @@ export class SessionRefreshTimerImpl implements SessionRefreshTimer {
 export const createSessionRefreshTimer = (
   tokenManager: TokenManager,
   activityMonitor: ActivityMonitor,
-  broker: PrimariaBroker,
-): SessionRefreshTimer => new SessionRefreshTimerImpl(tokenManager, activityMonitor, broker);
+): SessionRefreshTimer => new SessionRefreshTimerImpl(tokenManager, activityMonitor);

package/src/api/token-manager/token-manager.test.ts

@@ -1,5 +1,6 @@
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import axios from "axios";
+import { BROKER_EVENTS } from "../broker/broker-events";
 
 vi.mock("axios");
 
@@ -8,10 +9,19 @@ const refresh_token = "test_refresh_token";
 const new_access_token = "new_access_token";
 const new_refresh_token = "new_refresh_token";
 
+const createMockBroker = () => ({
+  publish: vi.fn().mockResolvedValue(undefined),
+  subscribe: vi.fn(),
+  send: vi.fn(),
+  registerRequest: vi.fn(),
+  events: BROKER_EVENTS,
+});
+
 describe("TokenManager", () => {
   let mockLocation: Partial<Location>;
   let TokenManagerImpl: any;
   let createTokenManager: any;
+  let mockBroker: ReturnType<typeof createMockBroker>;
 
   beforeEach(async () => {
     vi.resetModules();
@@ -19,6 +29,7 @@ describe("TokenManager", () => {
       search: `?access_token=${access_token}&refresh_token=${refresh_token}`,
     };
     vi.spyOn(window, "location", "get").mockReturnValue(mockLocation as Location);
+    mockBroker = createMockBroker();
 
     const module = await import("./token-manager");
     TokenManagerImpl = module.TokenManagerImpl;
@@ -31,31 +42,31 @@ describe("TokenManager", () => {
 
   describe("getToken", () => {
     it("should initialize token from URL params on first call", () => {
-      const tokenManager = new TokenManagerImpl();
+      const tokenManager = new TokenManagerImpl(mockBroker);
       expect(tokenManager.getToken()).toBe(access_token);
     });
 
     it("should return empty string if URL params are missing", () => {
       mockLocation.search = "";
-      const tokenManager = new TokenManagerImpl();
+      const tokenManager = new TokenManagerImpl(mockBroker);
       expect(tokenManager.getToken()).toBe("");
     });
 
     it("should return the same token on subsequent calls", () => {
-      const tokenManager = new TokenManagerImpl();
+      const tokenManager = new TokenManagerImpl(mockBroker);
       expect(tokenManager.getToken()).toBe(tokenManager.getToken());
     });
   });
 
   describe("setInitialTokens", () => {
     it("should set tokens manually", () => {
-      const tokenManager = new TokenManagerImpl();
+      const tokenManager = new TokenManagerImpl(mockBroker);
       tokenManager.setInitialTokens("manual_access", "manual_refresh");
       expect(tokenManager.getToken()).toBe("manual_access");
     });
 
     it("should throw error if tokens are already initialized", () => {
-      const tokenManager = new TokenManagerImpl();
+      const tokenManager = new TokenManagerImpl(mockBroker);
       tokenManager.setInitialTokens("manual_access", "manual_refresh");
       expect(() => tokenManager.setInitialTokens("another_access", "another_refresh")).toThrow(
         "Token already initialized",
@@ -63,7 +74,7 @@ describe("TokenManager", () => {
     });
 
     it("should throw error if tokens were already initialized from URL", () => {
-      const tokenManager = new TokenManagerImpl();
+      const tokenManager = new TokenManagerImpl(mockBroker);
       tokenManager.getToken();
       expect(() => tokenManager.setInitialTokens("manual_access", "manual_refresh")).toThrow(
         "Token already initialized",
@@ -77,7 +88,7 @@ describe("TokenManager", () => {
         data: { access_token: new_access_token, refresh_token: new_refresh_token },
       });
 
-      const tokenManager = new TokenManagerImpl();
+      const tokenManager = new TokenManagerImpl(mockBroker);
       tokenManager.setInitialTokens(access_token, refresh_token);
 
       const refreshed = await tokenManager.refreshToken();
@@ -92,7 +103,7 @@ describe("TokenManager", () => {
         data: { access_token: new_access_token, refresh_token: new_refresh_token },
       });
 
-      const tokenManager = new TokenManagerImpl();
+      const tokenManager = new TokenManagerImpl(mockBroker);
       await tokenManager.refreshToken();
 
       expect(axios.post).toHaveBeenCalledWith("/api/token/refresh", { token: refresh_token });
@@ -101,25 +112,38 @@ describe("TokenManager", () => {
     it("should throw error if refresh response doesn't contain access_token", async () => {
       vi.mocked(axios.post).mockResolvedValue({ data: {} });
 
-      const tokenManager = new TokenManagerImpl();
+      const tokenManager = new TokenManagerImpl(mockBroker);
       tokenManager.setInitialTokens(access_token, refresh_token);
 
       await expect(tokenManager.refreshToken()).rejects.toThrow("Invalid refresh token response");
     });
 
-    it("should handle axios errors", async () => {
+    it("should publish refreshTokenFailed and rethrow when refresh fails", async () => {
       vi.mocked(axios.post).mockRejectedValue(new Error("Network error"));
 
-      const tokenManager = new TokenManagerImpl();
+      const tokenManager = new TokenManagerImpl(mockBroker);
       tokenManager.setInitialTokens(access_token, refresh_token);
 
       await expect(tokenManager.refreshToken()).rejects.toThrow("Network error");
+      expect(mockBroker.publish).toHaveBeenCalledWith(BROKER_EVENTS.shell.refreshTokenFailed, {});
+    });
+
+    it("should not publish refreshTokenFailed when refresh succeeds", async () => {
+      vi.mocked(axios.post).mockResolvedValue({
+        data: { access_token: new_access_token, refresh_token: new_refresh_token },
+      });
+
+      const tokenManager = new TokenManagerImpl(mockBroker);
+      tokenManager.setInitialTokens(access_token, refresh_token);
+
+      await tokenManager.refreshToken();
+      expect(mockBroker.publish).not.toHaveBeenCalled();
     });
   });
 
   describe("createTokenManager", () => {
     it("should return a singleton instance", () => {
-      expect(createTokenManager()).toBe(createTokenManager());
+      expect(createTokenManager(mockBroker)).toBe(createTokenManager(mockBroker));
     });
   });
 });

package/src/api/token-manager/token-manager.ts

@@ -1,4 +1,6 @@
 import axios from "axios";
+import { BROKER_EVENTS } from "../broker/broker-events";
+import { PrimariaBroker } from "../broker/primaria-broker";
 
 export interface TokenManager {
   setInitialTokens: (access_token: string, refresh_token: string) => void;
@@ -11,6 +13,8 @@ let refreshToken: string;
 let tokenInitialized = false;
 
 export class TokenManagerImpl implements TokenManager {
+  constructor(private readonly broker: PrimariaBroker) {}
+
   getUrlParams = (): URLSearchParams => {
     return new URLSearchParams(window.location.search);
   };
@@ -38,19 +42,24 @@ export class TokenManagerImpl implements TokenManager {
 
   refreshToken = async () => {
     if (!tokenInitialized) this.initToken();
-    const response = await axios.post("/api/token/refresh", { token: refreshToken });
-    const { access_token, refresh_token } = response.data;
-    if (!access_token) throw new Error("Invalid refresh token response");
-    token = access_token;
-    refreshToken = refresh_token;
-    return token;
+    try {
+      const response = await axios.post("/api/token/refresh", { token: refreshToken });
+      const { access_token, refresh_token } = response.data;
+      if (!access_token) throw new Error("Invalid refresh token response");
+      token = access_token;
+      refreshToken = refresh_token;
+      return token;
+    } catch (error) {
+      this.broker.publish(BROKER_EVENTS.shell.refreshTokenFailed, {});
+      throw error;
+    }
   };
 }
 
 let tokenManager: TokenManagerImpl;
 
-export const createTokenManager = () => {
+export const createTokenManager = (broker: PrimariaBroker) => {
   if (tokenManager) return tokenManager;
-  tokenManager = new TokenManagerImpl();
+  tokenManager = new TokenManagerImpl(broker);
   return tokenManager;
 };