retryit

    1.3.2 • Public • Published

    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!

    CircleCI Coverage Status npm dependency status

    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

    Install

    npm i retryit

    DownloadsWeekly Downloads

    176

    Version

    1.3.2

    License

    MIT

    Unpacked Size

    29.7 kB

    Total Files

    11

    Last publish

    Collaborators

    • kouhin