Mongoose: Insert multiple documents and then disconnect database? - node.js

Question

When using Mongoose to insert multiple documents into a collection, since each .save() method has it's own callback, how do you know when they are all complete so that you can mongoose.disconnect()?
Lets say I have 3 documents I need to insert into the database:
var database = mongoose.connect('mongodb://localhost/somedb');
document1.create({...}, function(err){
if (err) { ... }
// It's saved!
});
document2.create({...}, function(err){
if (err) { ... }
// It's saved!
});
document3.create({...}, function(err){
if (err) { ... }
// It's saved!
});
database.disconnect();
The disconnect is most likely going to happen before the documents get saved to the database, especially if the Mongodb server is remote or slow or something.
What is the best way to handle this? Are Promises the only way? What was the solution to this a few years ago before Promises were so prevalent?

Answer 1

One option instead of using promises is to use the async library that has been around for some years now. There are nice helpers such as async.series and async.parallel that provide a final function call when all provided methods are complete, with the difference there being whether you need the operations to complete in series ( one after the other ) on simply just execute all together in parallel:
async.parallel(
[
function(callback) {
document1.create({...},callback);
},
function(callback) {
document2.create({...},callback);
},
function(callback) {
document3.create({...},callback);
},
],
// Called when all completed or on an error
function(err,results) {
// err is any error
// results contains an array ( in this case ) of any results
mongoose.disconnect();
}
)
Since the first argument in either case is either an array or an object containing the function calls, then you can just build up said array/object and pass it in, as long as the second argument is the handler that recieves any error or otherwise executes when all are complete.
So you can for example "build" like this:
var list = [
{ "model": "Model1", "data": {...} },
{ "model": "Model2", "data": {...} },
{ "model": "Model3", "data": {...} }
];
list = list.map(function(item) {
return function(callback) {
mongoose.model(item.model).create(item.data,callback);
}
});
async.parallel(list,function(err,results) {
// err is any error
// results contains an array ( in this case ) of any results
mongoose.disconnect();
});
And that all works the same as if hardcoded, but in a simple and programatic way.
Of course the other natural approach is to simply nest each call within their callbacks, but libraries such as shown are meant to make things prettier and easier to manipulate for creation of such a list.