README

promise_mtd

Set of methods allowing to simplify work with promises in cycle. The library has support TypeScript.

Implementation of forEach, map, filter, reduce, find for working with array data when it's needed to apply asynchronous function to each element.
Method transform allows to iterate asynchronously over an array similarly to map, but also it can skip unnecessary data.
Implementation of cycle while as asyncWhile(while is reserved word) for using with promise.
Method parallel allows to run concurrently promises similarly to method Promise.all, but with limit.
Method all allows to run concurrently promises similarly to method Promise.all, but supports receipt of parameter such as object { k1: Promise, k2: Promise } not only as array.

The library has no dependencies 😀.

npm i promise_mtd -S

forEach(Array, function(el, index))

forEach over promises serially

const promiseMtd = require('promise_mtd');

await promiseMtd.forEach([ 300, 200, 100], async function (el, i) {
  return new Promise((resolve, reject) => {
    setTimeout(function() {
      console.log(el); // 300 then 200 then 100
      resolve();
    }, el+i);
  });
});

map(Array, function(el, index): Promise): Promise<Array>

map over promises serially

const promiseMtd = require('promise_mtd');

const result = await promiseMtd.map([ 300, 200, 100], async function (el, i) {
  return new Promise((resolve, reject) => {
    setTimeout(function() {
      resolve(el*2);
    }, el*2);
  });
});
console.log(result); // [ 600, 400, 200 ]

reduce(Array, function(previousValue, currentValue, index, array): Promise)

reduce over promises serially

const promiseMtd = require('promise_mtd');

const result = await promiseMtd.reduce([0, 1, 2, 3, 4], function (previousValue, currentValue, index, array) {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve(previousValue + currentValue);
    }, currentValue*1000);
  });
}, 0);
console.log(result); // 10

filter(Array, function(el, index): Promise): Array

filter over promises serially

const promiseMtd = require('promise_mtd');

const result = await promiseMtd.filter([ 1, 2, 3, 4 ], function(time, i) {
  return new Promise((resolve, reject) => {
    setTimeout(function() {
      resolve(i % 2 === 0);
    }, time * 1000);
  });
});
console.log(result); // [ 2, 4 ]

find(Array, function(el, index): Promise)

find over promises serially

const promiseMtd = require('promise_mtd');

const result = await promiseMtd.find([0, 1, 2, 3, 4], function (previousValue, currentValue, index, array) {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve(el === 2);
    }, el*1000);
  });
});
console.log(result); // 2

parallel(Array, { pool: number }, function(el, index))

Equivalent of Promise.all but with limit

const promiseMtd = require('promise_mtd');

await promiseMtd.parallel([ 3000, 3000, 3000, 2000, 2000, 2000, 1000], { pool: 3 }, async function(el, i) {
  return new Promise((resolve) => {
    setTimeout(() => {
      console.log(el);
      resolve();
    }, t);
  });
});

transform(Array, function(el, index): Promise): Array

Iterating over an array and filter over promises

const promiseMtd = require('promise_mtd');

const res = await promiseMtd.transform([ 1, 2, 3, 4 ], function (el, i) {
  if (el <= 2) {
    return new Promise((resolve) => {
      setTimeout(() => resolve({ el, i }), 1000);
    });
  }
});
console.log(res); // [ { el: 1, i: 0 }, { el: 2, i: 1 } ]

asyncWhile(condition: () => boolean, function(), params?: { limit: number }) | asyncWhile(condition: () => Promise, params?: { limit: number })

while over promises serially. This method supports limit of iterations (protection from forever cycle) via third parameter&

const promiseMtd = require('promise_mtd');

let i = 0;
let result = [];
await promiseMtd.asyncWhile(() => i < 10, function () {
  return new Promise((resolve) => {
    setTimeout(() => {
      result.push(i++);
      resolve();
    }, i*1000);
  });
});
console.log(result); // [0,1,2,3,4,5,5,6,7,8,9]

// OR

i = 0
result = [];
await promiseMtd.asyncWhile(function () {
  return new Promise((resolve) => {
    setTimeout(() => {
      result.push(i++);
      resolve(i < 10);
    }, i*1000);
  });
});
console.log(result); // [0,1,2,3,4,5,5,6,7,8,9]

// Example: forever cycle, method will throw error
await promiseMtd.asyncWhile(() => true, function () {
  return new Promise((resolve) => {
    setTimeout(() => {
      resolve();
    }, i*1000);
  });
}, { limit: 100 }); // protection from forever cycle

all(data: Array | Object<{ key: Promise }>): Array | Object<{ key: any }>

All like Promise.all but it can handle object

const promiseMtd = require('promise_mtd');

const t1 = new Promise((resolve, reject) => {
  setTimeout(() => {
    resolve(2000);
  }, 2000);
});

const t2 = new Promise((resolve, reject) => {
  setTimeout(() => {
    resolve(1000);
  }, 1000);
});


// { t1: 2000, t2: 1000 }
console.log(await promiseMtd.all({ t1, t2 }));

// as Promise.all
// [ 2000, 1000 ]
console.log(await promiseMtd.all([ t1, t2 ]));

Tests

npm test

Usage no npm install needed!