scoresaber-reloaded/src/network/queues/http-queue.js

import {
  default as createQueue,
  PRIORITY as QUEUE_PRIORITY,
} from "../../utils/queue";
import { SsrError, SsrTimeoutError } from "../../others/errors";
import {
  SsrHttpRateLimitError,
  SsrHttpResponseError,
  SsrNetworkError,
  SsrNetworkTimeoutError,
} from "../errors";
import { fetchHtml, fetchJson } from "../fetch";
import makePendingPromisePool from "../../utils/pending-promises";
import { AbortError } from "../../utils/promise";

const DEFAULT_RETRIES = 2;

export const PRIORITY = {
  FG_HIGH: QUEUE_PRIORITY.HIGHEST,
  FG_LOW: QUEUE_PRIORITY.HIGH,
  BG_HIGH: QUEUE_PRIORITY.NORMAL,
  BG_NORMAL: QUEUE_PRIORITY.LOW,
  BG_LOW: QUEUE_PRIORITY.LOWEST,
};

const resolvePromiseOrWaitForPending = makePendingPromisePool();

export default (options = {}) => {
  const { retries, rateLimitTick, ...queueOptions } = {
    retries: DEFAULT_RETRIES,
    rateLimitTick: 500,
    ...options,
  };
  const queue = createQueue(queueOptions);

  const { add, emitter, ...queueToReturn } = queue;

  let lastRateLimitError = null;
  let rateLimitTimerId = null;
  let currentRateLimit = {
    waiting: 0,
    remaining: null,
    limit: null,
    resetAt: null,
  };

  const rateLimitTicker = () => {
    const expiresInMs =
      lastRateLimitError && lastRateLimitError.resetAt
        ? lastRateLimitError.resetAt - new Date() + 1000
        : 0;
    if (expiresInMs <= 0) {
      emitter.emit("waiting", {
        waiting: 0,
        remaining: null,
        limit: null,
        resetAt: null,
      });

      if (rateLimitTimerId) clearTimeout(rateLimitTimerId);

      return;
    }

    const { remaining, limit, resetAt } = lastRateLimitError;
    emitter.emit("waiting", {
      waiting: expiresInMs,
      remaining,
      limit,
      resetAt,
    });

    if (rateLimitTimerId) clearTimeout(rateLimitTimerId);
    rateLimitTimerId = setTimeout(rateLimitTicker, rateLimitTick);
  };

  const retriedFetch = async (
    fetchFunc,
    url,
    options,
    priority = PRIORITY.FG_LOW
  ) => {
    for (let i = 0; i <= retries; i++) {
      try {
        return await add(async () => {
          if (lastRateLimitError) {
            await lastRateLimitError.waitBeforeRetry();

            lastRateLimitError = null;
          }

          return fetchFunc(url, options)
            .then((response) => {
              currentRateLimit = { ...response.rateLimit, waiting: 0 };

              return response;
            })
            .catch((err) => {
              if (err instanceof SsrTimeoutError)
                throw new SsrNetworkTimeoutError(err.timeout);

              throw err;
            });
        }, priority);
      } catch (err) {
        if (err instanceof SsrHttpResponseError) {
          const { remaining, limit, resetAt } = err;
          currentRateLimit = { waiting: 0, remaining, limit, resetAt };
        }

        if (err instanceof SsrNetworkError) {
          const shouldRetry = err.shouldRetry();
          if (!shouldRetry || i === retries) throw err;

          if (err instanceof SsrHttpRateLimitError) {
            if (
              err.remaining <= 0 &&
              err.resetAt &&
              (!lastRateLimitError ||
                !lastRateLimitError.resetAt ||
                lastRateLimitError.resetAt < err.resetAt)
            ) {
              lastRateLimitError = err;

              rateLimitTicker();
            }
          } else {
            lastRateLimitError = null;
          }
        } else if (!(err instanceof DOMException)) {
          throw err;
        } else {
          throw AbortError();
        }
      }
    }

    throw new SsrError("Unknown error");
  };

  const queuedFetchJson = async (url, options, priority = PRIORITY.FG_LOW) =>
    resolvePromiseOrWaitForPending(url, () =>
      retriedFetch(fetchJson, url, options, priority)
    );
  const queuedFetchHtml = async (url, options, priority = PRIORITY.FG_LOW) =>
    resolvePromiseOrWaitForPending(url, () =>
      retriedFetch(fetchHtml, url, options, priority)
    );

  const getRateLimit = () => currentRateLimit;

  return {
    fetchJson: queuedFetchJson,
    fetchHtml: queuedFetchHtml,
    getRateLimit,
    ...queueToReturn,
  };
};