Retry mechanism about wretch HOT 5 CLOSED

const DEFAULTS = {
  ERROR_CODES : []
};

const reconnectMiddleware = ({
  errorCodes = DEFAULTS.ERROR_CODES
} = {}) => {
  const tracker = new Map();

  errorCodes.map(code => {
    tracker.set(code, new Map());
  });

  return next => (url, options) => {
    const req = next(url, options);

    req.then(response => {
      if (tracker.has(response.status)) {
        if (!response.ok) {
          const requestKey = `${options.method}@${url}`;
          const numberOfAttemptsMade = tracker.get(response.status).get(requestKey) || 0;

          tracker.get(response.status).set(requestKey, numberOfAttemptsMade + 1);

          return new Promise(resolve => {
            const delay = Math.max(DEFAULTS.DELAY * numberOfAttemptsMade, 1000);

            setTimeout(() => {
              resolve(wretch(url)[options.method.toLowerCase()](options));
            }, delay);
          });
        }

        tracker.set(response.status, new Map());
      }

      return response;
    });

    req.catch(response => {
      const requestKey = `${options.method}@${url}`;
      const numberOfAttemptsMade = tracker.get(response.status).get(requestKey) || 0;

      tracker.get(response.status).set(requestKey, numberOfAttemptsMade + 1);

      return new Promise(resolve => {
        const delay = Math.max(DEFAULTS.DELAY * numberOfAttemptsMade, 1000);

        setTimeout(() => {
          resolve(wretch(url)[options.method.toLowerCase()](options));
        }, delay);
      });
    });

    return req;
  };
};

export default reconnectMiddleware;

const DEFAULTS = {
  DELAY: 100,
  MAX_ATTEMPTS: 10,
  ERROR_CODES : []
};

const reconnectMiddleware = ({
  errorCodes = DEFAULTS.ERROR_CODES
} = {}) => {
  const tracker = new Map();

  errorCodes.map(code => {
    tracker.set(code, new Map());
  });

  return next => (url, options) => {
    const checkStatus = (response) => {
        if (tracker.has(response.status)) {
            if (!response.ok) {
                const requestKey = `${options.method}@${url}`;
                const numberOfAttemptsMade = tracker.get(response.status).get(requestKey) || 0;
                tracker.get(response.status).set(requestKey, numberOfAttemptsMade + 1);

                // Maybe add a maximum number of attempts ?
                if(numberOfAttemptsMade >= MAX_ATTEMPTS) 
                    return response

                // We need to recurse until we have a correct response and chain the checks
                return new Promise(resolve => {
                    const delay = Math.min(DEFAULTS.DELAY * numberOfAttemptsMade, 1000);
                    setTimeout(() => {
                        resolve(next(url, options));
                    }, delay);
                }).then(checkStatus);
            }

            // If ok - reset the map and return the response
            tracker.set(response.status, new Map());
            return Promise.resolve(response);
        }
        return response
    }
    // Willingly omitted .catch which prevents handling network errors and should throw
    return next(url, options).then(checkStatus);
  };
};