npm

Need private packages and team management tools?Check out npm Orgs. »

rg-async

2.5.4 • Public • Published

rg-async

A small library with JS functional utility methods to run async code with promises (async/await keywords)

docs travis build codecov coverage code climate dependencies downloads node version MIT Licence

NPM

Installation

    $ npm install --save rg-async
    $ npm i -S rg-async

Test

    $ npm t

Basic usage

  • Without async/await keywords:
const rgAsync = require('rg-async');
 
rgAsync.filter([1,2,3], value => Promise.resolve(value % 2 === 0))
    .then(filteredArray => console.log(filteredArray)) // output => [2]
    .catch(err => console.log(err));
 
  • With async/await keywords:
const rgAsync = require('rg-async');
 
rgAsync.map([1,2,3], async value => {
    try {
        const multiplyValue = await getAsyncMultiplyValue(); // some async code which returns 2 as a promise resolved value.
    }catch(err){
        throw err;
    }
    return value * multiplyValue;
})
.then(mappedArray => console.log(mappedArray)) // output => [2,4,6]
.catch(err => console.log(err));
 
  • With async method scope:
 
const rgAsync = require('rg-async');
const array = [1,2,3];
 
async function printRgAsyncPlusArrayNumbers(array){
    await rgAsync.each([1,2,3], async value => {
        const name = await getAsyncName(); // some async code which returns 'rg-async' as a promise resolved value.
        console.log(name + ' ' + value); 
    });
}
 
printRgAsyncPlusArrayNumbers(array)
    .then(() => console.log('All promises resolved')) // output => rg-async 1, rg-async 2, rg-async 3, All promises resolved
    .catch(err => console.log(err));

API

Filter

  • filter(srcArray, predicate) method invokes in parallel an async predicate function on each item in the given source Array.

  • This will return a promise to be resolved containing the new array with the items that predicate function returned a truthy value.

  • The async predicate function follows the standard javascript filter arguments- (value, index, array) and needs to return a promise.

  • Examples

    • With .then - .catch functions
    const rgAsync = require('rg-async');
     
    rgAsync.filter([1,2,3], value => Promise.resolve(value < 3))
        .then(filteredArray => console.log(filteredArray)) // output => [1,2]
        .catch(err => console.log(err)); // if exists any case that you throw an error on your predicate function
    • With async/await keywords
    const rgAsync = require('rg-async');
     
    // if you are inside of a async function scope
    // if exist any case that you throw an error you should wrap this with try-catch clause
    try{
        const result = await rgAsync.filter([1,2,3], value => Promise.resolve(value < 3));
        console.log(result); // output => [1,2]
    }catch(err){
        console.log(err);
    }

Map

  • map(srcArray, mapper) method invokes in parallel an async mappercon function on each item in the given source Array.

  • This will return a promise to be resolved containing the new array with the mapped/transformed items.

  • The mapper function follows the standard javascript map arguments - (value, index, array)and needs to return a promise.

  • Examples

    • With .then - .catch functions
    const rgAsync = require('rg-async');
     
    rgAsync.map([1,2,3], value => Promise.resolve(value * 2))
        .then(mappedArray => console.log(mappedArray)) // output => [2,4,6]
        .catch(err => console.log(err)); // if exists any case that you throw an error on your mapper function
    • With async/await keywords
    const rgAsync = require('rg-async');
     
    // if you are inside of a async function scope
    // if exist any case that you throw an error you should wrap this with try-catch clause
    try{
        const result = await rgAsync.map([1,2,3], value => Promise.resolve(value * 2));
        console.log(result); // output => [2,4,6]
    }catch(err){
        console.log(err);
    }

Each

  • each(srcArray, consumer) method invokes in parallel an async consumer function on each item in the given source Array.

  • This will return a promise without any resolved value.

  • The consumer function follows the standard javascript forEach arguments - (value, index, array)and needs to return a promise.

  • Examples

    • With .then - .catch functions
    const rgAsync = require('rg-async');
     
    rgAsync.each([1,2,3], value => Promise.resolve(console.log(value)))
        .then(() => console.log('done')) // output => 1,2,3,done
        .catch(err => console.log(err)); // if exists a case that you throw an error on your consumer function
    • With async/await keywords
    const rgAsync = require('rg-async');
     
    // if you are inside of a async function scope
    // if exist any case that you throw an error you should wrap this with try-catch clause
    try{
        await rgAsync.each([1,2,3], value => Promise.resolve(console.log(value)));
        console.log('done'); // output => 1,2,3,done
    }catch(err){
        console.log(err);
    }

Reduce

  • reduce(srcArray, reducer, accumulator) method invokes in series an async reducer function on each item in the given source Array.

  • The reducer function transforms an accumulator value based on each item iterated over. The reducer function follows the standard javascript map arguments- (accumulator, currValue, index, array) and needs to return a promise.

  • This will return a promise to be resolved containing the accumulator final value.

  • Examples

    • With .then - .catch functions
    const rgAsync = require('rg-async');
     
    rgAsync.reduce([1,2,3], (accumulator, currVal) => Promise.resolve(accumulator + currVal), 0)
    .then(accumulator => console.log(accumulator)) // output => 6
    .catch(err => console.log(err)); // if exists any case that you throw an error on your reducer function
    • With async/await keywords
    const rgAsync = require('rg-async');
     
    // if you are inside of a async function scope
    // if exist any case that you throw an error you should wrap this with try-catch clause
    try{
        const result = await  rgAsync.reduce([1,2,3], (accumulator, currVal) => Promise.resolve(accumulator + currVal), 0);
        console.log(result); // output => 6
    }catch(err){
        console.log(err);
    }

Series

  • series(srcArray) method invokes in series each item in the given source Array.

  • This will return a promise to be resolved containing the same structure as the srcArray, but with the resolved values

  • Example

const rgAsync = require('rg-async');
const list = [
    async () => await someAsyncCode1(), // let assume that this will return a promise with resolved value of 1 
    async () => await someAsyncCode2(), // returns 2 as a resolved value
    async () => await someAsyncCode3(), // returns 3 as a resolved value
    () => Promise.resolve(4) // returns 4 as a resolved value
];
// if you are inside of a async function scope
// if exist a case that you throw an error you should wrap this with try-catch clause
try{
    const result = await rgAsync.series(list);
    console.log(result); // output => [1,2,3,4]
}catch(err){
    console.log(err);
}
 
// if you aren't inside of async function scope you should use .then method
rgAsync.series(list)
    .then(resultArray => console.log(resultArray)); // output => [1,2,3,4]
    .catch(err => console.log(err)); // if exists a case that you throw an error on your list of promises

Parallel

  • parallel(srcArray) method invokes in parallel each item in the given source Array.

  • This will return a promise to be resolved containing the same structure as the srcArray, but with the resolved values

  • Example

const rgAsync = require('rg-async');
const list = [
    async () => await someAsyncCode1(), // let assume that this will return a promise with resolved value of 'one'
    async () => await someAsyncCode2(), // returns 'two' as a resolved value
    async () => await someAsyncCode3(), // returns 'three' as a resolved value
    () => Promise.resolve('four') // returns 'four' as a resolved value
];
// if you are inside of a async function scope
// if exist a case that you throw an error you should wrap this with try-catch clause
try{
    const result = await rgAsync.parallel(list);
    console.log(result); // output => ['one','two','three','four']
}catch(err){
    console.log(err);
}
 
// if you aren't inside of async function scope you should use .then method
rgAsync.parallel(list)
    .then(resultArray => console.log(resultArray)); // output => ['one','two','three','four']
    .catch(err => console.log(err)); // if exists a case that you throw an error on your list of promises

install

npm i rg-async

Downloadsweekly downloads

17

version

2.5.4

license

MIT

homepage

github.com

repository

Gitgithub

last publish

collaborators

  • avatar
Report a vulnerability