@krainovsd/js-helpers 0.8.1 → 0.10.0

package/lib/cjs/index.cjs

@@ -20,6 +20,10 @@ const DATE_TYPES = {
 
 const API_MIDDLEWARES = {
     Auth: "auth",
+    AuthNoRefresh: "authNoRefresh",
+    Logger: "logger",
+};
+const POST_API_MIDDLEWARES = {
     Logger: "logger",
 };
 
@@ -1317,6 +1321,76 @@ function transformData(data, pathToToken, pathToTokenExpires) {
         token,
     };
 }
+async function getAuthTokenNoRefresh(options) {
+    let waiting = true;
+    const url = new URL(window.origin);
+    url.searchParams.append(options.queryTokenExpiresName, "true");
+    let windowInstance = window.open(url.toString(), "_blank", "width=800,height=600,left=100,top=100");
+    if (!windowInstance) {
+        windowInstance = window.open(url.toString());
+    }
+    if (!windowInstance) {
+        if (options.onWindowOpenError)
+            options.onWindowOpenError();
+        return;
+    }
+    const channel = new BroadcastChannel(options.queryIsRefreshTokenName);
+    channel.onmessage = () => {
+        if (waiting) {
+            waiting = false;
+            channel.close();
+        }
+    };
+    setTimeout(() => {
+        if (waiting) {
+            waiting = false;
+            channel.close();
+        }
+        if (windowInstance && !windowInstance.closed) {
+            windowInstance.close();
+        }
+    }, 15000);
+    await waitUntil(() => waiting);
+}
+async function updateAuthTokenNoRefresh(options) {
+    let expires = localStorage.getItem(options.storageTokenExpiresName);
+    if (expires && !Number.isNaN(+expires) && Date.now() > +expires)
+        expires = null;
+    let hasExpiresQuery = false;
+    if (!expires) {
+        const queries = window.location.search.substring(1).split("&");
+        for (const query of queries) {
+            const [key, value] = query.split("=");
+            if (key === options.queryTokenExpiresName && value) {
+                expires = value;
+                hasExpiresQuery = true;
+                break;
+            }
+        }
+        if (expires && !Number.isNaN(+expires) && Date.now() > +expires)
+            expires = null;
+    }
+    if (!expires) {
+        return void window.location.replace(options.authUrl());
+    }
+    localStorage.setItem(options.storageTokenExpiresName, expires);
+    const queries = window.location.search.substring(1).split("&");
+    for (const query of queries) {
+        const [key, value] = query.split("=");
+        if (key === options.queryIsRefreshTokenName && value === "true") {
+            const channel = new BroadcastChannel(options.queryIsRefreshTokenName);
+            channel.postMessage(true);
+            channel.close();
+            window.close();
+        }
+    }
+    if (hasExpiresQuery) {
+        const url = new URL(window.location.href);
+        url.searchParams.delete(options.queryTokenExpiresName);
+        window.location.replace(url.toString());
+        await wait(300);
+    }
+}
 
 async function updateAuthUser(options) {
     const userInfo = await (options.userRequest ? options.userRequest() : getAuthUser(options));
@@ -1348,7 +1422,7 @@ async function getAuthUser(options) {
     }
 }
 
-let isFetchingAccessToken = false;
+let isFetchingAccessToken$1 = false;
 const generateAuthMiddleWare = (options) => async (request) => {
     if (!options.authTokenUrl ||
         !options.authUrl ||
@@ -1368,14 +1442,14 @@ const generateAuthMiddleWare = (options) => async (request) => {
             };
         return;
     }
-    if (isFetchingAccessToken)
-        await waitUntil(() => isFetchingAccessToken);
+    if (isFetchingAccessToken$1)
+        await waitUntil(() => isFetchingAccessToken$1);
     const expires = localStorage.getItem(options.storageTokenExpiresName);
     let token = localStorage.getItem(options.storageTokenName);
     if (!expires || Date.now() > +expires || !token) {
-        isFetchingAccessToken = true;
+        isFetchingAccessToken$1 = true;
         token = await (options.tokenRequest ? options.tokenRequest() : getAuthToken(options));
-        isFetchingAccessToken = false;
+        isFetchingAccessToken$1 = false;
         if (isNull(token)) {
             return void window.location.replace(options.authUrl());
         }
@@ -1390,14 +1464,100 @@ const generateAuthMiddleWare = (options) => async (request) => {
         };
 };
 
-const consoleMiddleware = (response) => {
-    return new Promise((resolve) => {
-        // eslint-disable-next-line no-console
-        console.log(response);
-        resolve(true);
-    });
+let isFetchingAccessToken = false;
+const generateAuthNoRefreshMiddleWare = (options) => async (request) => {
+    if (!options.authUrl || !options.storageTokenExpiresName || !options.errorUrl) {
+        throw new Error("Auth middleware hasn't required options");
+    }
+    const isSameOrigin = !startWith(request.path, "http");
+    if (request.token) {
+        if (!isSameOrigin)
+            request.headers = {
+                ...request.headers,
+                Authorization: `Bearer ${request.token}`,
+            };
+        return;
+    }
+    if (isFetchingAccessToken)
+        await waitUntil(() => isFetchingAccessToken);
+    const expires = localStorage.getItem(options.storageTokenExpiresName);
+    if (!expires) {
+        isFetchingAccessToken = true;
+        await (options.tokenRequest ? options.tokenRequest() : getAuthTokenNoRefresh(options));
+        isFetchingAccessToken = false;
+    }
+    const token = options.storageTokenName ? localStorage.getItem(options.storageTokenName) : null;
+    if (!isSameOrigin && token)
+        request.headers = {
+            ...request.headers,
+            Authorization: `Bearer ${token}`,
+        };
 };
 
+function generateConsoleMiddleware(options = {}) {
+    return (request) => {
+        return new Promise((resolve) => {
+            if ((options.filter &&
+                !options.filter(request)) ||
+                (options.filterHeaders && !options.filterHeaders(request.headers)) ||
+                (options.filterMethod && !options.filterMethod(request.method)) ||
+                (options.filterParams && !options.filterParams(request.params)) ||
+                (options.filterPath && !options.filterPath(request.path))) {
+                resolve(true);
+                return;
+            }
+            // eslint-disable-next-line no-console
+            console.log(request);
+            resolve(true);
+        });
+    };
+}
+
+function generateConsolePostMiddleware(options = {}) {
+    return (response) => {
+        return new Promise((resolve) => {
+            void (async function logger() {
+                try {
+                    if (!response ||
+                        (options.filter && !options.filter(response)) ||
+                        (options.filterStatus && !options.filterStatus(response.status)) ||
+                        (options.filterUrl && !options.filterUrl(response.url)) ||
+                        (options.filterHeaders && !options.filterHeaders(response.headers))) {
+                        resolve(true);
+                        return;
+                    }
+                    const contentType = response.headers.get("content-type");
+                    let result;
+                    if (contentType?.includes?.("text")) {
+                        result = await response.text();
+                    }
+                    else if (contentType?.includes?.("json")) {
+                        result = await response.json();
+                    }
+                    else {
+                        result = await response.blob();
+                    }
+                    console.log({
+                        url: response.url,
+                        status: response.status,
+                        headers: response.headers,
+                        body: result,
+                    });
+                    resolve(true);
+                }
+                catch {
+                    if (response) {
+                        console.log({ url: response.url, status: response.status, headers: response.headers });
+                    }
+                    resolve(true);
+                }
+            })().finally(() => {
+                resolve(true);
+            });
+        });
+    };
+}
+
 function generateMiddlewares(activeMiddlewares, middlewareOptions, customMiddlewares) {
     const selectedMiddlewares = customMiddlewares;
     for (const key of activeMiddlewares) {
@@ -1407,8 +1567,13 @@ function generateMiddlewares(activeMiddlewares, middlewareOptions, customMiddlew
                     selectedMiddlewares.push(generateAuthMiddleWare(middlewareOptions.auth));
                 continue;
             }
+            case API_MIDDLEWARES.AuthNoRefresh: {
+                if (middlewareOptions.authNoRefresh && (IS_BROWSER || IS_JEST))
+                    selectedMiddlewares.push(generateAuthNoRefreshMiddleWare(middlewareOptions.authNoRefresh));
+                continue;
+            }
             case API_MIDDLEWARES.Logger: {
-                selectedMiddlewares.push(consoleMiddleware);
+                selectedMiddlewares.push(generateConsoleMiddleware(middlewareOptions.logger));
                 continue;
             }
             default: {
@@ -1428,6 +1593,31 @@ function generateMiddlewares(activeMiddlewares, middlewareOptions, customMiddlew
         });
     };
 }
+function generatePostMiddlewares(activePostMiddlewares, postMiddlewaresOptions, customPostMiddlewares) {
+    const selectedMiddlewares = customPostMiddlewares;
+    for (const key of activePostMiddlewares) {
+        switch (key) {
+            case POST_API_MIDDLEWARES.Logger: {
+                selectedMiddlewares.push(generateConsolePostMiddleware(postMiddlewaresOptions.logger));
+                continue;
+            }
+            default: {
+                continue;
+            }
+        }
+    }
+    return function executeMiddlewares(response) {
+        return new Promise((resolve) => {
+            void (async () => {
+                for (const middleware of selectedMiddlewares) {
+                    // eslint-disable-next-line no-await-in-loop
+                    await middleware(response);
+                }
+                resolve(1);
+            })();
+        });
+    };
+}
 
 class ResponseError extends Error {
     status;
@@ -1438,8 +1628,14 @@ class ResponseError extends Error {
         this.description = description;
     }
 }
-function createRequestClientInstance({ activeMiddlewares, middlewareOptions, customMiddlewares, } = {}) {
-    const executeMiddlewares = generateMiddlewares(activeMiddlewares || [], middlewareOptions || {}, customMiddlewares || []);
+function createRequestClientInstance(options = {}) {
+    let executeMiddlewares;
+    let executePostMiddlewares;
+    function setMiddlewares({ activeMiddlewares = [], middlewareOptions = {}, customMiddlewares = [], activePostMiddlewares = [], postMiddlewaresOptions = {}, customPostMiddlewares = [], } = {}) {
+        executeMiddlewares = generateMiddlewares(activeMiddlewares, middlewareOptions, customMiddlewares);
+        executePostMiddlewares = generatePostMiddlewares(activePostMiddlewares, postMiddlewaresOptions, customPostMiddlewares);
+    }
+    setMiddlewares(options);
     async function handleRequest(request, responseWithStatus) {
         if (request.delay) {
             await wait(request.delay);
@@ -1491,13 +1687,29 @@ function createRequestClientInstance({ activeMiddlewares, middlewareOptions, cus
                 signal: request.signal,
             });
         }
+        await executePostMiddlewares(response);
         if (!response) {
             throw new Error("hasn't response");
         }
         if (!response.ok) {
+            let result;
+            try {
+                const contentType = response.headers.get("content-type");
+                if (contentType?.includes?.("text")) {
+                    result = await response.text();
+                }
+                else if (contentType?.includes?.("json")) {
+                    result = await response.json();
+                }
+                else {
+                    result = await response.blob();
+                }
+            }
+            catch { }
             throw new ResponseError({
                 status: response.status,
                 message: `HTTP error! Status: ${response.status}`,
+                description: result,
             });
         }
         if (request.downloadFile) {
@@ -1559,6 +1771,7 @@ function createRequestClientInstance({ activeMiddlewares, middlewareOptions, cus
     return {
         requestApi,
         requestApiWithMeta,
+        setMiddlewares,
     };
 }
 
@@ -1654,6 +1867,7 @@ exports.IS_DENO = IS_DENO;
 exports.IS_JEST = IS_JEST;
 exports.IS_NODE = IS_NODE;
 exports.IS_WEB_WORKER = IS_WEB_WORKER;
+exports.POST_API_MIDDLEWARES = POST_API_MIDDLEWARES;
 exports.ResponseError = ResponseError;
 exports.arrayToMapByKey = arrayToMapByKey;
 exports.buildQueryString = buildQueryString;
@@ -1666,6 +1880,7 @@ exports.downloadFile = downloadFile;
 exports.downloadJson = downloadJson;
 exports.fieldViewFormat = fieldViewFormat;
 exports.getAuthToken = getAuthToken;
+exports.getAuthTokenNoRefresh = getAuthTokenNoRefresh;
 exports.getAuthUser = getAuthUser;
 exports.getByPath = getByPath;
 exports.getCallerFunctionName = getCallerFunctionName;
@@ -1708,6 +1923,7 @@ exports.transformToNumber = transformToNumber;
 exports.translit = translit;
 exports.trimUrl = trimUrl;
 exports.updateAuthToken = updateAuthToken;
+exports.updateAuthTokenNoRefresh = updateAuthTokenNoRefresh;
 exports.updateAuthUser = updateAuthUser;
 exports.wait = wait;
 exports.waitUntil = waitUntil;