@uxland/primary-shell 4.3.1 → 5.0.0

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

@@ -1,17 +1,19 @@
 import axios, { AxiosInstance } from "axios";
 import AxiosMockAdapter from "axios-mock-adapter";
-import { Mock, beforeEach, describe, expect, it, vi } from "vitest";
+import { beforeEach, describe, expect, it, vi } from "vitest";
 import { TokenManager, createTokenManager } from "../token-manager/token-manager";
 import { createAxiosInstance } from "./http-client";
 import { shellEvents } from "../../events";
 import { createBroker } from "../broker/factory";
 
-const access_token = 'eyJhbGciOiJSUzI1NiIsInR5cCIgOiAiSldUIiwia2lkIiA6ICJidFZxNnRMWGpmcXdzbm5MR2FXMXdhdU9McDNiTmY4bWZ3Rm1SZ0lBS2VJIn0.eyJleHAiOjE3Mzg2NjcxODIsImlhdCI6MTczODY2NjI4MiwianRpIjoiY2I0M2M2ZmItY2MyMS00M2Y2LTk5M2UtNDM3ZTJjNDU3YWMzIiwiaXNzIjoiaHR0cHM6Ly9wcmVwcm9kdWNjaW8ucGRzLmhlcy5jYXRzYWx1dC5nZW5jYXQuY2F0L2F1dGgvcmVhbG1zL0hFUyIsInN1YiI6Ijk1OGUyZWQ5LTJkNmUtNDZjOC1hOTE5LTU5MDQ0ZTYwMzVjMiIsInR5cCI6IkJlYXJlciIsImF6cCI6ImV0Yy1jY2YtcHJlIiwic2Vzc2lvbl9zdGF0ZSI6ImU3MzIzYWIyLTU3MDktNGY1ZS05ZGU4LWU1MzM3ZTBhOTMxNiIsInJlYWxtX2FjY2VzcyI6eyJyb2xlcyI6WyJkZWZhdWx0LXJvbGVzLWhlcyIsIlJPTEVfSEVTX0VUQyIsIlJPTEVfSEVTX0xBTkRJTkciXX0sInNjb3BlIjoiIiwic2lkIjoiZTczMjNhYjItNTcwOS00ZjVlLTlkZTgtZTUzMzdlMGE5MzE2IiwiY2xpZW50SG9zdCI6IjEwLjUzLjI1NC4xNTAiLCJhY2Nlc3NfcnVsZXMiOnt9LCJhY2Nlc3NfaW5mbyI6eyJtb2R1bGVfY29kZSI6IkEwMDEiLCJyb2xlX3R5cGUiOiJOT1JNIiwidHJhY2VfdXNlcl9pZCI6IlVzZXJfSUQiLCJjZW50ZXJfdHlwZSI6IkUiLCJ1cF9jb2RlIjoiMDc3MzMiLCJ0cmFjZV91c2VyX2dpdmVuX25hbWUiOiJHaXZlbiBOYW1lIiwidHJhY2VfdXNlcl9mYW1pbHlfbmFtZSI6IkZhbWlseSBOYW1lIiwidXNlcl90eXBlIjoiQURNIiwiY2VudGVyX2NvZGUiOiJFMDg1ODY5NjMiLCJwcm9mZXNzaW9uYWxfY2F0ZWdvcnkiOiIzMDkzNDMwMDYiLCJzZXJ2aWNlX2NvZGUiOiI1UzA4OSIsImVwX2NvZGUiOiIwMjA4IiwiaWRlbnRpZmllciI6W3sidHlwZSI6IkROSSIsInZhbHVlIjoiNzMyODgyMTlBIn0seyJ0eXBlIjoiTlVNQ09MIiwidmFsdWUiOiIyIn1dLCJhbHRfaWRlbnRpZmllciI6W3sidHlwZSI6Ik1QSSIsInZhbHVlIjoiMDYyMWNmN2QtN2Q2My00OWVjLTgwMDYtOGMwNTY5MmVkMzc3In1dfSwiY2xpZW50QWRkcmVzcyI6IjEwLjUzLjI1NC4xNTAiLCJjbGllbnRfaWQiOiJldGMtY2NmLXByZSJ9.WYF6VvIVqzW71MdOcvRJnKNBEe8BoD43Ql_hyGyqBC1wbNDNcbqucX-2wPbSOpHaHv5iogYNTVp1eEkHvrnryQ4koHXf4U3inTxoZR94qAzIt8XGgBVxpYlArc-XrFX1FAwkdfsNmYE_L6G7q5wfzaP0y1YrFH6u9TPTBl1w2us8O8xKPB6B652NUphNHFWmPWv6t6Zq97sjHPIHMZsDeBdolK5RlG5J3u8K-quJeKLByZhA2kYAJMGyCzR6jLLrup5w-WdYNJRyGopeFSDVp-lECmaiYIXmhQOJzzJQqhARrwYN8ZxqTOyD5u24HOB7Q1ZCMnAp4vAL6OphWyRZuw';
-const refresh_token = 'eyJhbGciOiJIUzUxMiIsInR5cCIgOiAiSldUIiwia2lkIiA6ICIwMjUzZGM1MC1hY2FmLTQ5ZDctYTYzNi0xN2NkMTlmOWEwOTAifQ.eyJleHAiOjE3Mzg2NjgwODIsImlhdCI6MTczODY2NjI4MiwianRpIjoiZWM5OGE2OWMtMDJkNS00Yjc0LWIwZWYtNzcwMGU4OTc3YWY1IiwiaXNzIjoiaHR0cHM6Ly9wcmVwcm9kdWNjaW8ucGRzLmhlcy5jYXRzYWx1dC5nZW5jYXQuY2F0L2F1dGgvcmVhbG1zL0hFUyIsImF1ZCI6Imh0dHBzOi8vcHJlcHJvZHVjY2lvLnBkcy5oZXMuY2F0c2FsdXQuZ2VuY2F0LmNhdC9hdXRoL3JlYWxtcy9IRVMiLCJzdWIiOiI5NThlMmVkOS0yZDZlLTQ2YzgtYTkxOS01OTA0NGU2MDM1YzIiLCJ0eXAiOiJSZWZyZXNoIiwiYXpwIjoiZXRjLWNjZi1wcmUiLCJzZXNzaW9uX3N0YXRlIjoiZTczMjNhYjItNTcwOS00ZjVlLTlkZTgtZTUzMzdlMGE5MzE2Iiwic2NvcGUiOiIiLCJzaWQiOiJlNzMyM2FiMi01NzA5LTRmNWUtOWRlOC1lNTMzN2UwYTkzMTYifQ.KOO0Ulbed4640-obEr3Xg8qavGeXhU25o6ZUfsq0SoQpzMjhcx8GTgOH-PiIR88ksrjtTnpbmzw2D29xuugv4A';
-
+const access_token =
+  "eyJhbGciOiJSUzI1NiIsInR5cCIgOiAiSldUIiwia2lkIiA6ICJidFZxNnRMWGpmcXdzbm5MR2FXMXdhdU9McDNiTmY4bWZ3Rm1SZ0lBS2VJIn0.eyJleHAiOjE3NDI5MDkxNjMsImlhdCI6MTc0MjkwODI2MywianRpIjoiODRlMWEwYjYtOGNmYS00NzQ3LTk0MDItMjVkM2FlMzM3N2QxIiwiaXNzIjoiaHR0cHM6Ly9wcmVwcm9kdWNjaW8ucGRzLmhlcy5jYXRzYWx1dC5nZW5jYXQuY2F0L2F1dGgvcmVhbG1zL0hFUyIsInN1YiI6Ijk1OGUyZWQ5LTJkNmUtNDZjOC1hOTE5LTU5MDQ0ZTYwMzVjMiIsInR5cCI6IkJlYXJlciIsImF6cCI6ImV0Yy1jY2YtcHJlIiwic2Vzc2lvbl9zdGF0ZSI6ImVhNzUwMDg4LWI1NjctNDU4ZC1iOWY5LWQ0OTdjMzlkN2ZkMyIsInJlYWxtX2FjY2VzcyI6eyJyb2xlcyI6WyJkZWZhdWx0LXJvbGVzLWhlcyIsIlJPTEVfSEVTX0VUQyIsIlJPTEVfSEVTX0xBTkRJTkciXX0sInNjb3BlIjoiIiwic2lkIjoiZWE3NTAwODgtYjU2Ny00NThkLWI5ZjktZDQ5N2MzOWQ3ZmQzIiwiY2xpZW50SG9zdCI6IjEwLjUzLjI1NC4xNTAiLCJhY2Nlc3NfcnVsZXMiOnt9LCJhY2Nlc3NfaW5mbyI6eyJtb2R1bGVfY29kZSI6IkEwMDEiLCJyb2xlX3R5cGUiOiJOT1JNIiwidHJhY2VfdXNlcl9pZCI6IlVzZXJfSUQiLCJjZW50ZXJfdHlwZSI6IkUiLCJtcGlfcGF0aWVudF9pZCI6IjVlYzc0YzdiLTVhYTUtNGE4NC1iM2I0LWYwMmVkZGZkZjZkYyIsInVwX2NvZGUiOiIwNzczMyIsInRyYWNlX3VzZXJfZ2l2ZW5fbmFtZSI6IkdpdmVuIE5hbWUiLCJ0cmFjZV91c2VyX2ZhbWlseV9uYW1lIjoiRmFtaWx5IE5hbWUiLCJ1c2VyX3R5cGUiOiJBRE0iLCJjZW50ZXJfY29kZSI6IkUwODU4Njk2MyIsInByb2Zlc3Npb25hbF9jYXRlZ29yeSI6IjMwOTM0MzAwNiIsInNlcnZpY2VfY29kZSI6IjVTMDg5IiwiZXBfY29kZSI6IjAyMDgiLCJpZGVudGlmaWVyIjpbeyJ0eXBlIjoiRE5JIiwidmFsdWUiOiI3MzI4ODIxOUEifSx7InR5cGUiOiJOVU1DT0wiLCJ2YWx1ZSI6IjIifV0sImFsdF9pZGVudGlmaWVyIjpbeyJ0eXBlIjoiTVBJIiwidmFsdWUiOiIwNjIxY2Y3ZC03ZDYzLTQ5ZWMtODAwNi04YzA1NjkyZWQzNzcifV19LCJjbGllbnRBZGRyZXNzIjoiMTAuNTMuMjU0LjE1MCIsImNsaWVudF9pZCI6ImV0Yy1jY2YtcHJlIn0.CgYL3zXbUHHiE7ZtrcxvlDHB3dbY_eI8TsL-0mBOy-JedSZZaGT_JS8Odm_eIo1drWZSnEaNblFZUPE56sCEPH6RYSqtyK0eYwy_aKoprKoRuDjEy2-VfmOJi5gY9wpYnAYpVtuTbncVirQIV9SIZ9st2d7LlfcM_88Yn8NJNTDcUk7ETw7Zy_728X2wjL_UeHT7yuzo3Y-Xm_389Og7UMyYGGrs104CHQNrzIMXiklkRZr4dqjqWU61Csrb8OBI6jCUAbBqgS8vPuUzPUghQXstr-aNn3zicy-Zw5e6RqCmSQXg56aTKx9QIOrQuX-az-urPnqvtWdloQrQJLQGSg";
+const refresh_token =
+  "eyJhbGciOiJIUzUxMiIsInR5cCIgOiAiSldUIiwia2lkIiA6ICIwMjUzZGM1MC1hY2FmLTQ5ZDctYTYzNi0xN2NkMTlmOWEwOTAifQ.eyJleHAiOjE3NDI5MTE4NjMsImlhdCI6MTc0MjkwODI2MywianRpIjoiZjA4MzA1MDktMTA0My00ODI1LTk5YTItOTg1YmNjOGI4MmJmIiwiaXNzIjoiaHR0cHM6Ly9wcmVwcm9kdWNjaW8ucGRzLmhlcy5jYXRzYWx1dC5nZW5jYXQuY2F0L2F1dGgvcmVhbG1zL0hFUyIsImF1ZCI6Imh0dHBzOi8vcHJlcHJvZHVjY2lvLnBkcy5oZXMuY2F0c2FsdXQuZ2VuY2F0LmNhdC9hdXRoL3JlYWxtcy9IRVMiLCJzdWIiOiI5NThlMmVkOS0yZDZlLTQ2YzgtYTkxOS01OTA0NGU2MDM1YzIiLCJ0eXAiOiJSZWZyZXNoIiwiYXpwIjoiZXRjLWNjZi1wcmUiLCJzZXNzaW9uX3N0YXRlIjoiZWE3NTAwODgtYjU2Ny00NThkLWI5ZjktZDQ5N2MzOWQ3ZmQzIiwic2NvcGUiOiIiLCJzaWQiOiJlYTc1MDA4OC1iNTY3LTQ1OGQtYjlmOS1kNDk3YzM5ZDdmZDMifQ.I8u83nfdxbjRrS7dC1k8_f9oBKmSD_Xu4iAxlFqcA3QdHi-L_yY63ENU1LTehh8-2d51f__nv58zPb799hNGhg";
+const newAccessToken =
+  "eyJhbGciOiJSUzI1NiIsInR5cCIgOiAiSldUIiwia2lkIiA6ICJidFZxNnRMWGpmcXdzbm5MR2FXMXdhdU9McDNiTmY4bWZ3Rm1SZ0lBS2VJIn0.eyJleHAiOjE3NDI5MTAzNzgsImlhdCI6MTc0MjkwOTQ3OCwianRpIjoiMTg4OTE3ZDYtNmM0OS00YWY0LTlhYjItZjEzYTM4MGY5OTgyIiwiaXNzIjoiaHR0cHM6Ly9wcmVwcm9kdWNjaW8ucGRzLmhlcy5jYXRzYWx1dC5nZW5jYXQuY2F0L2F1dGgvcmVhbG1zL0hFUyIsInN1YiI6Ijk1OGUyZWQ5LTJkNmUtNDZjOC1hOTE5LTU5MDQ0ZTYwMzVjMiIsInR5cCI6IkJlYXJlciIsImF6cCI6ImV0Yy1jY2YtcHJlIiwic2Vzc2lvbl9zdGF0ZSI6IjY5ODdhMzExLWM1NzQtNDc1Ni1hMzY0LWY1ZjQzZmViZjNhYiIsInJlYWxtX2FjY2VzcyI6eyJyb2xlcyI6WyJkZWZhdWx0LXJvbGVzLWhlcyIsIlJPTEVfSEVTX0VUQyIsIlJPTEVfSEVTX0xBTkRJTkciXX0sInNjb3BlIjoiIiwic2lkIjoiNjk4N2EzMTEtYzU3NC00NzU2LWEzNjQtZjVmNDNmZWJmM2FiIiwiY2xpZW50SG9zdCI6IjEwLjUzLjI1NC4xNTAiLCJhY2Nlc3NfcnVsZXMiOnt9LCJhY2Nlc3NfaW5mbyI6eyJtb2R1bGVfY29kZSI6IkEwMDEiLCJyb2xlX3R5cGUiOiJOT1JNIiwidHJhY2VfdXNlcl9pZCI6IlVzZXJfSUQiLCJjZW50ZXJfdHlwZSI6IkUiLCJtcGlfcGF0aWVudF9pZCI6IjVlYzc0YzdiLTVhYTUtNGE4NC1iM2I0LWYwMmVkZGZkZjZkYyIsInVwX2NvZGUiOiIwNzczMyIsInRyYWNlX3VzZXJfZ2l2ZW5fbmFtZSI6IkdpdmVuIE5hbWUiLCJ0cmFjZV91c2VyX2ZhbWlseV9uYW1lIjoiRmFtaWx5IE5hbWUiLCJ1c2VyX3R5cGUiOiJBRE0iLCJjZW50ZXJfY29kZSI6IkUwODU4Njk2MyIsInByb2Zlc3Npb25hbF9jYXRlZ29yeSI6IjMwOTM0MzAwNiIsInNlcnZpY2VfY29kZSI6IjVTMDg5IiwiZXBfY29kZSI6IjAyMDgiLCJpZGVudGlmaWVyIjpbeyJ0eXBlIjoiRE5JIiwidmFsdWUiOiI3MzI4ODIxOUEifSx7InR5cGUiOiJOVU1DT0wiLCJ2YWx1ZSI6IjIifV0sImFsdF9pZGVudGlmaWVyIjpbeyJ0eXBlIjoiTVBJIiwidmFsdWUiOiIwNjIxY2Y3ZC03ZDYzLTQ5ZWMtODAwNi04YzA1NjkyZWQzNzcifV19LCJjbGllbnRBZGRyZXNzIjoiMTAuNTMuMjU0LjE1MCIsImNsaWVudF9pZCI6ImV0Yy1jY2YtcHJlIn0.zPxoN5d8_uxdbxeH7ly9sQdlnDxNp8_eWDzNSzjzkUPsRVkLxgjQw_WcjZfns-LNgGr0FToS6uSDIC7uj2hPpKqD7HPWbI6UPa7g-43Jf9rh-KSOXEHJWhlASi2w0n3xQHFSxHDYBwhyXlvWQ_Tr1Vh37MroWmEL84fdwqhcfZHmD9Ek52EuRRrB-XkymCmN1ZvO2GPU04LbBvQxLVzdAaKRzr1cUqHTnsEdgRduyKShPcyth01L_X7m128SIwjJsa1lYxFE_DbSDKz8dPTsxoS1DgwRxeArrkMlIdTHyxmDRezZUGhamyLuWpXLDXJCFfrTUB8-j_JnVlILHeR6O";
 
 describe("HTTP Client", () => {
-
   let broker = createBroker();
   let tokenManager: TokenManager;
   let axiosInstance: AxiosInstance;
@@ -19,91 +21,201 @@ describe("HTTP Client", () => {
 
   beforeEach(() => {
     vi.restoreAllMocks(); // Reset all spies before each test
-    vi.spyOn(window, 'location', 'get').mockReturnValue({
-      search: `?access_token=${access_token}&refresh_token=${refresh_token}`
+    vi.spyOn(window, "location", "get").mockReturnValue({
+      search: `?access_token=${access_token}&refresh_token=${refresh_token}`,
     } as unknown as Location);
-
-    tokenManager = createTokenManager();
-    axiosInstance = createAxiosInstance(tokenManager, broker);
-    axiosMockInstance = new AxiosMockAdapter(axiosInstance);
-    axiosMockInstance.reset();
   });
 
-  it("should make a request with header", async () => {
-    axiosMockInstance.onGet("/api/clinical-course").reply(200, "success");
-    // Perform the request
-    const response = await axiosInstance.get("/api/clinical-course");
-    // Assertions
-    expect(response.status).toBe(200);
-    expect(response.data).toBe("success");
-    expect(axiosMockInstance.history.get?.length).toBe(1);
-    // @ts-ignore
-    expect(axiosMockInstance.history.get?.[0]?.headers.Authorization).toBe(
-      `Bearer ${access_token}`,
-    );
-  });
+  describe("Without validateMpid", () => {
+    beforeEach(() => {
+      tokenManager = createTokenManager();
+      axiosInstance = createAxiosInstance(tokenManager, broker);
+      axiosMockInstance = new AxiosMockAdapter(axiosInstance);
+      axiosMockInstance.reset();
+    });
 
-  it("should retry request with  new token if failed with 401 after token refresh, and requests after that have new token", async () => {
-    
-    axiosMockInstance
-      .onGet("/api/clinical-course")
-      .replyOnce(401, "Unauthorized")
-      .onGet("/api/clinical-course")
-      .replyOnce(200, "success")
-      .onGet("/api/clinical-course/2")
-      .replyOnce(200, "success");
-
-    vi.spyOn(axios, "post").mockResolvedValueOnce({
-      data: {
-        access_token: "new-auth-token",
-        refresh_token: "new-refresh-token"
-      }
+    it("should make a request with header", async () => {
+      axiosMockInstance.onGet("/api/clinical-course").reply(200, "success");
+      // Perform the request
+      const response = await axiosInstance.get("/api/clinical-course");
+      // Assertions
+      expect(response.status).toBe(200);
+      expect(response.data).toBe("success");
+      expect(axiosMockInstance.history.get?.length).toBe(1);
+      // @ts-ignore
+      expect(axiosMockInstance.history.get?.[0]?.headers.Authorization).toBe(
+        `Bearer ${access_token}`,
+      );
     });
 
-    // Perform the request
-    const response = await axiosInstance.get("/api/clinical-course");
-    const secondResponse = await axiosInstance.get("/api/clinical-course/2");
-
-    console.log("response", response.status);
-    // Assertions
-    expect(response.status).toBe(200);
-    expect(response.data).toBe("success");
-    expect(axiosMockInstance.history.get?.length).toBe(3); // 3 Calls 2 for the first request (request and retry), 1 for the second request
-    expect(axiosMockInstance.history.get?.[1]?.headers?.Authorization).toBe(
-      "Bearer new-auth-token",
-    );
-    expect(axiosMockInstance.history.get?.[2]?.headers?.Authorization).toBe(
-      "Bearer new-auth-token",
-    );
+    it("should retry request with  new token if failed with 401 after token refresh, and requests after that have new token", async () => {
+      axiosMockInstance
+        .onGet("/api/clinical-course")
+        .replyOnce(401, "Unauthorized")
+        .onGet("/api/clinical-course")
+        .replyOnce(200, "success")
+        .onGet("/api/clinical-course/2")
+        .replyOnce(200, "success");
+
+      vi.spyOn(axios, "post").mockResolvedValueOnce({
+        data: {
+          access_token: newAccessToken,
+          refresh_token: "new-refresh-token",
+        },
+      });
+
+      // Perform the request
+      const response = await axiosInstance.get("/api/clinical-course");
+      const secondResponse = await axiosInstance.get("/api/clinical-course/2");
+      // Assertions
+      expect(response.status).toBe(200);
+      expect(response.data).toBe("success");
+      expect(axiosMockInstance.history.get?.length).toBe(3); // 3 Calls 2 for the first request (request and retry), 1 for the second request
+      expect(axiosMockInstance.history.get?.[1]?.headers?.Authorization).toBe(
+        "Bearer " + newAccessToken,
+      );
+      expect(axiosMockInstance.history.get?.[2]?.headers?.Authorization).toBe(
+        "Bearer " + newAccessToken,
+      );
+    });
+
+    it("should fail request if token refresh fails and publish an event", async () => {
+      vi.spyOn(axios, "post").mockRejectedValueOnce({
+        response: { status: 400, statusText: "Bad Request" },
+      });
+      const brokerSpy = vi.spyOn(broker, "publish");
+      axiosMockInstance.onGet("/api/clinical-course").replyOnce(401, "Unauthorized");
+
+      await expect(axiosInstance.get("/api/clinical-course")).rejects.toThrow(
+        "Request failed with status code 401",
+      );
+
+      expect(axiosMockInstance.history.get?.length).toBe(1); // No retry happened
+      expect(brokerSpy).toHaveBeenCalledWith(shellEvents.refreshTokenFailed, expect.any(Object));
+      expect(brokerSpy).toHaveBeenCalledWith(shellEvents.refreshTokenFailed, {
+        request: expect.objectContaining({ url: "/api/clinical-course" }),
+      });
+    });
 
+    it("should fail request with error != 401 and should not retry", async () => {
+      const refreshTokenSpy = vi.spyOn(tokenManager, "refreshToken");
+      const brokerSpy = vi.spyOn(broker, "publish");
+      axiosMockInstance.onGet("/api/clinical-course").replyOnce(500, "Internal Server Error");
+      await expect(axiosInstance.get("/api/clinical-course")).rejects.toMatchObject({
+        response: { status: 500 },
+      });
+      expect(axiosMockInstance.history.get?.length).toBe(1);
+      expect(refreshTokenSpy).not.toHaveBeenCalled();
+      expect(brokerSpy).not.toHaveBeenCalled();
+    });
   });
 
-  it("should fail request if token refresh fails and publish an event", async () => {
-    vi.spyOn(axios, "post").mockRejectedValueOnce({
-      response: { status: 400, statusText: "Bad Request" },
+  describe.skip("With validateMpid", () => {
+    const validTokenHeaders = { "x-catsalut-mpid": "5ec74c7b-5aa5-4a84-b3b4-f02eddfdf6dc" };
+    beforeEach(() => {
+      tokenManager = createTokenManager();
+      axiosInstance = createAxiosInstance(tokenManager, broker, true);
+      axiosMockInstance = new AxiosMockAdapter(axiosInstance);
+      axiosMockInstance.reset();
     });
-    const brokerSpy = vi.spyOn(broker, "publish") 
-    axiosMockInstance.onGet("/api/clinical-course").replyOnce(401, "Unauthorized");
 
-    await expect(axiosInstance.get("/api/clinical-course")).rejects.toThrow("Request failed with status code 401");
+    it("should throw error if mpid header is missing without sending broker event", async () => {
+      axiosMockInstance.onGet("/api/clinical-course").reply(200, "success");
+      const brokerSpy = vi.spyOn(broker, "publish");
 
-    expect(axiosMockInstance.history.get?.length).toBe(1); // No retry happened
-    expect(brokerSpy).toHaveBeenCalledWith(shellEvents.refreshTokenFailed, expect.any(Object));
-    expect(brokerSpy).toHaveBeenCalledWith(shellEvents.refreshTokenFailed, {
-      request: expect.objectContaining({ url: "/api/clinical-course" }),
+      // Perform the request
+      await expect(axiosInstance.get("/api/clinical-course")).rejects.toThrow(
+        "Mpid header is missing",
+      );
+      expect(brokerSpy).not.toHaveBeenCalled();
+    });
+
+    it("should throw error if mpid header value is invalid and send broker event ", async () => {
+      axiosMockInstance.onGet("/api/clinical-course").reply(200, "success", {
+        "x-catsalut-mpid": "invalid-mpid",
+      });
+      const brokerSpy = vi.spyOn(broker, "publish");
+      // Perform the request
+      await expect(axiosInstance.get("/api/clinical-course")).rejects.toThrow(
+        "Mpid header value is invalid",
+      );
+      expect(brokerSpy).toHaveBeenCalledWith(shellEvents.mpidHeaderInvalid, expect.any(Object));
+    });
+
+    it("should make a request with header and respond succesful if x-catsalut-mpid has valid value ", async () => {
+      axiosMockInstance.onGet("/api/clinical-course").reply(200, "success", validTokenHeaders);
+      // Perform the request
+      const response = await axiosInstance.get("/api/clinical-course");
+      // Assertions
+      expect(response.status).toBe(200);
+      expect(response.data).toBe("success");
+      expect(axiosMockInstance.history.get?.length).toBe(1);
+      // @ts-ignore
+      expect(axiosMockInstance.history.get?.[0]?.headers.Authorization).toBe(
+        `Bearer ${access_token}`,
+      );
+    });
+
+    it("should retry request with  new token if failed with 401 after token refresh, and requests after that have new token", async () => {
+      axiosMockInstance
+        .onGet("/api/clinical-course")
+        .replyOnce(401, "Unauthorized")
+        .onGet("/api/clinical-course")
+        .replyOnce(200, "success", validTokenHeaders)
+        .onGet("/api/clinical-course/2")
+        .replyOnce(200, "success", validTokenHeaders);
+
+      vi.spyOn(axios, "post").mockResolvedValueOnce({
+        data: {
+          access_token: newAccessToken,
+          refresh_token: "new-refresh-token",
+        },
+      });
+
+      // Perform the request
+      const response = await axiosInstance.get("/api/clinical-course");
+      const secondResponse = await axiosInstance.get("/api/clinical-course/2");
+
+      // Assertions
+      expect(response.status).toBe(200);
+      expect(response.data).toBe("success");
+      expect(axiosMockInstance.history.get?.length).toBe(3); // 3 Calls 2 for the first request (request and retry), 1 for the second request
+      expect(axiosMockInstance.history.get?.[1]?.headers?.Authorization).toBe(
+        "Bearer " + newAccessToken,
+      );
+      expect(axiosMockInstance.history.get?.[2]?.headers?.Authorization).toBe(
+        "Bearer " + newAccessToken,
+      );
+    });
+
+    it("should fail request if token refresh fails and publish an event", async () => {
+      vi.spyOn(axios, "post").mockRejectedValueOnce({
+        response: { status: 400, statusText: "Bad Request" },
+      });
+      const brokerSpy = vi.spyOn(broker, "publish");
+      axiosMockInstance.onGet("/api/clinical-course").replyOnce(401, "Unauthorized");
+
+      await expect(axiosInstance.get("/api/clinical-course")).rejects.toThrow(
+        "Request failed with status code 401",
+      );
+
+      expect(axiosMockInstance.history.get?.length).toBe(1); // No retry happened
+      expect(brokerSpy).toHaveBeenCalledWith(shellEvents.refreshTokenFailed, expect.any(Object));
+      expect(brokerSpy).toHaveBeenCalledWith(shellEvents.refreshTokenFailed, {
+        request: expect.objectContaining({ url: "/api/clinical-course" }),
+      });
     });
-  });
 
-  it("should fail request with error != 401 and should not retry", async () => {
-    const refreshTokenSpy = vi.spyOn(tokenManager, "refreshToken");
-    const brokerSpy = vi.spyOn(broker, "publish");
-    axiosMockInstance.onGet("/api/clinical-course").replyOnce(500, "Internal Server Error");
-    await expect(axiosInstance.get("/api/clinical-course")).rejects.toMatchObject({
-      response: { status: 500 },
+    it("should fail request with error != 401 and should not retry", async () => {
+      const refreshTokenSpy = vi.spyOn(tokenManager, "refreshToken");
+      const brokerSpy = vi.spyOn(broker, "publish");
+      axiosMockInstance.onGet("/api/clinical-course").replyOnce(500, "Internal Server Error");
+      await expect(axiosInstance.get("/api/clinical-course")).rejects.toMatchObject({
+        response: { status: 500 },
+      });
+      expect(axiosMockInstance.history.get?.length).toBe(1);
+      expect(refreshTokenSpy).not.toHaveBeenCalled();
+      expect(brokerSpy).not.toHaveBeenCalled();
     });
-    expect(axiosMockInstance.history.get?.length).toBe(1);
-    expect(refreshTokenSpy).not.toHaveBeenCalled();
-    expect(brokerSpy).not.toHaveBeenCalled();
   });
-  
 });

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

@@ -2,28 +2,76 @@ import axios, { AxiosRequestConfig, AxiosResponse } from "axios";
 import { TokenManager } from "../token-manager/token-manager";
 import { shellEvents } from "../../events";
 import { PrimariaBroker } from "../broker/primaria-broker";
+import { jwtDecode } from "jwt-decode";
 
-export const createAxiosInstance = (tokenManager: TokenManager, broker: PrimariaBroker) => {
+const mpidHeader = "x-catsalut-mpid";
+const obtainMpid = (token: string) => {
+  const mpid = (jwtDecode(token) as any).access_info?.mpi_patient_id;
+  return mpid;
+};
+
+export class MissingMpidHeaderError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "MissingMpidHeaderError";
+  }
+}
+
+export class InvalidMpidHeaderError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = "InvalidMpidHeaderError";
+  }
+}
+const validateMpidHeader = (response: AxiosResponse, tokenManager: TokenManager): boolean => {
+  const mpidHeaderValue = response.headers[mpidHeader];
+  if (!mpidHeaderValue) {
+    throw new MissingMpidHeaderError("Mpid header is missing");
+  }
+  if (mpidHeaderValue !== obtainMpid(tokenManager.getToken())) {
+    throw new InvalidMpidHeaderError("Mpid header value is invalid");
+  }
+  return true;
+};
+
+export const createAxiosInstance = (
+  tokenManager: TokenManager,
+  broker: PrimariaBroker,
+  validateMpid: boolean = false,
+) => {
   const instance = axios.create();
   instance.interceptors.request.use((config) => {
     config.headers.Authorization = `Bearer ${tokenManager.getToken()}`;
     return config;
   });
-  
+
   instance.interceptors.response.use(
-    (response: AxiosResponse) => response,
+    (response: AxiosResponse) => {
+      try {
+        if (validateMpid) validateMpidHeader(response, tokenManager);
+        return response;
+      } catch (error) {
+        if (error instanceof InvalidMpidHeaderError) {
+          broker.publish(shellEvents.mpidHeaderInvalid, {
+            request: response.config,
+          });
+        }
+        return Promise.reject(error);
+      }
+    },
     async (error) => {
       const originalRequest = error.config;
-      if (error.response.status === 401 && !originalRequest._retry) {
+      if (error.response?.status === 401 && !originalRequest._retry) {
         originalRequest._retry = true;
-        // Implement token refresh logic here and update the token in headers
         try {
-        const newToken = await tokenManager.refreshToken();
-        originalRequest.headers.Authorization = `Bearer ${newToken}`;
-        return instance(originalRequest);
+          const newToken = await tokenManager.refreshToken();
+          originalRequest.headers.Authorization = `Bearer ${newToken}`;
+          return instance(originalRequest);
         } catch (refreshError) {
           console.error("Error refreshing token:", refreshError);
-          broker.publish(shellEvents.refreshTokenFailed, {request: originalRequest});
+          broker.publish(shellEvents.refreshTokenFailed, {
+            request: originalRequest,
+          });
           return Promise.reject(error);
         }
       }
@@ -41,9 +89,12 @@ let instance;
 export interface HttpClient {
   request<T = any, R = AxiosResponse<T>, D = any>(config: AxiosRequestConfig<D>): Promise<R>;
 }
-export const createHttpClient = (tokenManager: TokenManager, broker: PrimariaBroker): HttpClient => {
+export const createHttpClient = (
+  tokenManager: TokenManager,
+  broker: PrimariaBroker,
+): HttpClient => {
   if (!instance) {
     instance = createAxiosInstance(tokenManager, broker);
   }
   return { request: instance.request };
-};
+};

package/src/api/interaction-service/confirmation-message.tsx

@@ -0,0 +1,5 @@
+import { ConfirmationContentProps } from "./interaction-service.ts";
+
+export const ConfirmationMessage = ({ data }: ConfirmationContentProps<string>) => {
+    return (<div>{data}</div>)
+}

package/src/api/interaction-service/index.ts

@@ -0,0 +1 @@
+export * from "./interaction-service";

package/src/api/interaction-service/interaction-service-impl.tsx

@@ -0,0 +1,225 @@
+import {
+  ConfirmationContentProps,
+  ConfirmationOptions,
+  ConfirmationResult,
+  ConfirmationWithResultContentProps,
+  PrimariaInteractionService,
+} from "./interaction-service";
+import * as React from "react";
+import { useEffect, useState, useRef } from "react";
+import { createRoot } from "react-dom/client";
+import { ConfirmationMessage } from "./confirmation-message.tsx";
+
+const defaultOptions: ConfirmationOptions = {
+  title: "Confirmació",
+  showConfirmButton: true,
+  showCancelButton: true,
+  confirmButtonText: "Acceptar",
+  cancelButtonText: "Cancel·lar",
+  showCloseButton: true,
+  fullWidth: false,
+  fullCustomization: false,
+};
+
+export class ParimariaInteractionServiceImpl extends PrimariaInteractionService {
+  confirm<TData = undefined, TResult = undefined>(
+    data: TData | undefined,
+    DialogComponent:
+      | React.ComponentType<ConfirmationContentProps<TData, TResult> | ConfirmationWithResultContentProps<TData, TResult>>
+      | (new () => HTMLElement),
+    options?: ConfirmationOptions | undefined,
+  ): Promise<ConfirmationResult<TResult | undefined>> {
+    const finalOptions: ConfirmationOptions = { ...defaultOptions, ...(options || {}) };
+    return new Promise((resolve) => {
+      const div = document.createElement("div");
+      const shadowRoot = div.attachShadow({ mode: "open" });
+
+      document.body.appendChild(div);
+
+      const DialogWrapper = () => {
+        const [open, setOpen] = useState(true);
+        const [result, setResult] = useState<ConfirmationResult<TResult | undefined>>();
+        const [isValid, setIsValid] = useState(true);
+        const dssModalComponentRef = useRef(null);
+        const dialogComponentRef = useRef(null);
+
+        const isWebComponent =
+          typeof DialogComponent === "function" && DialogComponent.prototype instanceof HTMLElement;
+
+        useEffect(() => {
+          const dssModalComponent = dssModalComponentRef.current;
+          const handleCloseDialog = (e: Event) => {
+            e.preventDefault();
+            handleClose(false);
+          };
+          dssModalComponent?.addEventListener("onModalClosed", handleCloseDialog);
+          return () => {
+            document.body.removeChild(div);
+          };
+        }, []);
+
+        useEffect(() => {
+          if (isWebComponent && dialogComponentRef.current) {
+            const parent = dialogComponentRef.current;
+
+            // ⚠ Aquí creamos la instancia del Web Component manualmente
+            const wcElement = new (DialogComponent as any)();
+
+            // Asignar propiedades manualmente
+            (wcElement as any).data = data;
+            (wcElement as any).setResult = setResult;
+            (wcElement as any).setIsValid = setIsValid;
+            (wcElement as any).confirm = () => isValid && handleClose(true);
+            (wcElement as any).confirmResult = (result) => isValid && handleCloseWithResult(result);
+            (wcElement as any).cancel = () => handleClose(false);
+
+            // Agregar el Web Component al DOM
+            parent.appendChild(wcElement);
+
+            return () => {
+              parent.removeChild(wcElement);
+            };
+          }
+        }, [DialogComponent, data]);
+
+        const handleClose = (confirmed: boolean) => {
+          resolvePromise(result, confirmed);
+        };
+
+        const handleCloseWithResult = (finalResult: TResult) => {
+          resolvePromise(finalResult, true);
+        };
+
+        const resolvePromise = (finalResult: TResult, confirmed: boolean) => {
+          setOpen(false);
+          setTimeout(() => {
+            const confirmationResult = {
+              result: confirmed ? finalResult : undefined,
+              confirmed: confirmed,
+            };
+            resolve(confirmationResult);
+            document.body.removeChild(div);
+          }, 300);
+        };
+
+        const getConfirmButtonVariant = () => {
+          if (finalOptions.state === "error") return "error";
+          if (finalOptions.state === "success") return "success";
+          if (finalOptions.state === "info") return "primary";
+          if (finalOptions.state === "alert") return "warning";
+          return "primary";
+        };
+
+        const getCancelButtonVariant = () => {
+          if (finalOptions.state) return "alternative-dark";
+          return "secondary";
+        };
+
+        const _renderContent = () => {
+          return isWebComponent ? (
+            <div ref={dialogComponentRef} />
+          ) : (
+            <DialogComponent
+              {...{
+                data,
+                setResult,
+                setIsValid,
+                confirm: () => isValid && handleClose(true),
+                cancel: () => handleClose(false),
+              }}
+            />
+          );
+        };
+
+        if (finalOptions.fullCustomization) {
+          return (
+            <div className="modal" hidden={!open}>
+              <div className="dialog">{_renderContent()}</div>
+            </div>
+          );
+        }
+        return (
+          <dss-modal
+            modalTitle={finalOptions.title}
+            open={open}
+            fullWidth={finalOptions.fullWidth}
+            ref={dssModalComponentRef}
+            hideCloseIcon={!finalOptions.showCloseButton}
+            modalStyle="padding:0px;"
+          >
+            <div slot="body">{_renderContent()}</div>
+            <div
+              className="dss-modal-footer"
+              slot="footer"
+              hidden={!finalOptions.showCancelButton && !finalOptions.showConfirmButton}
+            >
+              {finalOptions.showCancelButton && (
+                <dss-button
+                  label={finalOptions.cancelButtonText}
+                  onClick={() => handleClose(false)}
+                  size="md"
+                  variant={getCancelButtonVariant()}
+                />
+              )}
+              {finalOptions.showConfirmButton && (
+                <dss-button
+                  onClick={() => isValid && handleClose(true)}
+                  label={finalOptions.confirmButtonText}
+                  disabled={!isValid}
+                  size="md"
+                  variant={getConfirmButtonVariant()}
+                />
+              )}
+            </div>
+          </dss-modal>
+        );
+      };
+
+      // Agregar estilos al Shadow DOM
+      const style = document.createElement("style");
+      style.textContent = `
+        .modal {
+          font-family: "Open Sans";
+          display: block;
+          position: fixed;
+          z-index: 400;
+          left: 0;
+          top: 0;
+          width: 100%;
+          height: 100%;
+          background-color: rgba(0, 0, 0, 0.65);
+
+        .dialog {
+          display: flex;
+          flex-direction: column;
+          position: absolute;
+          top: 50%;
+          left: 50%;
+          transform: translate(-50%, -50%);
+          z-index: 21;
+          background: #fff;
+          border-radius: 16px;
+          width: auto;
+          height: auto;
+          max-height: 95%;
+          min-width: 400px;
+          box-shadow:
+            0px 0px 14px rgb(0 0 0 / 25%),
+            0px 1px 10px rgb(0 0 0 / 22%);
+        }
+      }
+      `;
+
+      shadowRoot.appendChild(style);
+      const root = createRoot(shadowRoot);
+      root.render(<DialogWrapper />);
+    });
+  }
+
+  confirmMessage(
+    message: string,
+    options?: ConfirmationOptions | undefined,
+  ): Promise<ConfirmationResult> {
+    return this.confirm(message, ConfirmationMessage, options);
+  }
+}