retry

Retry an async function when it fails

Usage

The retry function runs an async function and retries it if it fails. You can specify how many times to retry, how long to wait between retries, and whether to use exponential backoff.

Options

times is the maximum number of times to retry (default: 3)
delay is milliseconds to sleep between retries
backoff is a function called to calculate the delay between retries
- It receives the attempt number (starting with 1) and returns the delay in milliseconds.
signal (v12.3.0+) allows you to pass an AbortController.signal to interrupt the retry operation

import * as 
import _
_ from 'radashi'

const 
const api: {
    users: {
        list(): Promise<never[]>;
    };
}
api = {
  
users: {
    list(): Promise<never[]>;
}
users: {
    async 
function list(): Promise<never[]>
list() {
      if (
var Math: Math
An intrinsic object that provides basic mathematics functionality and constants.
Math.
Math.random(): number
Returns a pseudorandom number between 0 and 1.
random() < 0.5) {
        throw new 
var Error: ErrorConstructor
new (message?: string) => Error
Error('Random error')
      }
      return []
    },
  },
}

await 
import _
_.
retry<never[]>(options: _.RetryOptions, func: (exit: (err: any) => void) => Promise<never[]>): Promise<never[]>
export retry
Retries the given function the specified number of times.
@see ― https://radashi.js.org/reference/async/retry
@example 
const abortController = new AbortController();
const result = await retry({ times: 3, delay: 1000, signal: abortController.signal }, async () => {
  return await fetch('https://example.com')
})
// To abort the operation:
// abortController.abort()
@version ― 12.1.0
retry({}, 
const api: {
    users: {
        list(): Promise<never[]>;
    };
}
api.
users: {
    list(): Promise<never[]>;
}
users.
function list(): Promise<never[]>
list) // try 3 times before failing
await 
import _
_.
retry<never[]>(options: _.RetryOptions, func: (exit: (err: any) => void) => Promise<never[]>): Promise<never[]>
export retry
Retries the given function the specified number of times.
@see ― https://radashi.js.org/reference/async/retry
@example 
const abortController = new AbortController();
const result = await retry({ times: 3, delay: 1000, signal: abortController.signal }, async () => {
  return await fetch('https://example.com')
})
// To abort the operation:
// abortController.abort()
@version ― 12.1.0
retry({ 
times?: number
times: 10 }, 
const api: {
    users: {
        list(): Promise<never[]>;
    };
}
api.
users: {
    list(): Promise<never[]>;
}
users.
function list(): Promise<never[]>
list) // try 10 times before failing
await 
import _
_.
retry<never[]>(options: _.RetryOptions, func: (exit: (err: any) => void) => Promise<never[]>): Promise<never[]>
export retry
Retries the given function the specified number of times.
@see ― https://radashi.js.org/reference/async/retry
@example 
const abortController = new AbortController();
const result = await retry({ times: 3, delay: 1000, signal: abortController.signal }, async () => {
  return await fetch('https://example.com')
})
// To abort the operation:
// abortController.abort()
@version ― 12.1.0
retry({ 
times?: number
times: 2, 
delay?: number | null
delay: 1000 }, 
const api: {
    users: {
        list(): Promise<never[]>;
    };
}
api.
users: {
    list(): Promise<never[]>;
}
users.
function list(): Promise<never[]>
list) // try 2 times with 1 second delay

// exponential backoff
await 
import _
_.
retry<never[]>(options: _.RetryOptions, func: (exit: (err: any) => void) => Promise<never[]>): Promise<never[]>
export retry
Retries the given function the specified number of times.
@see ― https://radashi.js.org/reference/async/retry
@example 
const abortController = new AbortController();
const result = await retry({ times: 3, delay: 1000, signal: abortController.signal }, async () => {
  return await fetch('https://example.com')
})
// To abort the operation:
// abortController.abort()
@version ― 12.1.0
retry({ 
backoff?: (count: number) => number
backoff: 
i: number
i => 10 ** 
i: number
i }, 
const api: {
    users: {
        list(): Promise<never[]>;
    };
}
api.
users: {
    list(): Promise<never[]>;
}
users.
function list(): Promise<never[]>
list) // try 3 times with 10, 100, 1000 ms delay

Interrupting

If a signal is passed, the retry operation can be interrupted. When the signal is aborted, retry’s promise will reject with a DOMException (even in Node.js) with the message This operation was aborted and name AbortError.

import * as 
import _
_ from 'radashi'


const 
const abortController: AbortController
abortController = new 
var AbortController: new () => AbortController
A controller object that allows you to abort one or more DOM requests as and when desired.
AbortController()
const 
const signal: AbortSignal
signal = 
const abortController: AbortController
abortController.
AbortController.signal: AbortSignal
Returns the AbortSignal object associated with this object.
signal

const 
const promise: Promise<never[]>
promise = 
import _
_.
retry<never[]>(options: _.RetryOptions, func: (exit: (err: any) => void) => Promise<never[]>): Promise<never[]>
export retry
Retries the given function the specified number of times.
@see ― https://radashi.js.org/reference/async/retry
@example 
const abortController = new AbortController();
const result = await retry({ times: 3, delay: 1000, signal: abortController.signal }, async () => {
  return await fetch('https://example.com')
})
// To abort the operation:
// abortController.abort()
@version ― 12.1.0
retry({ 
times?: number
times: 3, 
delay?: number | null
delay: 1000, 
signal?: AbortSignal
signal }, 
const api: {
    users: {
        list(): Promise<never[]>;
    };
}
api.
users: {
    list(): Promise<never[]>;
}
users.
function list(): Promise<never[]>
list)

// To stop retrying immediately:
const abortController: AbortController
abortController.
AbortController.abort(reason?: any): void
Invoking this method will set this object's AbortSignal's aborted flag and signal to any observers that the associated activity is to be aborted.
abort()

try {
  await 
const promise: Promise<never[]>
promise
} catch (
var err: unknown
err) {
  if (
var err: unknown
err.
any
message === 'This operation was aborted') {
    
var console: Console
The console module provides a simple debugging console that is similar to the
JavaScript console mechanism provided by web browsers.
The module exports two specific components:

A Console class with methods such as console.log(), console.error() and console.warn() that can be used to write to any Node.js stream.
A global console instance configured to write to process.stdout and
process.stderr. The global console can be used without importing the node:console module.

Warning: The global console object's methods are neither consistently
synchronous like the browser APIs they resemble, nor are they consistently
asynchronous like all other Node.js streams. See the note on process I/O for
more information.
Example using the global console:
console.log('hello world');
// Prints: hello world, to stdout
console.log('hello %s', 'world');
// Prints: hello world, to stdout
console.error(new Error('Whoops, something bad happened'));
// Prints error message and stack trace to stderr:
//   Error: Whoops, something bad happened
//     at [eval]:5:15
//     at Script.runInThisContext (node:vm:132:18)
//     at Object.runInThisContext (node:vm:309:38)
//     at node:internal/process/execution:77:19
//     at [eval]-wrapper:6:22
//     at evalScript (node:internal/process/execution:76:60)
//     at node:internal/main/eval_string:23:3

const name = 'Will Robinson';
console.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to stderr
Example using the Console class:
const out = getStreamSomehow();
const err = getStreamSomehow();
const myConsole = new console.Console(out, err);

myConsole.log('hello world');
// Prints: hello world, to out
myConsole.log('hello %s', 'world');
// Prints: hello world, to out
myConsole.error(new Error('Whoops, something bad happened'));
// Prints: [Error: Whoops, something bad happened], to err

const name = 'Will Robinson';
myConsole.warn(`Danger ${name}! Danger!`);
// Prints: Danger Will Robinson! Danger!, to err
@see ― source
console.
Console.log(message?: any, ...optionalParams: any[]): void
Prints to stdout with newline. Multiple arguments can be passed, with the
first used as the primary message and all additional used as substitution
values similar to printf(3)
(the arguments are all passed to util.format()).
const count = 5;
console.log('count: %d', count);
// Prints: count: 5, to stdout
console.log('count:', count);
// Prints: count: 5, to stdout
See util.format() for more information.
@since ― v0.1.100
log('Retry operation was aborted')
  }
}