Skip to content

humptydumptyeiz/pNeAsync

Folders and files

NameName
Last commit message
Last commit date

Latest commit

 

History

9 Commits
 
 
 
 
 
 
 
 
 
 
 
 

Repository files navigation

p(romisify)Ne(sted)Async

A handy tool to promisify nested arrays

Installation

npm i @humptydumptyeiz/pneasync

Run Tests

npm test

Usage :

Suppose args is an array of objects which define some category, each object having categoryId as a property. Suppose someAsyncFunction takes categoryId of elements of the above array and returns an array of sub category objects, each having subCategoryId as a property. Suppose anotherAsyncFunction takes subCategoryId of each element of subcategory array and returns an array of products.

If we want to get all subcategories and products corresponding to each category, we can run a for loop inside another with awaits before each async function call and collect the results. However, this will make the code synchronous.

To resolve this, use pNeAsync.

Arguments

  1. list - array to iterate over.

  2. factorList - it is an array each of whose element is an object of the form -

     {
       argFoo:     // function which takes in each element of the list
       foo:        // async function which takes the value returned by argFoo as argument
     }
    
  3. failFast - default value is true. When true the function will throw errors and instead of handling them and will cause exception. When false the function will handle errors and push them into an array which will be returned with the result.

Return Value

  1. failFast === true && Exception - exception will be raised
  2. failFast === false && Exception -
      [[// this is the result 
        {
            parent: obj1,
            children: [
                {
                   parent: obj2
                   children: [...]   
                },
                ...
            ]
        },
        ...
       ], [{      // this is the error array
           object:    // object under use when exception occurred,
           depth:     // depth of nesting at which the exception occurred,
           arg        // arg variable from factorList element,
           typeOfArg, // typeOfArg variable from factorList,
           foo        // foo variable from factorList element,
           error:     // exception raised
     }, ...]]

Length of factor list decides the depth of the nesting. So, each element of the factorList is an object containing arg, foo and typeOfArg for increasing depths of nesting

  const list = [{id: 1, name: 'a'}, {id: 2, name: 'b'}, ...];
  const factors = [{argFoo: elm => elm.id, foo: someAsyncFoo},
                   {argFoo: elm => elm.subCategoryId, foo: anotherAsyncFoo}];
  
  async function anyFunction(arr){
    return await pneAsync(list, factors)
  }

About

This piece of code promisifies nested awaits

Topics

Resources

Stars

Watchers

Forks

Releases

No releases published

Packages

No packages published