retry

import { retry } from "jsr:@ende/async";

function

async function retry<T>(fn: (() => Promise<T>) | (() => T), options?: RetryOptions): Promise<T>

Calls the given (possibly asynchronous) function up to maxAttempts times. Retries as long as the given function throws. If the attempts are exhausted, throws a RetryError with cause set to the inner exception.

The backoff is calculated by multiplying minTimeout with multiplier to the power of the current attempt counter (starting at 0 up to maxAttempts - 1). It is capped at maxTimeout however. How long the actual delay is, depends on jitter.

When jitter is the default value of 1, waits between two attempts for a randomized amount between 0 and the backoff time. With the default options the maximal delay will be 15s = 1s + 2s + 4s + 8s. If all five attempts are exhausted the mean delay will be 9.5s = ½(4s + 15s).

When jitter is 0, waits the full backoff time.

fn: (() => Promise<T>) | (() => T): The function to retry.
options?: RetryOptions: Additional options.

Returns

The promise that resolves with the value returned by the function to retry.

Example: Example configuration 1

import { retry } from "@ende/async/retry";
const req = async () => {
 // some function that throws sometimes
};

// Below resolves to the first non-error result of `req`
const retryPromise = await retry(req, {
 multiplier: 2,
 maxTimeout: 60000,
 maxAttempts: 5,
 minTimeout: 100,
 jitter: 1,
});

Example: Example configuration 2

import { retry } from "@ende/async/retry";
const req = async () => {
 // some function that throws sometimes
};

// Make sure we wait at least 1 minute, but at most 2 minutes
const retryPromise = await retry(req, {
 multiplier: 2.34,
 maxTimeout: 80000,
 maxAttempts: 7,
 minTimeout: 1000,
 jitter: 0.5,
});

Example: Only retry on specific error types

import { retry } from "@ende/async/retry";

class HttpError extends Error {
  status: number;
  constructor(status: number) {
    super(`HTTP ${status}`);
    this.status = status;
  }
}

const req = async () => {
  // some function that throws HttpError
};

// Only retry on 429 (rate limit) or 5xx (server) errors
const retryPromise = await retry(req, {
  isRetriable: (err) =>
    err instanceof HttpError && (err.status === 429 || err.status >= 500),
});

Source