Ensures that an asynchronous activity has completed (just once) before allowing all users of that activity to continue execution.
npm install wait-for-itwait C, and notify all C steps with Node's event loop providing the schedule step.
javascript
var Monitor = require('wait-for-it').uncached;
// Create an instance of the monitor
var fileMon = new Monitor('file monitor');
// Assume we are in an express route
getIndex = function (req, res, next) {
// Start a queue for all requests that come in for 'index.html'
var notifyFn = fileMon.add('index.html', next);
// if notifyFn is not null then we should start the activity
if (notifyFn) {
// Perform potentially slow asynchronous operation that builds 'index.html'
createIndexIfItDoesntExist(function (err) {
if (!err) {
// Asynchonously read index.html passing along the notifyFn as the callback
return readIndexFile(notifyFn);
}
notifyFn(err);
});
}
}
`
In the example above, index.html will be created and read only once even in the face of multiple concurrent requests.
The only problem is that once there are no more concurrent requests pending, the file may be read multiple times. The value returned by reading isn't cached.
In order to cache potentially expensive-to-aquire resources, there is a cached version of the monitor:
`javascript
var Monitor = require('wait-for-it').cached;
`
That's it!
Everthing else remains the same but now all requests for 'index.html' (except for the first) will use the version stored in memory.
Installation
`bash
$ npm install wait-for-it
``