@krainovsd/js-helpers 0.18.1 → 0.19.0-beta.10

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;
@@ -1778,132 +1779,22 @@ const OAUTH_STATE = new OauthState();
 const OAUTH_TOKEN_STORAGE_NAME = "session_token";
 const OAUTH_TOKEN_EXPIRES_STORAGE_NAME = "session_token_expires";
 const OAUTH_REFRESH_QUERY = "only_session_refresh";
-
-async function getOauthTokenFromOtherWindow(options) {
-    let waiting = true;
-    const url = new URL(typeof options.refreshTokenWindowUrl === "function"
-        ? options.refreshTokenWindowUrl()
-        : (options.refreshTokenWindowUrl ?? window.origin));
-    // added only refresh tag to autoclose window after flow
-    url.searchParams.append(options.onlyRefreshTokenWindowQueryName ?? OAUTH_REFRESH_QUERY, "true");
-    // try open window with both of action
-    let windowInstance = window.open(url.toString(), "_blank", "width=800,height=600,left=100,top=100");
-    windowInstance ??= window.open(url.toString(), "_blank");
-    if (windowInstance) {
-        const channel = new BroadcastChannel(options.onlyRefreshTokenWindowQueryName ?? OAUTH_REFRESH_QUERY);
-        const windowCloseObserver = setInterval(() => {
-            if (windowInstance.closed) {
-                if (waiting) {
-                    waiting = false;
-                    channel.close();
-                    clearInterval(windowCloseObserver);
-                }
-            }
-        }, options.closeObserveInterval ?? 500);
-        channel.onmessage = () => {
-            if (waiting) {
-                waiting = false;
-                channel.close();
-                clearInterval(windowCloseObserver);
-            }
-        };
-        setTimeout(() => {
-            if (waiting) {
-                waiting = false;
-                channel.close();
-                clearInterval(windowCloseObserver);
-            }
-            if (windowInstance && !windowInstance.closed) {
-                windowInstance.close();
-            }
-        }, options.wait ?? 8000);
-    }
-    else {
-        if ("onWindowOpenError" in options)
-            options.onWindowOpenError?.();
-        else {
-            getOauthToken(options.oauthUrl);
-        }
-        waiting = false;
-        return;
-    }
-    await waitUntil(() => waiting);
-}
-async function refetchAfterOauth(options, refetch) {
-    OAUTH_STATE.fetching = true;
-    await getOauthTokenFromOtherWindow({
-        onlyRefreshTokenWindowQueryName: options.onlyRefreshTokenWindowQueryName,
-        onWindowOpenError: options.onWindowOpenError,
-        refreshTokenWindowUrl: options.refreshTokenWindowUrl,
-        wait: options.wait,
-        closeObserveInterval: options.closeObserveInterval,
-    });
-    OAUTH_STATE.fetching = false;
-    return await refetch();
-}
-// Trigger an oauth flow through some proxy server
-function getOauthToken(oauthUrl) {
-    oauthUrl ??= `/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 oauthUrl === "function" ? oauthUrl() : oauthUrl);
-    return null;
-}
-// Processing an oauth flow: extract expires, get token, close sub windows
-async function applyOauthProvider(options = {}) {
-    const { expiresTokenQueryName = OAUTH_TOKEN_EXPIRES_STORAGE_NAME, onlyRefreshTokenWindowQueryName = OAUTH_REFRESH_QUERY, tokenStorageName = OAUTH_TOKEN_STORAGE_NAME, expiresTokenStorageName = OAUTH_TOKEN_EXPIRES_STORAGE_NAME, tokenRequest = undefined, } = options;
-    const queries = getQueryValues([expiresTokenQueryName, onlyRefreshTokenWindowQueryName]);
-    const refreshQuery = queries?.[onlyRefreshTokenWindowQueryName];
-    const expiresQuery = queries?.[expiresTokenQueryName];
-    /** Is OnlyRefresh window */
-    const isRefresh = isString(refreshQuery)
-        ? refreshQuery === "true"
-        : isArray(refreshQuery)
-            ? refreshQuery[refreshQuery.length - 1] === "true"
-            : false;
-    /** Expires token */
-    const expires = isString(expiresQuery)
-        ? expiresQuery
-        : isArray(expiresQuery)
-            ? expiresQuery[expiresQuery.length - 1]
-            : false;
-    if (expires && !Number.isNaN(+expires) && Date.now() < +expires) {
-        localStorage.setItem(expiresTokenStorageName, expires);
-        if (tokenRequest) {
-            const token = await tokenRequest();
-            if (token != undefined && tokenStorageName) {
-                localStorage.setItem(tokenStorageName, token);
-            }
-        }
-    }
-    /** Close if OnlyRefresh window  */
-    if (isRefresh) {
-        const channel = new BroadcastChannel(onlyRefreshTokenWindowQueryName);
-        channel.postMessage(true);
-        channel.close();
-        window.close();
-    }
-    /** Delete expires query */
-    if (expires) {
-        const url = new URL(window.location.href);
-        url.searchParams.delete(expiresTokenQueryName);
-        window.location.replace(url.toString());
-    }
-}
+const OAUTH_ERROR_PAGE_URL = "/error";
+const OAUTH_CLEAR_PAGE_URL = "/clear";
+const OAUTH_LOGOUT_PAGE_URL = "/logout";
 
 function createFetchClient(options) {
     let client = options.client;
-    let oauthOptions = options.oauthOptions;
     let beforeHandlers = options.beforeHandlers;
     let afterHandlers = options.afterHandlers;
     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;
         }
-        if ("oauthOptions" in options) {
-            oauthOptions = options.oauthOptions;
-        }
         if ("beforeHandlers" in options) {
             beforeHandlers = options.beforeHandlers;
         }
@@ -1919,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;
@@ -1968,7 +1869,7 @@ function createFetchClient(options) {
                     await executeBeforeHandlers(handlers, request);
                 }
             }
-            const { method, body, path, queries, headers = {}, refetchAfterOauth: refetchAfterOauth$1 = true } = request;
+            const { method, body, path, queries, headers = {} } = request;
             let refetchAfterAuth = refetchAfterAuthGlobal;
             if ("refetchAfterAuth" in request) {
                 refetchAfterAuth = request.refetchAfterAuth;
@@ -2029,19 +1930,14 @@ 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 };
-                }
-                if ((oauthOptions?.responseStatusesForOauth?.includes(response.status) ||
-                    (!oauthOptions?.responseStatusesForOauth && response.status === 401)) &&
-                    oauthOptions &&
-                    refetchAfterOauth$1) {
-                    return await refetchAfterOauth(oauthOptions, () => handleRequest({ ...request, refetchAfterOauth: false }));
+                    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) {
                     const newRequest = await refetchAfterAuth(request);
                     return await handleRequest({ ...newRequest, refetchAfterAuth: false });
@@ -2082,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,
                 };
             }
@@ -2158,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();
@@ -2227,6 +2123,228 @@ function executeAfterHandlers(handlers, request, response) {
     });
 }
 
+function createOauthProvider(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 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;
+        }
+        if (subWindow) {
+            await startLoginFlowInSubWindow();
+        }
+        else {
+            await startLoginFlow();
+        }
+        processing = false;
+        await beforeHandlerSetToken(request);
+        return request;
+    }
+    async function startLoginFlowInSubWindow() {
+        processing = true;
+        let waiting = true;
+        const url = new URL(typeof refreshTokenWindowUrl === "function" ? refreshTokenWindowUrl() : refreshTokenWindowUrl);
+        // added only refresh tag to autoclose window after flow
+        url.searchParams.append(OAUTH_REFRESH_QUERY, "true");
+        // try open window with both of action
+        let windowInstance = window.open(url.toString(), "_blank", "width=800,height=600,left=100,top=100");
+        windowInstance ??= window.open(url.toString(), "_blank");
+        if (windowInstance) {
+            const channel = new BroadcastChannel(OAUTH_REFRESH_QUERY);
+            const windowCloseObserver = setInterval(() => {
+                if (windowInstance.closed) {
+                    if (waiting) {
+                        waiting = false;
+                        channel.close();
+                        clearInterval(windowCloseObserver);
+                    }
+                }
+            }, closeObserveSubWindowInterval);
+            channel.onmessage = () => {
+                if (waiting) {
+                    waiting = false;
+                    channel.close();
+                    clearInterval(windowCloseObserver);
+                }
+            };
+            setTimeout(() => {
+                if (waiting) {
+                    waiting = false;
+                    channel.close();
+                    clearInterval(windowCloseObserver);
+                }
+                if (windowInstance && !windowInstance.closed) {
+                    windowInstance.close();
+                }
+            }, waitSubWindow);
+        }
+        else {
+            if ("onSubWindowOpenError" in opts)
+                opts.onSubWindowOpenError?.();
+            else {
+                await startLoginFlow();
+            }
+            waiting = false;
+            return;
+        }
+        await waitUntil(() => waiting);
+        processing = false;
+    }
+    // Trigger an oauth flow through some proxy server
+    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
+    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) {
+            await startLogoutFlow();
+            return false;
+        }
+        if (window.location.pathname === clearPageUrl) {
+            localStorage.removeItem(expiresTokenStorageName);
+            localStorage.removeItem(tokenStorageName);
+            window.location.replace(afterClearPageUrl);
+            return false;
+        }
+        if (window.location.pathname === errorPageUrl) {
+            localStorage.removeItem(expiresTokenStorageName);
+            localStorage.removeItem(tokenStorageName);
+            return false;
+        }
+        const queries = getQueryValues([expiresTokenQueryName, OAUTH_REFRESH_QUERY]);
+        const refreshQuery = queries?.[OAUTH_REFRESH_QUERY];
+        const expiresQuery = queries?.[expiresTokenQueryName];
+        /** Is OnlyRefresh window */
+        const isRefresh = isString(refreshQuery)
+            ? refreshQuery === "true"
+            : isArray(refreshQuery)
+                ? refreshQuery[refreshQuery.length - 1] === "true"
+                : false;
+        /** Expires token */
+        const expiresStr = isString(expiresQuery)
+            ? expiresQuery
+            : isArray(expiresQuery)
+                ? expiresQuery[expiresQuery.length - 1]
+                : null;
+        const expires = expiresStr ? getExpiresDate(+expiresStr) : null;
+        if (checkExpires(expires)) {
+            localStorage.setItem(expiresTokenStorageName, String(expires));
+            if (tokenRequest) {
+                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 */
+            const url = new URL(window.location.href);
+            url.searchParams.delete(expiresTokenQueryName);
+            window.location.replace(url.toString());
+            return false;
+        }
+        return true;
+    }
+    async function beforeHandlerCheckExpires(request) {
+        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);
+        const isSameOrigin = request.path.includes(window.location.origin) || !startWith(request.path, "http");
+        if ((!isSameOrigin || forceSetToken) && token)
+            request.headers = {
+                ...request.headers,
+                Authorization: `Bearer ${token}`,
+            };
+    }
+    return {
+        startRefreshFlow,
+        startLoginFlowInSubWindow,
+        startLoginFlow,
+        startLogoutFlow,
+        refetchAfterRefreshFlow,
+        beforeHandlerSetToken,
+        beforeHandlerCheckExpires,
+        register,
+        get isServicePage() {
+            return [errorPageUrl, clearPageUrl, logoutPageUrl].some((u) => document.location.pathname === u);
+        },
+        get processing() {
+            return processing;
+        },
+        get token() {
+            return localStorage.getItem(tokenStorageName);
+        },
+        get expires() {
+            const expires = localStorage.getItem(expiresTokenStorageName);
+            return expires == undefined ? null : Number.isNaN(+expires) ? null : +expires;
+        },
+        get expired() {
+            const expiresStr = localStorage.getItem(expiresTokenStorageName);
+            const expires = expiresStr == undefined ? null : Number.isNaN(+expiresStr) ? null : +expiresStr;
+            return expires == undefined ? true : Date.now() > expires;
+        },
+    };
+}
+
 function loggerAfterHandler(options = {}) {
     return (request, response) => {
         return new Promise((resolve) => {
@@ -2297,19 +2415,6 @@ function loggerBeforeHandler(options = {}) {
     };
 }
 
-const authBeforeHandler = (options = {}) => async (request) => {
-    const { tokenStorageName = OAUTH_TOKEN_STORAGE_NAME, forceSetToken = false } = options;
-    if (OAUTH_STATE.fetching)
-        await waitUntil(() => OAUTH_STATE.fetching);
-    const token = request.token ?? localStorage.getItem(tokenStorageName);
-    const isSameOrigin = request.path.includes(window.location.origin) || !startWith(request.path, "http");
-    if ((!isSameOrigin || forceSetToken) && token)
-        request.headers = {
-            ...request.headers,
-            Authorization: `Bearer ${token}`,
-        };
-};
-
 exports.COLOR_FORMATS = COLOR_FORMATS;
 exports.DATE_TYPES = DATE_TYPES;
 exports.FIELD_TYPES = FIELD_TYPES;
@@ -2319,6 +2424,9 @@ exports.IS_DENO = IS_DENO;
 exports.IS_JEST = IS_JEST;
 exports.IS_NODE = IS_NODE;
 exports.IS_WEB_WORKER = IS_WEB_WORKER;
+exports.OAUTH_CLEAR_PAGE_URL = OAUTH_CLEAR_PAGE_URL;
+exports.OAUTH_ERROR_PAGE_URL = OAUTH_ERROR_PAGE_URL;
+exports.OAUTH_LOGOUT_PAGE_URL = OAUTH_LOGOUT_PAGE_URL;
 exports.OAUTH_REFRESH_QUERY = OAUTH_REFRESH_QUERY;
 exports.OAUTH_STATE = OAUTH_STATE;
 exports.OAUTH_TOKEN_EXPIRES_STORAGE_NAME = OAUTH_TOKEN_EXPIRES_STORAGE_NAME;
@@ -2326,10 +2434,8 @@ exports.OAUTH_TOKEN_STORAGE_NAME = OAUTH_TOKEN_STORAGE_NAME;
 exports.REQUEST_ERROR = REQUEST_ERROR;
 exports.RESPONSE_DATA_SYMBOL = RESPONSE_DATA_SYMBOL;
 exports.ResponseError = ResponseError;
-exports.applyOauthProvider = applyOauthProvider;
 exports.arrayToMapByKey = arrayToMapByKey;
 exports.asyncLoop = asyncLoop;
-exports.authBeforeHandler = authBeforeHandler;
 exports.buildQueryString = buildQueryString;
 exports.checkType = checkType;
 exports.cloneDeep = cloneDeep;
@@ -2337,6 +2443,7 @@ exports.copyToClipboard = copyToClipboard;
 exports.createFetchClient = createFetchClient;
 exports.createGlobalId = createGlobalId;
 exports.createLocalIdGenerator = createLocalIdGenerator;
+exports.createOauthProvider = createOauthProvider;
 exports.createURLWithQueries = createURLWithQueries;
 exports.dateDifference = dateDifference;
 exports.dateFormat = dateFormat;
@@ -2355,8 +2462,6 @@ exports.getCallerFunctionName = getCallerFunctionName;
 exports.getColorFormat = getColorFormat;
 exports.getDateByRules = getDateByRules;
 exports.getFileNameFromHeader = getFileNameFromHeader;
-exports.getOauthToken = getOauthToken;
-exports.getOauthTokenFromOtherWindow = getOauthTokenFromOtherWindow;
 exports.getQueryValues = getQueryValues;
 exports.getRandomColor = getRandomColor;
 exports.getToday = getToday;
@@ -2384,7 +2489,6 @@ exports.randomHex = randomHex;
 exports.randomNumber = randomNumber;
 exports.randomString = randomString;
 exports.readFile = readFile;
-exports.refetchAfterOauth = refetchAfterOauth;
 exports.setByPath = setByPath;
 exports.speedTest = speedTest;
 exports.startWith = startWith;