promise-pool-ext

Queue promises into pool limiting concurrency

Install

Install with npm:

$ npm install --save promise-pool-ext

Usage

Pool

import { Pool } from 'promise-pool-ext';

const pool = Pool({ concurrency: 10 });

// queue array of functions, returns Promise < array of function results >
pool([
  () => new Promise((resolve) => { /* do async logic here */ }),
  async () => { /* do async logic here */ }
]);

// queue function, returns Promise < function result >
pool(async () => { /* do async logic here */ });

See tests for more examples

PoolManager

import { PoolManager } from 'promise-pool-ext';

const manager = PoolManager({
  check1: {
    if: () => false, // when not true returned, promise is not resolved and undefined is returned
    fn: () => { /* return async logic */ }
  },
  check2: {
    requires: ['check1'],
    fn: ({ check1 }) => {
      if (check1) { /* return async logic */ }
    }
  },
  data: {
    requires: ['check1', 'check2'],
    fn: ({ check1, check2 }) => {
      if (check1 && check2) { /* return async logic */ }
    }
  }
}, { concurrency: 10 });

// returns Promise < data.fn result >
manager.get('data');

See tests for more examples

Parameters

concurrency: Integer

How many promises can resolve in parallel.

timeout: Integer = undefined

Maximum amount of time in ms that a promise can take to resolve before a failure is returned.

If 0 or undefined is passes, no timeout is enforced.

Errors

When a promise is rejected or an error is thrown, the returned promise is rejected once all promises in batch have completed execution.

Why

As an example, when making a lot of external requests one can hit limits of the external API or the node runtime itself. This library makes it easy to limit the amount of parallel executions.