Creates a placeholder object which can be used to keep functions which can be called in parallel and post execution, the values will be assigned at proper places!

🏠 Homepage

Install

npm install

PromisePlaceholder

Creates a placeholder object which can be used to keep functions which can be called in parallel and post execution, the values will be assigned at proper places!

Kind: global constant
Notes: 1. All the methods of async library are mapped with exec followed by first letter uppercase method name. For example: async.parallelLimit will be used when pp.execParallelLimit(2) will be called // This will make 2 concurrent calls at a time ... etc 2. exec is short for execParallel which uses async.parallel
Example

// Consider the following scenario where we need complete data on teams.
 // We need the data at the respective points by calling the api. (get...FromApi are async functions that make http call to some server which outputs the desired array!)
 const PromisePlaceholder = require('promise-placeholder');
 const pp = new PromisePlaceholder;

 const obj = {
     data1: pp({
         teams: async () => getTeamsFromApi(),
         playersInfo: pp({
             active: async () => getActivePlayersFromApi(),
             retired: async () => getRetiredPlayersFromApi(),
             joinedIn2007: async () => getPlayersFromApi(2007),
             joinedLater: pp({
                     2008: async () => getJoinedLaterThanFromApi(2007)
             })
         })
     })
 }

 // Note: pp() -> This call collects all the keys with value as a function in the object. It DOES NOT iterate deep, that's the reason pp() is should be called on every object which has a function value in any key which should be included in a parallel call.
 // In case of deep-iteration is deserved, see [collect](#PromisePlaceholder+collect)
 // Now, we need all the async calls to execute and the value to be set at the respective places.
 await pp.exec(); // By default executes async.parallel(); ,, other async.method can be used as an uppercase version (Example below)
 
 // By default, the above outputs the result of async[method] call but this will ideally not be required and can be ignored! 
 // Troper values will be placed in obj itself.

 console.log(obj); // will log:
 {
     data1: {
         teams: ['team1','team2'],
         playersInfo: {
             active: ['activeplayer1', 'activeplayer2'],
             retired: <retired player list>,
             joinedIn2007: <desired list>,
             joinedLater: {
                     2008: <desired list>
             }
         }
     }
 }

• PromisePlaceholder
  • instance
    • .setReviver(reviver)
    • .getResults() ⇒
    • .getRefs() ⇒
    • .size() ⇒
    • .exec() ⇒
    • .collect(obj) ⇒ PromisePlaceholder
  • static
    • .withAsync

promisePlaceholder.setReviver(reviver)

Sets a reviver otherwise plain assignment is used. Can be used to revive manually!

Kind: instance method of PromisePlaceholder

| Param | Type | Description | | --- | --- | --- | | reviver | function | string | If reviver = 'ignore', the revival will be skipped and the values need to be revived manually |

promisePlaceholder.getResults() ⇒

Returns results array of execution

Kind: instance method of PromisePlaceholder
Returns: results

promisePlaceholder.getRefs() ⇒

Returns internal references

Kind: instance method of PromisePlaceholder
Returns: refs

promisePlaceholder.size() ⇒

Kind: instance method of PromisePlaceholder
Returns: Length of current of functions in the queue

promisePlaceholder.exec() ⇒

Calls async.parallel and stores the values at the respective places!

Kind: instance method of PromisePlaceholder
Returns: Result of async.parallel (may be discarded)

promisePlaceholder.collect(obj) ⇒ PromisePlaceholder

Instead of calling the promisePlaceholder at every step, it may be desirable to deep iterate the object and collect all the functions!

Kind: instance method of PromisePlaceholder

| Param | Type | | --- | --- | | obj | Object |

Example

// In the example for [Placeholder](Placeholder), instead of wrapping every object having a promise inside a pp() call,
 // just call once like:
 const obj = {
     data1: {
         teams: async () => getTeamsFromApi(),
         playersInfo: {
             active: async () => getActivePlayersFromApi(),
             retired: async () => getRetiredPlayersFromApi(),
             joinedIn2007: async () => getPlayersFromApi(2007),
             joinedLater: {
                     2008: async () => getJoinedLaterThanFromApi(2007)
             }
         }
     }
 }

// Now:
await (new PromisePlaceholder()).collect(obj).exec();
After await resumes, obj will have all the values instead of functions! 

PromisePlaceholder.withAsync

Ability to pass custom async library such as another version of async or any other library. Will map that libraries method instead of async as above

Kind: static property of PromisePlaceholder
Example

// Instead of 
     new PromisePlaceholder //(See below),
     new (PromisePlaceholder.withAsync(customAsyncOrOtherLib)) // The outer brackets are necessary

Run tests

npm run test

Author

👤 Praveen Ranjan Keshri

• Github: @prkeshri
• LinkedIn: @prkeshri

🤝 Contributing

Contributions, issues and feature requests are welcome!Feel free to check issues page.

Show your support

Give a ⭐️ if this project helped you!

This README was generated with ❤️ by readme-md-generator