RefrshAlgo

import fetchIntercept from 'fetch-intercept';
import { refresh, REFRESH_URL } from '...';

type IDataRequest = {
  [key: string]: Request;
}

export const CreateInterceptors = (() => {
  let instance;

  const init = () => {
    let isRefreshing = false;
    let refreshSubscribers = [];
    let dataRequests = {} as IDataRequest;

    const subscribeTokenRefresh = callback => {
      refreshSubscribers.push(callback);
    };

    const onRefreshed = () => {
      refreshSubscribers.map(callback => callback());
      refreshSubscribers = [];
    };

    const removeDataRequestsItem = requestKey => {
      const { [requestKey]: _omit, ...remaining } = dataRequests;
      dataRequests = remaining;
    };

    const getRelativeUrl = url => url.replace(window.location.origin, '');

    return {
      registerInterceptors: () => {
        fetchIntercept.register({
          request(url, config) {
            if (config && url.indexOf(REFRESH_URL) === -1) {
              dataRequests = {
                ...dataRequests,
                [`${getRelativeUrl(url)}_${config.method || 'GET'}`]: config,
              };
            }
            return [url, config];
          },

          response(response) {
            const requestKey = `${getRelativeUrl(response.url)}_${response.request.method}`;
            if (response.status === 401 && response.url.indexOf(REFRESH_URL) === -1) {
              if (!isRefreshing) {
                isRefreshing = true;
                refresh()
                  .then(() => {
                    isRefreshing = false;
                    onRefreshed();
                  })
                  .catch(() => {

                  })
                  .finally(() => {
                    isRefreshing = false;
                  });
              }
              const retryOrigReq: any = new Promise((resolve, reject) => {
                subscribeTokenRefresh(() => {
                  fetch(response.url, {
                    ...dataRequests[requestKey],
                  })
                    .then(origReqResponse => {
                      resolve(origReqResponse);
                      removeDataRequestsItem(requestKey);
                    })
                    .catch(err => {
                      reject(err);
                    });
                });
              });
              return retryOrigReq;
            }
            removeDataRequestsItem(requestKey);
            return response;
          },
        });
      },
    };
  };

  return {
    getInstance() {
      if (!instance) {
        instance = init();
      }
      return instance;
    },
  };
})();