async-is-fun v0.0.3

Async is Fun

A collection of small, composable helper functions and utilities for doing fun stuff with promises.

Installation

Node

yarn add async-is-fun
// or
npm install --save async-is-fun

Webpack

Documentation

Table of Contents

• async-is-fun
  • defer
  • delay
  • retryUntil

async-is-fun

defer

• See: test/defer.js For usage.

An overlooked pattern for Promise usage, returns An old school self contained deferred object. A fun use of this is waiting for async instantiation in class constructors.

Type: object

Properties

• resolve function (any) resolve the Promise with value.
• reject function (any) reject the Promise with value.
• promise Promise

Examples

const defer = require('async-is-fun').defer

 class AsyncConstructor {
   constructor(promise){
     this.Promise = promise.promise
     setTimeout(() => {
       promise.resolve(Math.random())
     }, 1000)
   }
 }

 let later = new AsyncConstructor(defer())
 let evenLater = new AsyncConstructor(defer())

 Promise.all([later.Promise, evenLater.Promise])
 .then((results)=>{
   console.log(results) // [ 0.17888717674897858, 0.8638054083464473 ]
 })

delay

• See: test/delayPromise.js For usage.

Delays resolution of a Promise by time amount, resolving value

Yes, it is true that plenty of other libraries implement this method, but is included here because it is used internally and could save someone from having to load a second bigger library like bluebird.

Parameters

• time number in milliseconds

Examples

const delay = require('async-is-fun').delay

Promise.resolve('Wait for it')
.then(delay(1000))
.then((result)=>{
  console.log(result) // 'wait for it'
}

Returns function (any)

retryUntil

• See: test/retryUntil.js For usage.
• See: src/growIt.js For the timeout growth function.

Retry a Promise returning function

Type: function

Parameters

• fun function A promise or value returning function, values will be wrapped in a Promise.
• config object? The optional configuration object.
  • config.timeout object Initial timeout value before retry. (optional, default 250)
  • config.bound object Upper bound of the computed timeout. (optional, default 1000)
  • config.growth object Growth rate of the timeout per iteration. src/growIt.js (optional, default 0.2)
  • config.tries object Number of attempts before the promise is rejected. (optional, default 10)
  • config.returnErrors object Number of errors to report if func throws or rejects. (optional, default 5)

Examples

const retryUntil = require('async-is-fun').retryUntil

Promise.resolve({msg: 'Retry a bunch', value: 10})
.then(retryUntil((value)=>{

  //Value is passed through.
  console.log(value) // {msg: 'Retry a bunch', value: 10}

  return somePromiseReturningFun(9)
  .then((count)=>{
    console.log(count) // 9
    let total = count + value

    //If a truthy value is returned the promise will resolve with that value.
    if(total === 15){
      return {total: total}
    }

    //If we return false, the method will retry after the timout expires.
    return false
  })
}))
.then((result)=>{
  console.log(result) // {total: 19}
}

Returns function (value) Returns a Promise returning function that will resolve the first truthy value returned or resolved by the provided function. It will reject when all attempts are exhausted.