indigobird v1.0.0

What is indigobird?

Much of the same functionality as bluebird, except everything allows for concurrency and handlers, as well as additional functionality, such as asynchronous .reduce.

Install

Node Install:

$ npm install --save indigobird

Deno Install:

// Coming soon

Where it's like bluebird:

import indigobird from 'indigobird';

// Like Promise.all or bluebird's variant
indigobird.all([
  doSomethingAsync(),
  doSomethingAsync(),
  doSomethingAsync(),
]);

// Like bluebird's .some, we wait for `amount` to resolve
// successfully before resolving the batch.
indigobird.some([
  doSomethingAsync(),
  doSomethingAsync(),
  doSomethingAsync(),
], { amount: 2 });

// Like bluebird's .props, we resolve the promises at the keys'
// values, and map them onto a result object with the same keys
indigobird.props({
  head: getHeadAsync(),
  shoulders: getShouldersAsync(),
  knees: getKneesAsync(),
  toes: getToesAsync(),
});

// Like .some, but has `amount` set to 1.
indigibird.any([
  doSomethingAsync(),
  doSomethingAsync(),
  doSomethingAsync(),
]);

Where it's NOT like bluebird

Rather than just handing an array of promises, like Promise.all or bluebird's .some, all of these utilities can also be passed a handler argument

// This then behaves like bluebird's .map, where
// arguments in an array will be passed into an asynchronous handler,
// and can therefore have their concurrency specified in the `concurrency`
// argument.
indigobird.some(userIds, (userId) => {
  return validateAndFetchUser(userId);
}, { amount: 5, concurrency: 3});

Rather than invoking the functions at a given prop, we could, for example, just pass them instead. Then we could invoke them in the handler, and benefit from having control over concurrency.

indigobird.props({
  head: getHeadAsync,
  shoulders: getShouldersAsync,
  knees: getKneesAsync,
  toes: getToesAsync,
}, fn => fn(), { concurrency: 3 });

There is also unique functionality typically unavailable to asynchronous libraries, such as .reduce.

const arr = [1, 2, 3, 6, 4, 2, 9, 1, 64];
const sum = await reduce(arr, async (getAggregate, n) => {
  // Notice that because these handlers are meant to be executed
  // asynchronously, rather than passing in `sum`, or the equivalent
  // aggregate value, which would have issues with having the closure
  // capture an aggregate value which may have become stale during
  // concurrent execution of peer handlers, we instead provide a getter.
  // This way, when ready to use the aggregate, the getter can be invoked
  // for access to the aggregate value that is in up to date.
  const someValue = await someAsynchronousThing(n);
  return getAggregate() + someValue;
}, 0, { concurrency: 6 });