npm - @fctc/interface-logic - Versions diffs - 3.8.8 → 3.8.10 - Mend

@fctc/interface-logic 3.8.8 → 3.8.10

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (7) hide show

package/dist/configs.js CHANGED Viewed

@@ -2276,10 +2276,10 @@ var axiosClient = {
       timeout: 5e4,
       paramsSerializer: (params) => new URLSearchParams(params).toString()
     });
-    instance.interceptors.request.use(async (config2) => {
-      const useRefreshToken = config2.headers["X-Use-Refresh-Token"] === "true";
-      const useActionToken = config2.headers["X-Use-Action-Token"] === "true";
-      const actionToken = config2.headers["X-Action-Token"];
+    instance.interceptors.request.use(async (configReq) => {
+      const useRefreshToken = configReq.headers["X-Use-Refresh-Token"] === "true";
+      const useActionToken = configReq.headers["X-Use-Action-Token"] === "true";
+      const actionToken = configReq.headers["X-Action-Token"];
       let token = null;
       if (useActionToken && actionToken) {
         token = actionToken;
@@ -2288,20 +2288,115 @@ var axiosClient = {
         token = await getToken?.();
       }
       if (token) {
-        config2.headers["Authorization"] = `Bearer ${token}`;
+        configReq.headers["Authorization"] = `Bearer ${token}`;
       }
       if (database) {
-        config2.headers["DATABASE"] = database;
+        configReq.headers["DATABASE"] = database;
       }
-      if (token) config2.headers["Authorization"] = `Bearer ${token}`;
-      return config2;
+      return configReq;
     }, Promise.reject);
+    const buildRefreshUrl = () => {
+      if (!config.refreshTokenEndpoint) {
+        return `${getBaseUrl(config?.baseUrl)}${"/authentication/oauth2/token" /* AUTH_TOKEN_PATH */}`;
+      }
+      const ep = String(config.refreshTokenEndpoint);
+      if (/^https?:\/\//i.test(ep)) return ep;
+      const cleanBase = String(config?.baseUrl || "").replace(/\/$/, "");
+      const cleanEp = ep.startsWith("/") ? ep : `/${ep}`;
+      return `${cleanBase}${cleanEp}`;
+    };
+    instance.interceptors.response.use(
+      (response) => handleResponse(response),
+      async (error) => {
+        const handleError3 = async (err) => {
+          if (!err.response) return err;
+          const { data } = err.response;
+          if (data && data.code === 400 && ["invalid_grant"].includes(data.data?.error)) {
+            await clearAuthToken();
+          }
+          return data;
+        };
+        const originalRequest = error.config;
+        if ((error.response?.status === 403 || error.response?.status === 401 || error.response?.status === 404) && ["TOKEN_EXPIRED", "AUTHEN_FAIL", 401, "ERR_2FA_006"].includes(
+          error.response.data.code
+        )) {
+          if (isRefreshing) {
+            return new Promise(function(resolve, reject) {
+              failedQueue.push({ resolve, reject });
+            }).then((newToken) => {
+              originalRequest.headers["Authorization"] = "Bearer " + newToken;
+              originalRequest.data = updateTokenParamInOriginalRequest(
+                originalRequest,
+                newToken
+              );
+              return instance.request(originalRequest);
+            }).catch(async (err) => {
+              if ((err.response?.status === 400 || err.response?.status === 401) && ["invalid_grant"].includes(err.response.data.error)) {
+                await clearAuthToken();
+              }
+            });
+          }
+          const browserSession = await sessionStorage2.getBrowserSession();
+          const refreshToken = await localStorage2.getRefreshToken();
+          const accessTokenExp = await localStorage2.getAccessToken();
+          isRefreshing = true;
+          if (!refreshToken && (!browserSession || browserSession == "unActive")) {
+            await clearAuthToken();
+          } else {
+            const payload = Object.fromEntries(
+              Object.entries({
+                refresh_token: refreshToken,
+                grant_type: "refresh_token",
+                client_id: config.config.clientId,
+                client_secret: config.config.clientSecret
+              }).filter(([_, v]) => !!v)
+            );
+            const refreshUrl = buildRefreshUrl();
+            return new Promise(function(resolve) {
+              import_axios.default.post(refreshUrl, payload, {
+                headers: {
+                  "Content-Type": config.refreshTokenEndpoint ? "application/x-www-form-urlencoded" : "multipart/form-data",
+                  Authorization: `Bearer ${accessTokenExp}`
+                }
+              }).then(async (res) => {
+                const data = res.data;
+                await localStorage2.setToken(data.access_token);
+                await localStorage2.setRefreshToken(data.refresh_token);
+                import_axios.default.defaults.headers.common["Authorization"] = "Bearer " + data.access_token;
+                originalRequest.headers["Authorization"] = "Bearer " + data.access_token;
+                originalRequest.data = updateTokenParamInOriginalRequest(
+                  originalRequest,
+                  data.access_token
+                );
+                processQueue(null, data.access_token);
+                resolve(instance.request(originalRequest));
+              }).catch(async (err) => {
+                if (err && (err?.error_code === "AUTHEN_FAIL" || err?.error_code === "TOKEN_EXPIRED" || err?.error_code === "TOKEN_INCORRECT" || err?.code === "ERR_2FA_006")) {
+                  await clearAuthToken();
+                }
+                if (err && err.response) {
+                  const { error_code } = err.response?.data || {};
+                  const { code } = err;
+                  if (error_code === "AUTHEN_FAIL" || code === "ERR_2FA_006") {
+                    await clearAuthToken();
+                  }
+                }
+                processQueue(err, null);
+              }).finally(() => {
+                isRefreshing = false;
+              });
+            });
+          }
+        }
+        return Promise.reject(await handleError3(error));
+      }
+    );
     instance.interceptors.response.use(
       (response) => {
         return handleResponse(response);
       },
       async (error) => {
-        const handleError2 = async (error2) => {
+        const handleError3 = async (error2) => {
           if (!error2.response) {
             return error2;
           }
@@ -2347,13 +2442,16 @@ var axiosClient = {
               }).filter(([_, value]) => !!value)
             );
             return new Promise(function(resolve) {
-              const refreshPath = config.refreshTokenEndpoint ? config.refreshTokenEndpoint : `/api/v2${"/authentication/oauth2/token" /* AUTH_TOKEN_PATH */}`;
-              import_axios.default.post(`${config?.baseUrl}${refreshPath}`, payload, {
-                headers: {
-                  "Content-Type": config.refreshTokenEndpoint ? "application/x-www-form-urlencoded" : "multipart/form-data",
-                  Authorization: `Bearer ${accessTokenExp}`
+              import_axios.default.post(
+                `${config?.baseUrl}${config.refreshTokenEndpoint ?? "/authentication/oauth2/token" /* AUTH_TOKEN_PATH */}`,
+                payload,
+                {
+                  headers: {
+                    "Content-Type": config.refreshTokenEndpoint ? "application/x-www-form-urlencoded" : "multipart/form-data",
+                    Authorization: `Bearer ${accessTokenExp}`
+                  }
                 }
-              }).then(async (res) => {
+              ).then(async (res) => {
                 const data = res.data;
                 await localStorage2.setToken(data.access_token);
                 await localStorage2.setRefreshToken(data.refresh_token);
@@ -2386,7 +2484,7 @@ var axiosClient = {
             });
           }
         }
-        return Promise.reject(await handleError2(error));
+        return Promise.reject(await handleError3(error));
       }
     );
     const handleResponse = (res) => {
@@ -2395,6 +2493,19 @@ var axiosClient = {
       }
       return res;
     };
+    const handleError2 = (error) => {
+      if (error.isAxiosError && error.code === "ECONNABORTED") {
+        console.error("Request Timeout Error:", error);
+        return "Request Timeout Error";
+      } else if (error.isAxiosError && !error.response) {
+        console.error("Network Error:", error);
+        return "Network Error";
+      } else {
+        console.error("Other Error:", error?.response);
+        const errorMessage = error?.response?.data?.message || "An error occurred";
+        return { message: errorMessage, status: error?.response?.status };
+      }
+    };
     const clearAuthToken = async () => {
       await localStorage2.clearToken();
       if (typeof window !== "undefined") {

package/dist/configs.mjs CHANGED Viewed

@@ -2240,10 +2240,10 @@ var axiosClient = {
       timeout: 5e4,
       paramsSerializer: (params) => new URLSearchParams(params).toString()
     });
-    instance.interceptors.request.use(async (config2) => {
-      const useRefreshToken = config2.headers["X-Use-Refresh-Token"] === "true";
-      const useActionToken = config2.headers["X-Use-Action-Token"] === "true";
-      const actionToken = config2.headers["X-Action-Token"];
+    instance.interceptors.request.use(async (configReq) => {
+      const useRefreshToken = configReq.headers["X-Use-Refresh-Token"] === "true";
+      const useActionToken = configReq.headers["X-Use-Action-Token"] === "true";
+      const actionToken = configReq.headers["X-Action-Token"];
       let token = null;
       if (useActionToken && actionToken) {
         token = actionToken;
@@ -2252,20 +2252,115 @@ var axiosClient = {
         token = await getToken?.();
       }
       if (token) {
-        config2.headers["Authorization"] = `Bearer ${token}`;
+        configReq.headers["Authorization"] = `Bearer ${token}`;
       }
       if (database) {
-        config2.headers["DATABASE"] = database;
+        configReq.headers["DATABASE"] = database;
       }
-      if (token) config2.headers["Authorization"] = `Bearer ${token}`;
-      return config2;
+      return configReq;
     }, Promise.reject);
+    const buildRefreshUrl = () => {
+      if (!config.refreshTokenEndpoint) {
+        return `${getBaseUrl(config?.baseUrl)}${"/authentication/oauth2/token" /* AUTH_TOKEN_PATH */}`;
+      }
+      const ep = String(config.refreshTokenEndpoint);
+      if (/^https?:\/\//i.test(ep)) return ep;
+      const cleanBase = String(config?.baseUrl || "").replace(/\/$/, "");
+      const cleanEp = ep.startsWith("/") ? ep : `/${ep}`;
+      return `${cleanBase}${cleanEp}`;
+    };
+    instance.interceptors.response.use(
+      (response) => handleResponse(response),
+      async (error) => {
+        const handleError3 = async (err) => {
+          if (!err.response) return err;
+          const { data } = err.response;
+          if (data && data.code === 400 && ["invalid_grant"].includes(data.data?.error)) {
+            await clearAuthToken();
+          }
+          return data;
+        };
+        const originalRequest = error.config;
+        if ((error.response?.status === 403 || error.response?.status === 401 || error.response?.status === 404) && ["TOKEN_EXPIRED", "AUTHEN_FAIL", 401, "ERR_2FA_006"].includes(
+          error.response.data.code
+        )) {
+          if (isRefreshing) {
+            return new Promise(function(resolve, reject) {
+              failedQueue.push({ resolve, reject });
+            }).then((newToken) => {
+              originalRequest.headers["Authorization"] = "Bearer " + newToken;
+              originalRequest.data = updateTokenParamInOriginalRequest(
+                originalRequest,
+                newToken
+              );
+              return instance.request(originalRequest);
+            }).catch(async (err) => {
+              if ((err.response?.status === 400 || err.response?.status === 401) && ["invalid_grant"].includes(err.response.data.error)) {
+                await clearAuthToken();
+              }
+            });
+          }
+          const browserSession = await sessionStorage2.getBrowserSession();
+          const refreshToken = await localStorage2.getRefreshToken();
+          const accessTokenExp = await localStorage2.getAccessToken();
+          isRefreshing = true;
+          if (!refreshToken && (!browserSession || browserSession == "unActive")) {
+            await clearAuthToken();
+          } else {
+            const payload = Object.fromEntries(
+              Object.entries({
+                refresh_token: refreshToken,
+                grant_type: "refresh_token",
+                client_id: config.config.clientId,
+                client_secret: config.config.clientSecret
+              }).filter(([_, v]) => !!v)
+            );
+            const refreshUrl = buildRefreshUrl();
+            return new Promise(function(resolve) {
+              axios.post(refreshUrl, payload, {
+                headers: {
+                  "Content-Type": config.refreshTokenEndpoint ? "application/x-www-form-urlencoded" : "multipart/form-data",
+                  Authorization: `Bearer ${accessTokenExp}`
+                }
+              }).then(async (res) => {
+                const data = res.data;
+                await localStorage2.setToken(data.access_token);
+                await localStorage2.setRefreshToken(data.refresh_token);
+                axios.defaults.headers.common["Authorization"] = "Bearer " + data.access_token;
+                originalRequest.headers["Authorization"] = "Bearer " + data.access_token;
+                originalRequest.data = updateTokenParamInOriginalRequest(
+                  originalRequest,
+                  data.access_token
+                );
+                processQueue(null, data.access_token);
+                resolve(instance.request(originalRequest));
+              }).catch(async (err) => {
+                if (err && (err?.error_code === "AUTHEN_FAIL" || err?.error_code === "TOKEN_EXPIRED" || err?.error_code === "TOKEN_INCORRECT" || err?.code === "ERR_2FA_006")) {
+                  await clearAuthToken();
+                }
+                if (err && err.response) {
+                  const { error_code } = err.response?.data || {};
+                  const { code } = err;
+                  if (error_code === "AUTHEN_FAIL" || code === "ERR_2FA_006") {
+                    await clearAuthToken();
+                  }
+                }
+                processQueue(err, null);
+              }).finally(() => {
+                isRefreshing = false;
+              });
+            });
+          }
+        }
+        return Promise.reject(await handleError3(error));
+      }
+    );
     instance.interceptors.response.use(
       (response) => {
         return handleResponse(response);
       },
       async (error) => {
-        const handleError2 = async (error2) => {
+        const handleError3 = async (error2) => {
           if (!error2.response) {
             return error2;
           }
@@ -2311,13 +2406,16 @@ var axiosClient = {
               }).filter(([_, value]) => !!value)
             );
             return new Promise(function(resolve) {
-              const refreshPath = config.refreshTokenEndpoint ? config.refreshTokenEndpoint : `/api/v2${"/authentication/oauth2/token" /* AUTH_TOKEN_PATH */}`;
-              axios.post(`${config?.baseUrl}${refreshPath}`, payload, {
-                headers: {
-                  "Content-Type": config.refreshTokenEndpoint ? "application/x-www-form-urlencoded" : "multipart/form-data",
-                  Authorization: `Bearer ${accessTokenExp}`
+              axios.post(
+                `${config?.baseUrl}${config.refreshTokenEndpoint ?? "/authentication/oauth2/token" /* AUTH_TOKEN_PATH */}`,
+                payload,
+                {
+                  headers: {
+                    "Content-Type": config.refreshTokenEndpoint ? "application/x-www-form-urlencoded" : "multipart/form-data",
+                    Authorization: `Bearer ${accessTokenExp}`
+                  }
                 }
-              }).then(async (res) => {
+              ).then(async (res) => {
                 const data = res.data;
                 await localStorage2.setToken(data.access_token);
                 await localStorage2.setRefreshToken(data.refresh_token);
@@ -2350,7 +2448,7 @@ var axiosClient = {
             });
           }
         }
-        return Promise.reject(await handleError2(error));
+        return Promise.reject(await handleError3(error));
       }
     );
     const handleResponse = (res) => {
@@ -2359,6 +2457,19 @@ var axiosClient = {
       }
       return res;
     };
+    const handleError2 = (error) => {
+      if (error.isAxiosError && error.code === "ECONNABORTED") {
+        console.error("Request Timeout Error:", error);
+        return "Request Timeout Error";
+      } else if (error.isAxiosError && !error.response) {
+        console.error("Network Error:", error);
+        return "Network Error";
+      } else {
+        console.error("Other Error:", error?.response);
+        const errorMessage = error?.response?.data?.message || "An error occurred";
+        return { message: errorMessage, status: error?.response?.status };
+      }
+    };
     const clearAuthToken = async () => {
       await localStorage2.clearToken();
       if (typeof window !== "undefined") {

package/dist/environment.js CHANGED Viewed

@@ -2278,10 +2278,10 @@ var axiosClient = {
       timeout: 5e4,
       paramsSerializer: (params) => new URLSearchParams(params).toString()
     });
-    instance.interceptors.request.use(async (config2) => {
-      const useRefreshToken = config2.headers["X-Use-Refresh-Token"] === "true";
-      const useActionToken = config2.headers["X-Use-Action-Token"] === "true";
-      const actionToken = config2.headers["X-Action-Token"];
+    instance.interceptors.request.use(async (configReq) => {
+      const useRefreshToken = configReq.headers["X-Use-Refresh-Token"] === "true";
+      const useActionToken = configReq.headers["X-Use-Action-Token"] === "true";
+      const actionToken = configReq.headers["X-Action-Token"];
       let token = null;
       if (useActionToken && actionToken) {
         token = actionToken;
@@ -2290,20 +2290,115 @@ var axiosClient = {
         token = await getToken?.();
       }
       if (token) {
-        config2.headers["Authorization"] = `Bearer ${token}`;
+        configReq.headers["Authorization"] = `Bearer ${token}`;
       }
       if (database) {
-        config2.headers["DATABASE"] = database;
+        configReq.headers["DATABASE"] = database;
       }
-      if (token) config2.headers["Authorization"] = `Bearer ${token}`;
-      return config2;
+      return configReq;
     }, Promise.reject);
+    const buildRefreshUrl = () => {
+      if (!config.refreshTokenEndpoint) {
+        return `${getBaseUrl(config?.baseUrl)}${"/authentication/oauth2/token" /* AUTH_TOKEN_PATH */}`;
+      }
+      const ep = String(config.refreshTokenEndpoint);
+      if (/^https?:\/\//i.test(ep)) return ep;
+      const cleanBase = String(config?.baseUrl || "").replace(/\/$/, "");
+      const cleanEp = ep.startsWith("/") ? ep : `/${ep}`;
+      return `${cleanBase}${cleanEp}`;
+    };
+    instance.interceptors.response.use(
+      (response) => handleResponse(response),
+      async (error) => {
+        const handleError3 = async (err) => {
+          if (!err.response) return err;
+          const { data } = err.response;
+          if (data && data.code === 400 && ["invalid_grant"].includes(data.data?.error)) {
+            await clearAuthToken();
+          }
+          return data;
+        };
+        const originalRequest = error.config;
+        if ((error.response?.status === 403 || error.response?.status === 401 || error.response?.status === 404) && ["TOKEN_EXPIRED", "AUTHEN_FAIL", 401, "ERR_2FA_006"].includes(
+          error.response.data.code
+        )) {
+          if (isRefreshing) {
+            return new Promise(function(resolve, reject) {
+              failedQueue.push({ resolve, reject });
+            }).then((newToken) => {
+              originalRequest.headers["Authorization"] = "Bearer " + newToken;
+              originalRequest.data = updateTokenParamInOriginalRequest(
+                originalRequest,
+                newToken
+              );
+              return instance.request(originalRequest);
+            }).catch(async (err) => {
+              if ((err.response?.status === 400 || err.response?.status === 401) && ["invalid_grant"].includes(err.response.data.error)) {
+                await clearAuthToken();
+              }
+            });
+          }
+          const browserSession = await sessionStorage2.getBrowserSession();
+          const refreshToken = await localStorage2.getRefreshToken();
+          const accessTokenExp = await localStorage2.getAccessToken();
+          isRefreshing = true;
+          if (!refreshToken && (!browserSession || browserSession == "unActive")) {
+            await clearAuthToken();
+          } else {
+            const payload = Object.fromEntries(
+              Object.entries({
+                refresh_token: refreshToken,
+                grant_type: "refresh_token",
+                client_id: config.config.clientId,
+                client_secret: config.config.clientSecret
+              }).filter(([_, v]) => !!v)
+            );
+            const refreshUrl = buildRefreshUrl();
+            return new Promise(function(resolve) {
+              import_axios.default.post(refreshUrl, payload, {
+                headers: {
+                  "Content-Type": config.refreshTokenEndpoint ? "application/x-www-form-urlencoded" : "multipart/form-data",
+                  Authorization: `Bearer ${accessTokenExp}`
+                }
+              }).then(async (res) => {
+                const data = res.data;
+                await localStorage2.setToken(data.access_token);
+                await localStorage2.setRefreshToken(data.refresh_token);
+                import_axios.default.defaults.headers.common["Authorization"] = "Bearer " + data.access_token;
+                originalRequest.headers["Authorization"] = "Bearer " + data.access_token;
+                originalRequest.data = updateTokenParamInOriginalRequest(
+                  originalRequest,
+                  data.access_token
+                );
+                processQueue(null, data.access_token);
+                resolve(instance.request(originalRequest));
+              }).catch(async (err) => {
+                if (err && (err?.error_code === "AUTHEN_FAIL" || err?.error_code === "TOKEN_EXPIRED" || err?.error_code === "TOKEN_INCORRECT" || err?.code === "ERR_2FA_006")) {
+                  await clearAuthToken();
+                }
+                if (err && err.response) {
+                  const { error_code } = err.response?.data || {};
+                  const { code } = err;
+                  if (error_code === "AUTHEN_FAIL" || code === "ERR_2FA_006") {
+                    await clearAuthToken();
+                  }
+                }
+                processQueue(err, null);
+              }).finally(() => {
+                isRefreshing = false;
+              });
+            });
+          }
+        }
+        return Promise.reject(await handleError3(error));
+      }
+    );
     instance.interceptors.response.use(
       (response) => {
         return handleResponse(response);
       },
       async (error) => {
-        const handleError2 = async (error2) => {
+        const handleError3 = async (error2) => {
           if (!error2.response) {
             return error2;
           }
@@ -2349,13 +2444,16 @@ var axiosClient = {
               }).filter(([_, value]) => !!value)
             );
             return new Promise(function(resolve) {
-              const refreshPath = config.refreshTokenEndpoint ? config.refreshTokenEndpoint : `/api/v2${"/authentication/oauth2/token" /* AUTH_TOKEN_PATH */}`;
-              import_axios.default.post(`${config?.baseUrl}${refreshPath}`, payload, {
-                headers: {
-                  "Content-Type": config.refreshTokenEndpoint ? "application/x-www-form-urlencoded" : "multipart/form-data",
-                  Authorization: `Bearer ${accessTokenExp}`
+              import_axios.default.post(
+                `${config?.baseUrl}${config.refreshTokenEndpoint ?? "/authentication/oauth2/token" /* AUTH_TOKEN_PATH */}`,
+                payload,
+                {
+                  headers: {
+                    "Content-Type": config.refreshTokenEndpoint ? "application/x-www-form-urlencoded" : "multipart/form-data",
+                    Authorization: `Bearer ${accessTokenExp}`
+                  }
                 }
-              }).then(async (res) => {
+              ).then(async (res) => {
                 const data = res.data;
                 await localStorage2.setToken(data.access_token);
                 await localStorage2.setRefreshToken(data.refresh_token);
@@ -2388,7 +2486,7 @@ var axiosClient = {
             });
           }
         }
-        return Promise.reject(await handleError2(error));
+        return Promise.reject(await handleError3(error));
       }
     );
     const handleResponse = (res) => {
@@ -2397,6 +2495,19 @@ var axiosClient = {
       }
       return res;
     };
+    const handleError2 = (error) => {
+      if (error.isAxiosError && error.code === "ECONNABORTED") {
+        console.error("Request Timeout Error:", error);
+        return "Request Timeout Error";
+      } else if (error.isAxiosError && !error.response) {
+        console.error("Network Error:", error);
+        return "Network Error";
+      } else {
+        console.error("Other Error:", error?.response);
+        const errorMessage = error?.response?.data?.message || "An error occurred";
+        return { message: errorMessage, status: error?.response?.status };
+      }
+    };
     const clearAuthToken = async () => {
       await localStorage2.clearToken();
       if (typeof window !== "undefined") {

package/dist/environment.mjs CHANGED Viewed

@@ -2240,10 +2240,10 @@ var axiosClient = {
       timeout: 5e4,
       paramsSerializer: (params) => new URLSearchParams(params).toString()
     });
-    instance.interceptors.request.use(async (config2) => {
-      const useRefreshToken = config2.headers["X-Use-Refresh-Token"] === "true";
-      const useActionToken = config2.headers["X-Use-Action-Token"] === "true";
-      const actionToken = config2.headers["X-Action-Token"];
+    instance.interceptors.request.use(async (configReq) => {
+      const useRefreshToken = configReq.headers["X-Use-Refresh-Token"] === "true";
+      const useActionToken = configReq.headers["X-Use-Action-Token"] === "true";
+      const actionToken = configReq.headers["X-Action-Token"];
       let token = null;
       if (useActionToken && actionToken) {
         token = actionToken;
@@ -2252,20 +2252,115 @@ var axiosClient = {
         token = await getToken?.();
       }
       if (token) {
-        config2.headers["Authorization"] = `Bearer ${token}`;
+        configReq.headers["Authorization"] = `Bearer ${token}`;
       }
       if (database) {
-        config2.headers["DATABASE"] = database;
+        configReq.headers["DATABASE"] = database;
       }
-      if (token) config2.headers["Authorization"] = `Bearer ${token}`;
-      return config2;
+      return configReq;
     }, Promise.reject);
+    const buildRefreshUrl = () => {
+      if (!config.refreshTokenEndpoint) {
+        return `${getBaseUrl(config?.baseUrl)}${"/authentication/oauth2/token" /* AUTH_TOKEN_PATH */}`;
+      }
+      const ep = String(config.refreshTokenEndpoint);
+      if (/^https?:\/\//i.test(ep)) return ep;
+      const cleanBase = String(config?.baseUrl || "").replace(/\/$/, "");
+      const cleanEp = ep.startsWith("/") ? ep : `/${ep}`;
+      return `${cleanBase}${cleanEp}`;
+    };
+    instance.interceptors.response.use(
+      (response) => handleResponse(response),
+      async (error) => {
+        const handleError3 = async (err) => {
+          if (!err.response) return err;
+          const { data } = err.response;
+          if (data && data.code === 400 && ["invalid_grant"].includes(data.data?.error)) {
+            await clearAuthToken();
+          }
+          return data;
+        };
+        const originalRequest = error.config;
+        if ((error.response?.status === 403 || error.response?.status === 401 || error.response?.status === 404) && ["TOKEN_EXPIRED", "AUTHEN_FAIL", 401, "ERR_2FA_006"].includes(
+          error.response.data.code
+        )) {
+          if (isRefreshing) {
+            return new Promise(function(resolve, reject) {
+              failedQueue.push({ resolve, reject });
+            }).then((newToken) => {
+              originalRequest.headers["Authorization"] = "Bearer " + newToken;
+              originalRequest.data = updateTokenParamInOriginalRequest(
+                originalRequest,
+                newToken
+              );
+              return instance.request(originalRequest);
+            }).catch(async (err) => {
+              if ((err.response?.status === 400 || err.response?.status === 401) && ["invalid_grant"].includes(err.response.data.error)) {
+                await clearAuthToken();
+              }
+            });
+          }
+          const browserSession = await sessionStorage2.getBrowserSession();
+          const refreshToken = await localStorage2.getRefreshToken();
+          const accessTokenExp = await localStorage2.getAccessToken();
+          isRefreshing = true;
+          if (!refreshToken && (!browserSession || browserSession == "unActive")) {
+            await clearAuthToken();
+          } else {
+            const payload = Object.fromEntries(
+              Object.entries({
+                refresh_token: refreshToken,
+                grant_type: "refresh_token",
+                client_id: config.config.clientId,
+                client_secret: config.config.clientSecret
+              }).filter(([_, v]) => !!v)
+            );
+            const refreshUrl = buildRefreshUrl();
+            return new Promise(function(resolve) {
+              axios.post(refreshUrl, payload, {
+                headers: {
+                  "Content-Type": config.refreshTokenEndpoint ? "application/x-www-form-urlencoded" : "multipart/form-data",
+                  Authorization: `Bearer ${accessTokenExp}`
+                }
+              }).then(async (res) => {
+                const data = res.data;
+                await localStorage2.setToken(data.access_token);
+                await localStorage2.setRefreshToken(data.refresh_token);
+                axios.defaults.headers.common["Authorization"] = "Bearer " + data.access_token;
+                originalRequest.headers["Authorization"] = "Bearer " + data.access_token;
+                originalRequest.data = updateTokenParamInOriginalRequest(
+                  originalRequest,
+                  data.access_token
+                );
+                processQueue(null, data.access_token);
+                resolve(instance.request(originalRequest));
+              }).catch(async (err) => {
+                if (err && (err?.error_code === "AUTHEN_FAIL" || err?.error_code === "TOKEN_EXPIRED" || err?.error_code === "TOKEN_INCORRECT" || err?.code === "ERR_2FA_006")) {
+                  await clearAuthToken();
+                }
+                if (err && err.response) {
+                  const { error_code } = err.response?.data || {};
+                  const { code } = err;
+                  if (error_code === "AUTHEN_FAIL" || code === "ERR_2FA_006") {
+                    await clearAuthToken();
+                  }
+                }
+                processQueue(err, null);
+              }).finally(() => {
+                isRefreshing = false;
+              });
+            });
+          }
+        }
+        return Promise.reject(await handleError3(error));
+      }
+    );
     instance.interceptors.response.use(
       (response) => {
         return handleResponse(response);
       },
       async (error) => {
-        const handleError2 = async (error2) => {
+        const handleError3 = async (error2) => {
           if (!error2.response) {
             return error2;
           }
@@ -2311,13 +2406,16 @@ var axiosClient = {
               }).filter(([_, value]) => !!value)
             );
             return new Promise(function(resolve) {
-              const refreshPath = config.refreshTokenEndpoint ? config.refreshTokenEndpoint : `/api/v2${"/authentication/oauth2/token" /* AUTH_TOKEN_PATH */}`;
-              axios.post(`${config?.baseUrl}${refreshPath}`, payload, {
-                headers: {
-                  "Content-Type": config.refreshTokenEndpoint ? "application/x-www-form-urlencoded" : "multipart/form-data",
-                  Authorization: `Bearer ${accessTokenExp}`
+              axios.post(
+                `${config?.baseUrl}${config.refreshTokenEndpoint ?? "/authentication/oauth2/token" /* AUTH_TOKEN_PATH */}`,
+                payload,
+                {
+                  headers: {
+                    "Content-Type": config.refreshTokenEndpoint ? "application/x-www-form-urlencoded" : "multipart/form-data",
+                    Authorization: `Bearer ${accessTokenExp}`
+                  }
                 }
-              }).then(async (res) => {
+              ).then(async (res) => {
                 const data = res.data;
                 await localStorage2.setToken(data.access_token);
                 await localStorage2.setRefreshToken(data.refresh_token);
@@ -2350,7 +2448,7 @@ var axiosClient = {
             });
           }
         }
-        return Promise.reject(await handleError2(error));
+        return Promise.reject(await handleError3(error));
       }
     );
     const handleResponse = (res) => {
@@ -2359,6 +2457,19 @@ var axiosClient = {
       }
       return res;
     };
+    const handleError2 = (error) => {
+      if (error.isAxiosError && error.code === "ECONNABORTED") {
+        console.error("Request Timeout Error:", error);
+        return "Request Timeout Error";
+      } else if (error.isAxiosError && !error.response) {
+        console.error("Network Error:", error);
+        return "Network Error";
+      } else {
+        console.error("Other Error:", error?.response);
+        const errorMessage = error?.response?.data?.message || "An error occurred";
+        return { message: errorMessage, status: error?.response?.status };
+      }
+    };
     const clearAuthToken = async () => {
       await localStorage2.clearToken();
       if (typeof window !== "undefined") {

package/dist/provider.js CHANGED Viewed

@@ -5915,10 +5915,10 @@ var axiosClient = {
       timeout: 5e4,
       paramsSerializer: (params) => new URLSearchParams(params).toString()
     });
-    instance.interceptors.request.use(async (config2) => {
-      const useRefreshToken = config2.headers["X-Use-Refresh-Token"] === "true";
-      const useActionToken = config2.headers["X-Use-Action-Token"] === "true";
-      const actionToken = config2.headers["X-Action-Token"];
+    instance.interceptors.request.use(async (configReq) => {
+      const useRefreshToken = configReq.headers["X-Use-Refresh-Token"] === "true";
+      const useActionToken = configReq.headers["X-Use-Action-Token"] === "true";
+      const actionToken = configReq.headers["X-Action-Token"];
       let token = null;
       if (useActionToken && actionToken) {
         token = actionToken;
@@ -5927,20 +5927,115 @@ var axiosClient = {
         token = await getToken?.();
       }
       if (token) {
-        config2.headers["Authorization"] = `Bearer ${token}`;
+        configReq.headers["Authorization"] = `Bearer ${token}`;
       }
       if (database) {
-        config2.headers["DATABASE"] = database;
+        configReq.headers["DATABASE"] = database;
       }
-      if (token) config2.headers["Authorization"] = `Bearer ${token}`;
-      return config2;
+      return configReq;
     }, Promise.reject);
+    const buildRefreshUrl = () => {
+      if (!config.refreshTokenEndpoint) {
+        return `${getBaseUrl(config?.baseUrl)}${"/authentication/oauth2/token" /* AUTH_TOKEN_PATH */}`;
+      }
+      const ep = String(config.refreshTokenEndpoint);
+      if (/^https?:\/\//i.test(ep)) return ep;
+      const cleanBase = String(config?.baseUrl || "").replace(/\/$/, "");
+      const cleanEp = ep.startsWith("/") ? ep : `/${ep}`;
+      return `${cleanBase}${cleanEp}`;
+    };
+    instance.interceptors.response.use(
+      (response) => handleResponse(response),
+      async (error) => {
+        const handleError3 = async (err) => {
+          if (!err.response) return err;
+          const { data } = err.response;
+          if (data && data.code === 400 && ["invalid_grant"].includes(data.data?.error)) {
+            await clearAuthToken();
+          }
+          return data;
+        };
+        const originalRequest = error.config;
+        if ((error.response?.status === 403 || error.response?.status === 401 || error.response?.status === 404) && ["TOKEN_EXPIRED", "AUTHEN_FAIL", 401, "ERR_2FA_006"].includes(
+          error.response.data.code
+        )) {
+          if (isRefreshing) {
+            return new Promise(function(resolve, reject) {
+              failedQueue.push({ resolve, reject });
+            }).then((newToken) => {
+              originalRequest.headers["Authorization"] = "Bearer " + newToken;
+              originalRequest.data = updateTokenParamInOriginalRequest(
+                originalRequest,
+                newToken
+              );
+              return instance.request(originalRequest);
+            }).catch(async (err) => {
+              if ((err.response?.status === 400 || err.response?.status === 401) && ["invalid_grant"].includes(err.response.data.error)) {
+                await clearAuthToken();
+              }
+            });
+          }
+          const browserSession = await sessionStorage2.getBrowserSession();
+          const refreshToken = await localStorage2.getRefreshToken();
+          const accessTokenExp = await localStorage2.getAccessToken();
+          isRefreshing = true;
+          if (!refreshToken && (!browserSession || browserSession == "unActive")) {
+            await clearAuthToken();
+          } else {
+            const payload = Object.fromEntries(
+              Object.entries({
+                refresh_token: refreshToken,
+                grant_type: "refresh_token",
+                client_id: config.config.clientId,
+                client_secret: config.config.clientSecret
+              }).filter(([_, v]) => !!v)
+            );
+            const refreshUrl = buildRefreshUrl();
+            return new Promise(function(resolve) {
+              import_axios.default.post(refreshUrl, payload, {
+                headers: {
+                  "Content-Type": config.refreshTokenEndpoint ? "application/x-www-form-urlencoded" : "multipart/form-data",
+                  Authorization: `Bearer ${accessTokenExp}`
+                }
+              }).then(async (res) => {
+                const data = res.data;
+                await localStorage2.setToken(data.access_token);
+                await localStorage2.setRefreshToken(data.refresh_token);
+                import_axios.default.defaults.headers.common["Authorization"] = "Bearer " + data.access_token;
+                originalRequest.headers["Authorization"] = "Bearer " + data.access_token;
+                originalRequest.data = updateTokenParamInOriginalRequest(
+                  originalRequest,
+                  data.access_token
+                );
+                processQueue(null, data.access_token);
+                resolve(instance.request(originalRequest));
+              }).catch(async (err) => {
+                if (err && (err?.error_code === "AUTHEN_FAIL" || err?.error_code === "TOKEN_EXPIRED" || err?.error_code === "TOKEN_INCORRECT" || err?.code === "ERR_2FA_006")) {
+                  await clearAuthToken();
+                }
+                if (err && err.response) {
+                  const { error_code } = err.response?.data || {};
+                  const { code } = err;
+                  if (error_code === "AUTHEN_FAIL" || code === "ERR_2FA_006") {
+                    await clearAuthToken();
+                  }
+                }
+                processQueue(err, null);
+              }).finally(() => {
+                isRefreshing = false;
+              });
+            });
+          }
+        }
+        return Promise.reject(await handleError3(error));
+      }
+    );
     instance.interceptors.response.use(
       (response) => {
         return handleResponse(response);
       },
       async (error) => {
-        const handleError2 = async (error2) => {
+        const handleError3 = async (error2) => {
           if (!error2.response) {
             return error2;
           }
@@ -5986,13 +6081,16 @@ var axiosClient = {
               }).filter(([_, value]) => !!value)
             );
             return new Promise(function(resolve) {
-              const refreshPath = config.refreshTokenEndpoint ? config.refreshTokenEndpoint : `/api/v2${"/authentication/oauth2/token" /* AUTH_TOKEN_PATH */}`;
-              import_axios.default.post(`${config?.baseUrl}${refreshPath}`, payload, {
-                headers: {
-                  "Content-Type": config.refreshTokenEndpoint ? "application/x-www-form-urlencoded" : "multipart/form-data",
-                  Authorization: `Bearer ${accessTokenExp}`
+              import_axios.default.post(
+                `${config?.baseUrl}${config.refreshTokenEndpoint ?? "/authentication/oauth2/token" /* AUTH_TOKEN_PATH */}`,
+                payload,
+                {
+                  headers: {
+                    "Content-Type": config.refreshTokenEndpoint ? "application/x-www-form-urlencoded" : "multipart/form-data",
+                    Authorization: `Bearer ${accessTokenExp}`
+                  }
                 }
-              }).then(async (res) => {
+              ).then(async (res) => {
                 const data = res.data;
                 await localStorage2.setToken(data.access_token);
                 await localStorage2.setRefreshToken(data.refresh_token);
@@ -6025,7 +6123,7 @@ var axiosClient = {
             });
           }
         }
-        return Promise.reject(await handleError2(error));
+        return Promise.reject(await handleError3(error));
       }
     );
     const handleResponse = (res) => {
@@ -6034,6 +6132,19 @@ var axiosClient = {
       }
       return res;
     };
+    const handleError2 = (error) => {
+      if (error.isAxiosError && error.code === "ECONNABORTED") {
+        console.error("Request Timeout Error:", error);
+        return "Request Timeout Error";
+      } else if (error.isAxiosError && !error.response) {
+        console.error("Network Error:", error);
+        return "Network Error";
+      } else {
+        console.error("Other Error:", error?.response);
+        const errorMessage = error?.response?.data?.message || "An error occurred";
+        return { message: errorMessage, status: error?.response?.status };
+      }
+    };
     const clearAuthToken = async () => {
       await localStorage2.clearToken();
       if (typeof window !== "undefined") {

package/dist/provider.mjs CHANGED Viewed

@@ -5872,10 +5872,10 @@ var axiosClient = {
       timeout: 5e4,
       paramsSerializer: (params) => new URLSearchParams(params).toString()
     });
-    instance.interceptors.request.use(async (config2) => {
-      const useRefreshToken = config2.headers["X-Use-Refresh-Token"] === "true";
-      const useActionToken = config2.headers["X-Use-Action-Token"] === "true";
-      const actionToken = config2.headers["X-Action-Token"];
+    instance.interceptors.request.use(async (configReq) => {
+      const useRefreshToken = configReq.headers["X-Use-Refresh-Token"] === "true";
+      const useActionToken = configReq.headers["X-Use-Action-Token"] === "true";
+      const actionToken = configReq.headers["X-Action-Token"];
       let token = null;
       if (useActionToken && actionToken) {
         token = actionToken;
@@ -5884,20 +5884,115 @@ var axiosClient = {
         token = await getToken?.();
       }
       if (token) {
-        config2.headers["Authorization"] = `Bearer ${token}`;
+        configReq.headers["Authorization"] = `Bearer ${token}`;
       }
       if (database) {
-        config2.headers["DATABASE"] = database;
+        configReq.headers["DATABASE"] = database;
       }
-      if (token) config2.headers["Authorization"] = `Bearer ${token}`;
-      return config2;
+      return configReq;
     }, Promise.reject);
+    const buildRefreshUrl = () => {
+      if (!config.refreshTokenEndpoint) {
+        return `${getBaseUrl(config?.baseUrl)}${"/authentication/oauth2/token" /* AUTH_TOKEN_PATH */}`;
+      }
+      const ep = String(config.refreshTokenEndpoint);
+      if (/^https?:\/\//i.test(ep)) return ep;
+      const cleanBase = String(config?.baseUrl || "").replace(/\/$/, "");
+      const cleanEp = ep.startsWith("/") ? ep : `/${ep}`;
+      return `${cleanBase}${cleanEp}`;
+    };
+    instance.interceptors.response.use(
+      (response) => handleResponse(response),
+      async (error) => {
+        const handleError3 = async (err) => {
+          if (!err.response) return err;
+          const { data } = err.response;
+          if (data && data.code === 400 && ["invalid_grant"].includes(data.data?.error)) {
+            await clearAuthToken();
+          }
+          return data;
+        };
+        const originalRequest = error.config;
+        if ((error.response?.status === 403 || error.response?.status === 401 || error.response?.status === 404) && ["TOKEN_EXPIRED", "AUTHEN_FAIL", 401, "ERR_2FA_006"].includes(
+          error.response.data.code
+        )) {
+          if (isRefreshing) {
+            return new Promise(function(resolve, reject) {
+              failedQueue.push({ resolve, reject });
+            }).then((newToken) => {
+              originalRequest.headers["Authorization"] = "Bearer " + newToken;
+              originalRequest.data = updateTokenParamInOriginalRequest(
+                originalRequest,
+                newToken
+              );
+              return instance.request(originalRequest);
+            }).catch(async (err) => {
+              if ((err.response?.status === 400 || err.response?.status === 401) && ["invalid_grant"].includes(err.response.data.error)) {
+                await clearAuthToken();
+              }
+            });
+          }
+          const browserSession = await sessionStorage2.getBrowserSession();
+          const refreshToken = await localStorage2.getRefreshToken();
+          const accessTokenExp = await localStorage2.getAccessToken();
+          isRefreshing = true;
+          if (!refreshToken && (!browserSession || browserSession == "unActive")) {
+            await clearAuthToken();
+          } else {
+            const payload = Object.fromEntries(
+              Object.entries({
+                refresh_token: refreshToken,
+                grant_type: "refresh_token",
+                client_id: config.config.clientId,
+                client_secret: config.config.clientSecret
+              }).filter(([_, v]) => !!v)
+            );
+            const refreshUrl = buildRefreshUrl();
+            return new Promise(function(resolve) {
+              axios.post(refreshUrl, payload, {
+                headers: {
+                  "Content-Type": config.refreshTokenEndpoint ? "application/x-www-form-urlencoded" : "multipart/form-data",
+                  Authorization: `Bearer ${accessTokenExp}`
+                }
+              }).then(async (res) => {
+                const data = res.data;
+                await localStorage2.setToken(data.access_token);
+                await localStorage2.setRefreshToken(data.refresh_token);
+                axios.defaults.headers.common["Authorization"] = "Bearer " + data.access_token;
+                originalRequest.headers["Authorization"] = "Bearer " + data.access_token;
+                originalRequest.data = updateTokenParamInOriginalRequest(
+                  originalRequest,
+                  data.access_token
+                );
+                processQueue(null, data.access_token);
+                resolve(instance.request(originalRequest));
+              }).catch(async (err) => {
+                if (err && (err?.error_code === "AUTHEN_FAIL" || err?.error_code === "TOKEN_EXPIRED" || err?.error_code === "TOKEN_INCORRECT" || err?.code === "ERR_2FA_006")) {
+                  await clearAuthToken();
+                }
+                if (err && err.response) {
+                  const { error_code } = err.response?.data || {};
+                  const { code } = err;
+                  if (error_code === "AUTHEN_FAIL" || code === "ERR_2FA_006") {
+                    await clearAuthToken();
+                  }
+                }
+                processQueue(err, null);
+              }).finally(() => {
+                isRefreshing = false;
+              });
+            });
+          }
+        }
+        return Promise.reject(await handleError3(error));
+      }
+    );
     instance.interceptors.response.use(
       (response) => {
         return handleResponse(response);
       },
       async (error) => {
-        const handleError2 = async (error2) => {
+        const handleError3 = async (error2) => {
           if (!error2.response) {
             return error2;
           }
@@ -5943,13 +6038,16 @@ var axiosClient = {
               }).filter(([_, value]) => !!value)
             );
             return new Promise(function(resolve) {
-              const refreshPath = config.refreshTokenEndpoint ? config.refreshTokenEndpoint : `/api/v2${"/authentication/oauth2/token" /* AUTH_TOKEN_PATH */}`;
-              axios.post(`${config?.baseUrl}${refreshPath}`, payload, {
-                headers: {
-                  "Content-Type": config.refreshTokenEndpoint ? "application/x-www-form-urlencoded" : "multipart/form-data",
-                  Authorization: `Bearer ${accessTokenExp}`
+              axios.post(
+                `${config?.baseUrl}${config.refreshTokenEndpoint ?? "/authentication/oauth2/token" /* AUTH_TOKEN_PATH */}`,
+                payload,
+                {
+                  headers: {
+                    "Content-Type": config.refreshTokenEndpoint ? "application/x-www-form-urlencoded" : "multipart/form-data",
+                    Authorization: `Bearer ${accessTokenExp}`
+                  }
                 }
-              }).then(async (res) => {
+              ).then(async (res) => {
                 const data = res.data;
                 await localStorage2.setToken(data.access_token);
                 await localStorage2.setRefreshToken(data.refresh_token);
@@ -5982,7 +6080,7 @@ var axiosClient = {
             });
           }
         }
-        return Promise.reject(await handleError2(error));
+        return Promise.reject(await handleError3(error));
       }
     );
     const handleResponse = (res) => {
@@ -5991,6 +6089,19 @@ var axiosClient = {
       }
       return res;
     };
+    const handleError2 = (error) => {
+      if (error.isAxiosError && error.code === "ECONNABORTED") {
+        console.error("Request Timeout Error:", error);
+        return "Request Timeout Error";
+      } else if (error.isAxiosError && !error.response) {
+        console.error("Network Error:", error);
+        return "Network Error";
+      } else {
+        console.error("Other Error:", error?.response);
+        const errorMessage = error?.response?.data?.message || "An error occurred";
+        return { message: errorMessage, status: error?.response?.status };
+      }
+    };
     const clearAuthToken = async () => {
       await localStorage2.clearToken();
       if (typeof window !== "undefined") {

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@fctc/interface-logic",
-  "version": "3.8.8",
+  "version": "3.8.10",
   "types": "dist/index.d.ts",
   "main": "dist/index.cjs",
   "module": "dist/index.mjs",