@uxland/primary-shell 7.8.0 → 7.9.0

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

@@ -1,10 +1,12 @@
 export interface TokenManager {
+    setInitialTokens: (access_token: string, refresh_token: string) => void;
     getToken: () => string;
     refreshToken: () => Promise<string>;
 }
 export declare class TokenManagerImpl implements TokenManager {
     getUrlParams: () => URLSearchParams;
-    initToken: () => string;
+    private initToken;
+    setInitialTokens: (access_token: string, refresh_token: string) => void;
     getToken: () => string;
     refreshToken: () => Promise<string>;
 }

package/dist/primary/shell/src/handle-plugins.d.ts

@@ -1,6 +1,17 @@
-import { PluginDefinition, Plugin as PluginType } from '@uxland/harmonix';
+import { PluginDefinition, Plugin as PluginType, BootstrappedPlugin } from '@uxland/harmonix';
 import { PrimariaApi } from './api/api';
 export type { PluginDefinition, PluginInfo } from '@uxland/harmonix';
-export declare const bootstrapPlugins: (plugins: PluginDefinition[]) => Promise<void>;
+export interface PrimariaPlugin extends Plugin {
+    startup: (api: PrimariaApi, startupParams: any) => Promise<void>;
+}
+export interface PrimariaStartupPlugin {
+    pluginId: string;
+    params: any;
+}
+interface PrimariaBootstrappedPlugin extends BootstrappedPlugin<PrimariaApi> {
+    importedPlugin: PrimariaPlugin;
+}
+export declare const bootstrapPlugins: (plugins: PluginDefinition[], startup?: PrimariaStartupPlugin) => Promise<void>;
+export declare const handleStartupPlugin: (plugins: PrimariaBootstrappedPlugin[], startupPlugin?: PrimariaStartupPlugin) => void;
 export declare const disposePlugins: () => Promise<void[]>;
 export type Plugin = PluginType<PrimariaApi>;

package/package.json

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

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

@@ -1,17 +1,143 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { createTokenManager } from "./token-manager";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import axios from "axios";
 
-const access_token = 'eyJhbGciOiJSUzI1NiIsInR5cCIgOiAiSldUIiwia2lkIiA6ICJidFZxNnRMWGpmcXdzbm5MR2FXMXdhdU9McDNiTmY4bWZ3Rm1SZ0lBS2VJIn0.eyJleHAiOjE3Mzg2NjcxODIsImlhdCI6MTczODY2NjI4MiwianRpIjoiY2I0M2M2ZmItY2MyMS00M2Y2LTk5M2UtNDM3ZTJjNDU3YWMzIiwiaXNzIjoiaHR0cHM6Ly9wcmVwcm9kdWNjaW8ucGRzLmhlcy5jYXRzYWx1dC5nZW5jYXQuY2F0L2F1dGgvcmVhbG1zL0hFUyIsInN1YiI6Ijk1OGUyZWQ5LTJkNmUtNDZjOC1hOTE5LTU5MDQ0ZTYwMzVjMiIsInR5cCI6IkJlYXJlciIsImF6cCI6ImV0Yy1jY2YtcHJlIiwic2Vzc2lvbl9zdGF0ZSI6ImU3MzIzYWIyLTU3MDktNGY1ZS05ZGU4LWU1MzM3ZTBhOTMxNiIsInJlYWxtX2FjY2VzcyI6eyJyb2xlcyI6WyJkZWZhdWx0LXJvbGVzLWhlcyIsIlJPTEVfSEVTX0VUQyIsIlJPTEVfSEVTX0xBTkRJTkciXX0sInNjb3BlIjoiIiwic2lkIjoiZTczMjNhYjItNTcwOS00ZjVlLTlkZTgtZTUzMzdlMGE5MzE2IiwiY2xpZW50SG9zdCI6IjEwLjUzLjI1NC4xNTAiLCJhY2Nlc3NfcnVsZXMiOnt9LCJhY2Nlc3NfaW5mbyI6eyJtb2R1bGVfY29kZSI6IkEwMDEiLCJyb2xlX3R5cGUiOiJOT1JNIiwidHJhY2VfdXNlcl9pZCI6IlVzZXJfSUQiLCJjZW50ZXJfdHlwZSI6IkUiLCJ1cF9jb2RlIjoiMDc3MzMiLCJ0cmFjZV91c2VyX2dpdmVuX25hbWUiOiJHaXZlbiBOYW1lIiwidHJhY2VfdXNlcl9mYW1pbHlfbmFtZSI6IkZhbWlseSBOYW1lIiwidXNlcl90eXBlIjoiQURNIiwiY2VudGVyX2NvZGUiOiJFMDg1ODY5NjMiLCJwcm9mZXNzaW9uYWxfY2F0ZWdvcnkiOiIzMDkzNDMwMDYiLCJzZXJ2aWNlX2NvZGUiOiI1UzA4OSIsImVwX2NvZGUiOiIwMjA4IiwiaWRlbnRpZmllciI6W3sidHlwZSI6IkROSSIsInZhbHVlIjoiNzMyODgyMTlBIn0seyJ0eXBlIjoiTlVNQ09MIiwidmFsdWUiOiIyIn1dLCJhbHRfaWRlbnRpZmllciI6W3sidHlwZSI6Ik1QSSIsInZhbHVlIjoiMDYyMWNmN2QtN2Q2My00OWVjLTgwMDYtOGMwNTY5MmVkMzc3In1dfSwiY2xpZW50QWRkcmVzcyI6IjEwLjUzLjI1NC4xNTAiLCJjbGllbnRfaWQiOiJldGMtY2NmLXByZSJ9.WYF6VvIVqzW71MdOcvRJnKNBEe8BoD43Ql_hyGyqBC1wbNDNcbqucX-2wPbSOpHaHv5iogYNTVp1eEkHvrnryQ4koHXf4U3inTxoZR94qAzIt8XGgBVxpYlArc-XrFX1FAwkdfsNmYE_L6G7q5wfzaP0y1YrFH6u9TPTBl1w2us8O8xKPB6B652NUphNHFWmPWv6t6Zq97sjHPIHMZsDeBdolK5RlG5J3u8K-quJeKLByZhA2kYAJMGyCzR6jLLrup5w-WdYNJRyGopeFSDVp-lECmaiYIXmhQOJzzJQqhARrwYN8ZxqTOyD5u24HOB7Q1ZCMnAp4vAL6OphWyRZuw';
-const refresh_token = 'eyJhbGciOiJIUzUxMiIsInR5cCIgOiAiSldUIiwia2lkIiA6ICIwMjUzZGM1MC1hY2FmLTQ5ZDctYTYzNi0xN2NkMTlmOWEwOTAifQ.eyJleHAiOjE3Mzg2NjgwODIsImlhdCI6MTczODY2NjI4MiwianRpIjoiZWM5OGE2OWMtMDJkNS00Yjc0LWIwZWYtNzcwMGU4OTc3YWY1IiwiaXNzIjoiaHR0cHM6Ly9wcmVwcm9kdWNjaW8ucGRzLmhlcy5jYXRzYWx1dC5nZW5jYXQuY2F0L2F1dGgvcmVhbG1zL0hFUyIsImF1ZCI6Imh0dHBzOi8vcHJlcHJvZHVjY2lvLnBkcy5oZXMuY2F0c2FsdXQuZ2VuY2F0LmNhdC9hdXRoL3JlYWxtcy9IRVMiLCJzdWIiOiI5NThlMmVkOS0yZDZlLTQ2YzgtYTkxOS01OTA0NGU2MDM1YzIiLCJ0eXAiOiJSZWZyZXNoIiwiYXpwIjoiZXRjLWNjZi1wcmUiLCJzZXNzaW9uX3N0YXRlIjoiZTczMjNhYjItNTcwOS00ZjVlLTlkZTgtZTUzMzdlMGE5MzE2Iiwic2NvcGUiOiIiLCJzaWQiOiJlNzMyM2FiMi01NzA5LTRmNWUtOWRlOC1lNTMzN2UwYTkzMTYifQ.KOO0Ulbed4640-obEr3Xg8qavGeXhU25o6ZUfsq0SoQpzMjhcx8GTgOH-PiIR88ksrjtTnpbmzw2D29xuugv4A';
+vi.mock("axios");
 
-describe("Token Manager test", () => {
-  beforeEach(() => {
-    vi.spyOn(window, 'location', 'get').mockReturnValue({
+const access_token = 'test_access_token';
+const refresh_token = 'test_refresh_token';
+const new_access_token = 'new_access_token';
+const new_refresh_token = 'new_refresh_token';
+
+describe("TokenManager", () => {
+  let mockLocation: Partial<Location>;
+  let TokenManagerImpl: any;
+  let createTokenManager: any;
+
+  beforeEach(async () => {
+    // Reset module state by requiring a fresh instance
+    vi.resetModules();
+    mockLocation = {
       search: `?access_token=${access_token}&refresh_token=${refresh_token}`
-    } as unknown as Location);
+    };
+    vi.spyOn(window, 'location', 'get').mockReturnValue(mockLocation as Location);
+
+    // Import fresh module
+    const module = await import("./token-manager");
+    TokenManagerImpl = module.TokenManagerImpl;
+    createTokenManager = module.createTokenManager;
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe("getToken", () => {
+    it("should initialize token from URL params on first call", () => {
+      const tokenManager = new TokenManagerImpl();
+      const token = tokenManager.getToken();
+      expect(token).toBe(access_token);
+    });
+
+    it("should return empty string if URL params are missing", () => {
+      mockLocation.search = "";
+      const tokenManager = new TokenManagerImpl();
+      const token = tokenManager.getToken();
+      expect(token).toBe("");
+    });
+
+    it("should return the same token on subsequent calls", () => {
+      const tokenManager = new TokenManagerImpl();
+      const token1 = tokenManager.getToken();
+      const token2 = tokenManager.getToken();
+      expect(token1).toBe(token2);
+      expect(token1).toBe(access_token);
+    });
+  });
+
+  describe("setInitialTokens", () => {
+    it("should set tokens manually", () => {
+      const tokenManager = new TokenManagerImpl();
+      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();
+      tokenManager.setInitialTokens("manual_access", "manual_refresh");
+      expect(() => tokenManager.setInitialTokens("another_access", "another_refresh"))
+        .toThrow("Token already initialized");
+    });
+
+    it("should throw error if tokens were already initialized from URL", () => {
+      const tokenManager = new TokenManagerImpl();
+      tokenManager.getToken(); // Initialize from URL
+      expect(() => tokenManager.setInitialTokens("manual_access", "manual_refresh"))
+        .toThrow("Token already initialized");
+    });
+  });
+
+  describe("refreshToken", () => {
+    it("should refresh token successfully", async () => {
+      vi.mocked(axios.post).mockResolvedValue({
+        data: {
+          access_token: new_access_token,
+          refresh_token: new_refresh_token
+        }
+      });
+
+      const tokenManager = new TokenManagerImpl();
+      tokenManager.setInitialTokens(access_token, refresh_token);
+
+      const refreshedToken = await tokenManager.refreshToken();
+
+      expect(axios.post).toHaveBeenCalledWith('/api/token/refresh', { token: refresh_token });
+      expect(refreshedToken).toBe(new_access_token);
+      expect(tokenManager.getToken()).toBe(new_access_token);
+    });
+
+    it("should initialize tokens from URL before refreshing if not initialized", async () => {
+      vi.mocked(axios.post).mockResolvedValue({
+        data: {
+          access_token: new_access_token,
+          refresh_token: new_refresh_token
+        }
+      });
+
+      const tokenManager = new TokenManagerImpl();
+      await tokenManager.refreshToken();
+
+      expect(axios.post).toHaveBeenCalledWith('/api/token/refresh', { token: refresh_token });
+      expect(tokenManager.getToken()).toBe(new_access_token);
+    });
+
+    it("should throw error if refresh response doesn't contain access_token", async () => {
+      vi.mocked(axios.post).mockResolvedValue({
+        data: {}
+      });
+
+      const tokenManager = new TokenManagerImpl();
+      tokenManager.setInitialTokens(access_token, refresh_token);
+
+      await expect(tokenManager.refreshToken())
+        .rejects.toThrow("Invalid refresh token response");
+    });
+
+    it("should handle axios errors", async () => {
+      const error = new Error("Network error");
+      vi.mocked(axios.post).mockRejectedValue(error);
+
+      const tokenManager = new TokenManagerImpl();
+      tokenManager.setInitialTokens(access_token, refresh_token);
+
+      await expect(tokenManager.refreshToken()).rejects.toThrow("Network error");
+    });
   });
-  it("should return initial token", () => {
-    const tokenManager = createTokenManager();
-    expect(tokenManager.getToken()).toBe(access_token);
+
+  describe("createTokenManager", () => {
+    it("should return a singleton instance", () => {
+      const tokenManager1 = createTokenManager();
+      const tokenManager2 = createTokenManager();
+      expect(tokenManager1).toBe(tokenManager2);
+    });
   });
 });

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

@@ -1,43 +1,61 @@
 import axios from "axios";
 
 export interface TokenManager {
+  setInitialTokens: (access_token: string, refresh_token: string) => void;
   getToken: () => string;
   refreshToken: () => Promise<string>;
 }
 
 let token: string;
 let refreshToken: string;
+let tokenInitialized = false;
 export class TokenManagerImpl implements TokenManager {
   getUrlParams = (): URLSearchParams => {
     return new URLSearchParams(window.location.search);
   };
 
-  initToken = () => {
+  private initToken = () => {
+    if (tokenInitialized)
+      throw new Error("Token already initialized");
+    tokenInitialized = true;
     const searchString = this.getUrlParams();
     token = searchString.get("access_token") || "";
     refreshToken = searchString.get("refresh_token") || "";
     return token;
   };
 
+  setInitialTokens = (access_token: string, refresh_token: string) => {
+    if (tokenInitialized)
+      throw new Error("Token already initialized");
+    token = access_token;
+    refreshToken = refresh_token;
+    tokenInitialized = true;
+  };
+
   getToken = () => {
+    if (!tokenInitialized)
+      this.initToken();
     return token;
   };
 
   refreshToken = async () => {
-      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;
+    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;
   };
 }
 let tokenManager;
 export const createTokenManager = () =>  {
   if(tokenManager) return tokenManager;
   tokenManager = new TokenManagerImpl();
-  tokenManager.initToken();
+  //tokenManager.initToken();
   return tokenManager;
 }

package/src/handle-plugins.ts

@@ -15,7 +15,20 @@ import {
 } from "../../../plugins/admin-clinical-monitoring/src/plugin";
 import { PrimariaApi, primariaApiFactory, shellApi } from "./api/api";
 
-let bootstrappedPlugins = [] as BootstrappedPlugin[];
+let bootstrappedPlugins = [] as BootstrappedPlugin<PrimariaApi>[];
+
+export interface PrimariaPlugin extends Plugin{
+  startup: (api: PrimariaApi, startupParams: any) => Promise<void>;
+}
+
+export interface PrimariaStartupPlugin{
+  pluginId: string;
+  params: any;
+}
+
+interface PrimariaBootstrappedPlugin extends BootstrappedPlugin<PrimariaApi>{
+  importedPlugin: PrimariaPlugin;
+}
 
 const commonPlugins: PluginDefinition[] = [
   {
@@ -57,15 +70,24 @@ const getPluginsByUserRole = (isUserRoleAdministrative: boolean) => {
   return commonPlugins.concat(doctorInternalPlugins);
 };
 
-export const bootstrapPlugins = async (plugins: PluginDefinition[]) => {
+export const bootstrapPlugins = async (plugins: PluginDefinition[], startup?: PrimariaStartupPlugin) => {
   const isUserRoleAdministrative = shellApi.userManager.isUserRoleAdministrative();
   const internalPlugins = getPluginsByUserRole(isUserRoleAdministrative);
   const finalPlugins = internalPlugins.concat(plugins || []);
-  bootstrappedPlugins = await pluginBootstrapper(finalPlugins, primariaApiFactory);
+  bootstrappedPlugins = await pluginBootstrapper(finalPlugins, primariaApiFactory) as BootstrappedPlugin<PrimariaApi>[] ;
+  handleStartupPlugin(bootstrappedPlugins as PrimariaBootstrappedPlugin[], startup);
+};
+
+export const handleStartupPlugin = (plugins: PrimariaBootstrappedPlugin[], startupPlugin?: PrimariaStartupPlugin) => {
+  if (plugins && plugins.length > 0 && startupPlugin?.pluginId) {
+    const plugin = plugins.find((plugin: PrimariaBootstrappedPlugin) => plugin?.apiInstance.pluginInfo.pluginId === startupPlugin.pluginId);
+    if(plugin?.importedPlugin?.startup)
+      plugin?.importedPlugin?.startup?.(plugin.apiInstance, startupPlugin.params);
+  }
 };
 
 export const disposePlugins = async () => {
-  return Promise.all(bootstrappedPlugins.map((plugin: BootstrappedPlugin) => plugin?.dispose()));
+  return Promise.all(bootstrappedPlugins.map((plugin: PrimariaBootstrappedPlugin) => plugin?.dispose()));
 };
 
 export type Plugin = PluginType<PrimariaApi>;