retryit

retryit

A Promise version of async/retry. Also includes serveral WaitStrategies that might be useful for situations where more well-behaved service polling is preferred.

Thanks to Caolan McMahon for the great work!

Installation

npm install retryit --save

API && Usage

retryit(opts, task)

Arguments

• opts: Object | number
  • Default: { times: 5, interval: 0, errorFilter: () => true }
  • Description:
    • opts can be either an object or a number.
    • times - The number of attempts to make before giving up. The default is 5.
    • interval - The time to wait between retries, in milliseconds. The default is 0. The interval may also be specified as a function of the retry count (see example). This library provides serveral wait strategies that you can use it as interval.
    • errorFilter - An optional synchronous function that is invoked on erroneous result. If it returns true the retry attempts will continue; if the function returns false the retry flow is aborted with the current attempt's error and result being returned to the final callback. Invoked with (err).
    • If opts is a number, the number specifies the number of times to retry, with the default interval of 0.
• task: function(err)
  • Description:
    • A function which returns a Promise. The argument is previous error.

Returns

• (Promise): A Promise object which will be resolved when the task has succeeded, or rejected with an error after the final failed attempt.

Example

import retryit from 'retyryit';

// The `retry` function can be used as a stand-alone control flow by passing
// a callback, as shown below:

// try calling getPromise 3 times
retryit(3, (err) => {
    if (err) {
      // err is previous error
      console.error(err);
    }
    // return a Promise
  })
  .then(result => {
    // do something with the result
  })
  .catch(err => {
    // do something with the error
  });

// try calling getPromise 3 times, waiting 200 ms between each retry
retryit({ times: 3, interval: 200 }, getPromise)
  .then(result => {
    // do something with the result
  })
  .catch(err => {
    // do something with the error
  });

retryit({
  times: 10,
  interval: (retryCount) => {
    return 50 * Math.pow(2, retryCount);
  }
}, getPromise)
  .then(result => {
    // do something with the result
  })
  .catch(err => {
    // do something with the error
  });

// try calling getPromise the default 5 times no delay between each retry
retryit(getPromise)
  .then(result => {
    // do something with the result
  })
  .catch(err => {
    // do something with the error
  });

// try calling getPromise only when error condition satisfies, all other
// errors will abort the retry control flow and return to final callback
retryit({
  errorFilter: function(err) {
    return err.message === 'Temporary error'; // only retry on a specific error
  }
}, getPromise)
  .then(result => {
    // do something with the result
  })
  .catch(err => {
    // do something with the error
  });

Build-in waitStrategies for opts.interval

Inspired by guava-retrying

fixedWait(interval = 0)

• Returns a wait strategy that sleeps a fixed amount of time before retrying (in millisecond).

exponentialWait(multiplier = 1, max = Number.MAX_VALUE)

• Returns a strategy which sleeps for an exponential amount of time after the first failed attempt, and in exponentially incrementing amounts after each failed attempt up to the maximumTime.

fibonacciWait(multiplier = 1, max = Number.MAX_VALUE)

• Returns a strategy which sleeps for an increasing amount of time after the first failed attempt and in Fibonacci increments after each failed attempt up to the maximumTime.

incrementingWait(initialSleepTime = 0, increment = 1000, max = Number.MAX_VALUE)

• Returns a strategy that sleeps a fixed amount of time after the first failed attempt and in incrementing amounts of time after each additional failed attempt.

randomWait(min = 0, max = 0)

• Returns a strategy that sleeps a random amount of time before retrying.

Example

import retryit, { exponentialWait } from 'retryit';

retryit({
  times: 10,
  interval: exponentialWait(2, 64),
}, getPromise)
  .then(result => {
    // do something with the result
  })
  .catch(err => {
    // do something with the error
  });

LICENSE

MIT