Node, wait and retry api calls that fail

Question

So I fetch an array of urls from api with a rate limit, currently I handle this by adding a timeout to each call like this:

const calls = urls.map((url, i) =>
  new Promise(resolve => setTimeout(resolve, 250 * i))
    .then(() => fetch(url)
  )
);

const data = await Promise.all(calls);

forcing a 250ms wait between each call. This ensures that the rate limit is never exceeded.

---

The thing is, this isn't really necessary. I've tried with 0ms wait time, and most of the cases I have to repeatedly reload the page four or five times before the api starts to return:

{ error: { status: 429, message: 'API rate limit exceeded' } }

and most of the times you only have to wait a second or so before you can safely reload the page and get all data.

A more reasonable approach would be to collect the calls that return 429 (if they do), wait for a set amount of time and then retry them (and perhaps redo this a set amount of times).

Problem, I'm a bit stumped as to how one would go about achieving this?

EDIT:
Just got home and will look through the answers but there seem to have been an assumption made which I don't believe is necessary: The calls does not have to be sequential, they can be fired (and returned) in any order.

Answer 1

The term for what you want is exponential backoff. You can modify your code so that it continues trying on a certain failure condition:

const max_wait = 2000;

async function wait(ms) {
  return new Promise(resolve => {
    setTimeout(resolve, ms);
  });
}

const calls = urls.map(async (url) => {
  let retry = 0, result;

  do {
    if (retry !== 0) { await wait(Math.pow(2, retry); }
    result = await fetch(url);
    retry++;
  } while(result.status !== 429 || (Math.pow(2, retry) > max_wait))

  return result;
}

Or you can try using a library to handle the backoff for you like https://github.com/MathieuTurcotte/node-backoff