https://github.com/humptydumptyeiz/pneasync

This piece of code promisifies nested awaits
https://github.com/humptydumptyeiz/pneasync

async await nested-arrays nodejs promise

Last synced: 15 days ago
JSON representation

This piece of code promisifies nested awaits

• Host: GitHub
• URL: https://github.com/humptydumptyeiz/pneasync
• Owner: humptydumptyeiz
• Created: 2020-10-28T17:51:06.000Z (about 4 years ago)
• Default Branch: master
• Last Pushed: 2020-10-31T07:50:33.000Z (about 4 years ago)
• Last Synced: 2024-10-31T23:06:14.136Z (15 days ago)
• Topics: async, await, nested-arrays, nodejs, promise
• Language: JavaScript
• Homepage:
• Size: 21.5 KB
• Stars: 0
• Watchers: 1
• Forks: 0
• Open Issues: 0
• Metadata Files:
  • Readme: README.md

Awesome Lists containing this project

README

        
# 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)

      }