@krainovsd/js-helpers 0.19.0-beta.1 → 0.19.0-beta.11

package/lib/cjs/index.cjs

@@ -1757,13 +1757,14 @@ function throttle(func, interval) {
 
 const RESPONSE_DATA_SYMBOL = Symbol("response data");
 const REQUEST_ERROR = {
-    HTTP_ERROR: "http",
-    NETWORK_ERROR: "network",
-    TIMEOUT_ERROR: "timeout",
-    ABORT_ERROR: "abort",
-    VALIDATION_ERROR: "validation",
-    CACHE_ERROR: "cache",
-    UNKNOWN_ERROR: "unknown",
+    Http: "http",
+    Network: "network",
+    Timeout: "timeout",
+    Abort: "abort",
+    Validation: "validation",
+    Cache: "cache",
+    Unknown: "unknown",
+    Disabled: "disabled",
 };
 class OauthState {
     _fetching = false;
@@ -1789,6 +1790,7 @@ function createFetchClient(options) {
     let retries = options.retries;
     let timeout = options.timeout;
     let refetchAfterAuthGlobal = options.refetchAfterAuth;
+    let enabled = options.enabled ?? true;
     function recreate(options) {
         if ("client" in options) {
             client = options.client;
@@ -1808,8 +1810,18 @@ function createFetchClient(options) {
         if ("refetchAfterAuth" in options) {
             refetchAfterAuthGlobal = options.refetchAfterAuth;
         }
+        if ("enabled" in options) {
+            enabled = options.enabled ?? true;
+        }
     }
     async function handleRequest(request) {
+        if (!enabled) {
+            return {
+                response: null,
+                data: new ResponseError({ message: "requests disabled", status: 0 }),
+                error: REQUEST_ERROR.Disabled,
+            };
+        }
         const timeoutController = new AbortController();
         const requestController = new AbortController();
         const requestTimeout = request.timeout ?? timeout;
@@ -1918,12 +1930,12 @@ function createFetchClient(options) {
             if (!response.ok) {
                 if (response.status === 304) {
                     const error = new ResponseError({
-                        message: REQUEST_ERROR.CACHE_ERROR,
+                        message: REQUEST_ERROR.Cache,
                         status: response.status,
                         headers: Object.fromEntries(response.headers.entries()),
                     });
-                    request.onError?.(REQUEST_ERROR.CACHE_ERROR, error);
-                    return { data: error, error: REQUEST_ERROR.CACHE_ERROR, response };
+                    request.onError?.(REQUEST_ERROR.Cache, error);
+                    return { data: error, error: REQUEST_ERROR.Cache, response };
                 }
                 /** if you need observe other than only 401 status, you can override some statuses in after handler middleware to 401 */
                 if (response.status === 401 && refetchAfterAuth) {
@@ -1966,14 +1978,14 @@ function createFetchClient(options) {
                 catch { }
                 const error = new ResponseError({
                     status: response.status,
-                    message: REQUEST_ERROR.HTTP_ERROR,
+                    message: REQUEST_ERROR.Http,
                     description: result,
                     headers: Object.fromEntries(response.headers.entries()),
                 });
-                request.onError?.(REQUEST_ERROR.HTTP_ERROR, error);
+                request.onError?.(REQUEST_ERROR.Http, error);
                 return {
                     data: error,
-                    error: REQUEST_ERROR.HTTP_ERROR,
+                    error: REQUEST_ERROR.Http,
                     response,
                 };
             }
@@ -2042,36 +2054,36 @@ function createFetchClient(options) {
             }
             if (err instanceof TypeError) {
                 const error = new ResponseError({
-                    message: REQUEST_ERROR.NETWORK_ERROR,
+                    message: REQUEST_ERROR.Network,
                     status: 0,
                     description: String(err.message),
                 });
-                request.onError?.(REQUEST_ERROR.NETWORK_ERROR, error);
-                return { data: error, error: REQUEST_ERROR.NETWORK_ERROR, response: null };
+                request.onError?.(REQUEST_ERROR.Network, error);
+                return { data: error, error: REQUEST_ERROR.Network, response: null };
             }
             if (err instanceof Error && err.name === "AbortError") {
                 if (timeoutController.signal.aborted) {
                     const error = new ResponseError({
-                        message: REQUEST_ERROR.TIMEOUT_ERROR,
+                        message: REQUEST_ERROR.Timeout,
                         status: 0,
                     });
-                    request.onError?.(REQUEST_ERROR.TIMEOUT_ERROR, error);
-                    return { data: error, error: REQUEST_ERROR.TIMEOUT_ERROR, response: null };
+                    request.onError?.(REQUEST_ERROR.Timeout, error);
+                    return { data: error, error: REQUEST_ERROR.Timeout, response: null };
                 }
                 const error = new ResponseError({
-                    message: REQUEST_ERROR.ABORT_ERROR,
+                    message: REQUEST_ERROR.Abort,
                     status: 0,
                 });
-                request.onError?.(REQUEST_ERROR.ABORT_ERROR, error);
-                return { data: error, error: REQUEST_ERROR.ABORT_ERROR, response: null };
+                request.onError?.(REQUEST_ERROR.Abort, error);
+                return { data: error, error: REQUEST_ERROR.Abort, response: null };
             }
             const error = new ResponseError({
-                message: REQUEST_ERROR.UNKNOWN_ERROR,
+                message: REQUEST_ERROR.Unknown,
                 status: 0,
                 description: String(err),
             });
-            request.onError?.(REQUEST_ERROR.UNKNOWN_ERROR, error);
-            return { data: error, error: REQUEST_ERROR.UNKNOWN_ERROR, response: null };
+            request.onError?.(REQUEST_ERROR.Unknown, error);
+            return { data: error, error: REQUEST_ERROR.Unknown, response: null };
         }
         finally {
             requestController.abort();
@@ -2112,18 +2124,51 @@ function executeAfterHandlers(handlers, request, response) {
 }
 
 function createOauthProvider(opts = {}) {
-    const { refreshTokenWindowUrl = window.origin, closeObserveSubWindowInterval = 500, waitSubWindow = 8000, loginUrl = undefined, logoutUrl = undefined, clearPageUrl = OAUTH_CLEAR_PAGE_URL, errorPageUrl = OAUTH_ERROR_PAGE_URL, logoutPageUrl = OAUTH_LOGOUT_PAGE_URL, afterClearPageUrl = "/", expiresTokenQueryName = OAUTH_TOKEN_EXPIRES_STORAGE_NAME, tokenStorageName = OAUTH_TOKEN_STORAGE_NAME, expiresTokenStorageName = OAUTH_TOKEN_EXPIRES_STORAGE_NAME, tokenRequest = undefined, forceSetToken = false, } = opts;
+    const { refreshTokenWindowUrl = window.origin, closeObserveSubWindowInterval = 500, waitSubWindow = 15000, loginUrl = undefined, logoutUrl = undefined, clearPageUrl = OAUTH_CLEAR_PAGE_URL, errorPageUrl = OAUTH_ERROR_PAGE_URL, logoutPageUrl = OAUTH_LOGOUT_PAGE_URL, afterClearPageUrl = "/", expiresTokenQueryName = OAUTH_TOKEN_EXPIRES_STORAGE_NAME, tokenStorageName = OAUTH_TOKEN_STORAGE_NAME, expiresTokenStorageName = OAUTH_TOKEN_EXPIRES_STORAGE_NAME, tokenRequest = undefined, forceSetToken = false, subWindow = true, refreshToken = false, } = opts;
     let processing = false;
+    function getExpiresDate(expires) {
+        return Date.now() + (expires - 30) * 1000;
+    }
+    function checkExpires(expires) {
+        return expires != undefined && !Number.isNaN(+expires) && Date.now() < +expires;
+    }
     async function refetchAfterRefreshFlow(request) {
         if (processing) {
-            await beforeHandler(request);
+            await beforeHandlerSetToken(request);
+            return request;
+        }
+        processing = true;
+        if (refreshToken && tokenRequest) {
+            const tokenInfo = await startRefreshFlow();
+            if (tokenInfo == undefined) {
+                if (subWindow) {
+                    await startLoginFlowInSubWindow();
+                }
+                else {
+                    await startLoginFlow();
+                }
+                processing = false;
+                await beforeHandlerSetToken(request);
+                return request;
+            }
+            processing = false;
+            await beforeHandlerSetToken(request);
             return request;
         }
-        void startRefreshFlowInSubWindow();
-        await beforeHandler(request);
+        if (subWindow) {
+            await startLoginFlowInSubWindow();
+        }
+        else {
+            await startLoginFlow();
+        }
+        processing = false;
+        await beforeHandlerSetToken(request);
         return request;
     }
-    async function startRefreshFlowInSubWindow() {
+    function isServicePageCheck() {
+        return [errorPageUrl, clearPageUrl, logoutPageUrl].some((u) => document.location.pathname === u);
+    }
+    async function startLoginFlowInSubWindow() {
         processing = true;
         let waiting = true;
         const url = new URL(typeof refreshTokenWindowUrl === "function" ? refreshTokenWindowUrl() : refreshTokenWindowUrl);
@@ -2165,7 +2210,7 @@ function createOauthProvider(opts = {}) {
             if ("onSubWindowOpenError" in opts)
                 opts.onSubWindowOpenError?.();
             else {
-                startLoginFlow();
+                await startLoginFlow();
             }
             waiting = false;
             return;
@@ -2174,21 +2219,34 @@ function createOauthProvider(opts = {}) {
         processing = false;
     }
     // Trigger an oauth flow through some proxy server
-    function startLoginFlow(loginUrlArg = loginUrl) {
+    async function startLoginFlow(loginUrlArg = loginUrl, delay = 2000) {
         loginUrlArg ??= `/api/v1/auth?frontend_protocol=${window.location.protocol.replace(":", "")}&frontend_host=${window.location.host}&comeback_path=${window.location.pathname}${encodeURIComponent(window.location.search)}`;
         window.location.replace(typeof loginUrlArg === "function" ? loginUrlArg() : loginUrlArg);
+        await wait(delay);
         return null;
     }
     // Trigger an oauth flow through some proxy server
-    function startLogoutFlow(logoutUrlArg = logoutUrl) {
-        logoutUrlArg ??= `/api/v1/auth/logout?frontend_protocol=${window.location.protocol.replace(":", "")}&frontend_host=${window.location.host}&comeback_path=${window.location.pathname}${encodeURIComponent(window.location.search)}`;
+    async function startLogoutFlow(logoutUrlArg = logoutUrl, delay = 2000) {
+        logoutUrlArg ??= `/api/v1/auth/logout?frontend_protocol=${window.location.protocol.replace(":", "")}&frontend_host=${window.location.host}`;
         window.location.replace(typeof logoutUrlArg === "function" ? logoutUrlArg() : logoutUrlArg);
+        await wait(delay);
         return null;
     }
+    async function startRefreshFlow() {
+        const tokenInfo = await tokenRequest?.();
+        if (tokenInfo) {
+            localStorage.setItem(tokenStorageName, tokenInfo.token);
+            if (tokenInfo.expires !== 0) {
+                tokenInfo.expires = getExpiresDate(tokenInfo.expires);
+                localStorage.setItem(expiresTokenStorageName, String(tokenInfo.expires));
+            }
+        }
+        return tokenInfo;
+    }
     // Processing an oauth flow: extract expires, get token, close sub windows, check if logout/clear/error url
     async function register() {
         if (window.location.pathname === logoutPageUrl) {
-            startLogoutFlow();
+            await startLogoutFlow();
             return false;
         }
         if (window.location.pathname === clearPageUrl) {
@@ -2212,30 +2270,29 @@ function createOauthProvider(opts = {}) {
                 ? refreshQuery[refreshQuery.length - 1] === "true"
                 : false;
         /** Expires token */
-        const expires = isString(expiresQuery)
+        const expiresStr = isString(expiresQuery)
             ? expiresQuery
             : isArray(expiresQuery)
                 ? expiresQuery[expiresQuery.length - 1]
-                : false;
-        if (expires && !Number.isNaN(+expires) && Date.now() < +expires) {
-            localStorage.setItem(expiresTokenStorageName, expires);
+                : null;
+        const expires = expiresStr ? getExpiresDate(+expiresStr) : null;
+        if (checkExpires(expires)) {
+            localStorage.setItem(expiresTokenStorageName, String(expires));
             if (tokenRequest) {
-                const token = await tokenRequest();
-                if (token != undefined && tokenStorageName) {
-                    localStorage.setItem(tokenStorageName, token);
+                const tokenInfo = await tokenRequest();
+                if (tokenInfo != undefined) {
+                    localStorage.setItem(tokenStorageName, tokenInfo.token);
                 }
             }
-        }
-        /** Close if OnlyRefresh window  */
-        if (isRefresh) {
-            const channel = new BroadcastChannel(OAUTH_REFRESH_QUERY);
-            channel.postMessage(true);
-            channel.close();
-            window.close();
-            return false;
-        }
-        /** Delete expires query */
-        if (expires) {
+            /** Close if OnlyRefresh window  */
+            if (isRefresh) {
+                const channel = new BroadcastChannel(OAUTH_REFRESH_QUERY);
+                channel.postMessage(true);
+                channel.close();
+                window.close();
+                return false;
+            }
+            /** Delete expires query */
             const url = new URL(window.location.href);
             url.searchParams.delete(expiresTokenQueryName);
             window.location.replace(url.toString());
@@ -2243,7 +2300,16 @@ function createOauthProvider(opts = {}) {
         }
         return true;
     }
-    async function beforeHandler(request) {
+    async function beforeHandlerCheckExpires(request) {
+        if (isServicePageCheck())
+            return;
+        const expires = localStorage.getItem(expiresTokenStorageName);
+        if (checkExpires(expires)) {
+            return;
+        }
+        await refetchAfterRefreshFlow(request);
+    }
+    async function beforeHandlerSetToken(request) {
         if (processing)
             await waitUntil(() => processing);
         const token = request.token ?? localStorage.getItem(tokenStorageName);
@@ -2255,12 +2321,17 @@ function createOauthProvider(opts = {}) {
             };
     }
     return {
-        startRefreshFlowInSubWindow,
+        startRefreshFlow,
+        startLoginFlowInSubWindow,
         startLoginFlow,
         startLogoutFlow,
-        register,
         refetchAfterRefreshFlow,
-        beforeHandler,
+        beforeHandlerSetToken,
+        beforeHandlerCheckExpires,
+        register,
+        get isServicePage() {
+            return isServicePageCheck();
+        },
         get processing() {
             return processing;
         },