Node.js and MongoDB, reusing the DB object

Question

I'm new to both Node.js and MongoDB, but I've managed to put some parts together from SO and the documentation for mongo.

Mongo documentetion gives the example:

// Retrieve
var MongoClient = require('mongodb').MongoClient;

// Connect to the db
MongoClient.connect("mongodb://localhost:27017/exampleDb", function(err, db) {
  if(!err) {
    console.log("We are connected");
  }
});

Which looks fine if I only need to use the DB in one function at one place. Searching and reading on SO has shown me that I should not open a new connection each time, but rather use a pool and reuse the database object I get the first time. This answer is abundant on SO, but I'm not sure how to even get the DB object in the first place, and then how to reuse it.

Say I have the Node.js code above in my App.js, and I then have differnt routes that need to run different operations on the db like:

app.post('/employee', function(req, res){
    //Put req.name in database
});


app.post('/car', function(req, res){
    //Put req.car in database
});

How would I go about to put these two snippets together into something useful?

I found a similar question in Node.js reuse MongoDB reference , but from the looks of this ( http://mongodb.github.io/node-mongodb-native/driver-articles/mongoclient.html ) it looks like I should use MongoClient rather than db(). And I'm not sure it solves my problem either...

Answer 1

You could always write a module which initializes your database connections, and makes them accessible throughout your program. For example:

mongo.js

var mongodb = require('mongodb');

module.exports.init = function (callback) {
  var server = new mongodb.Server("127.0.0.1", 27017, {});
  new mongodb.Db('test', server, {w: 1}).open(function (error, client) {
    //export the client and maybe some collections as a shortcut
    module.exports.client = client;
    module.exports.myCollection = new mongodb.Collection(client, 'myCollection');
    callback(error);
  });
};

app.js

var mongo = require('./mongo.js');

//setup express...

//initialize the db connection
mongo.init(function (error) {
    if (error)
        throw error;

    app.listen(80); //database is initialized, ready to listen for connections
});

randomFile.js

var mongo = require('./mongo.js');

module.exports.doInsert = function () {
  //use the collection object exported by mongo.js
  mongo.myCollection.insert({test: 'obj'}, {safe:true}, function(err, objects) {
    if (err)
        console.warn(err.message);
  });
};

I know people talk about pooling, but when I did benchmarking of pooling mongo connections vs. a single connection for all requests, the single connection actually performed better. Granted, this was about a year ago, but I doubt that basic concept has changed. All the requests are asynchronous, so it's not like multiple connections are necessary in order to make simultaneous requests.

As far as MongoClient, I guess that's the new syntax they're encouraging. Either way, it's essentially a client object that you want to keep and make accessible regardless of which style you use.

Answer 2

From your last code snippet, seems like you using Express or similar framework. You can use express-mongo-db to get connection inside req object. This middleware will cache connection for you and share it with other incoming requests:

app.use(require('express-mongo-db')(require('mongodb'), { db: 'test' }))
app.post('/employee', function(req, res){
    // req.db.collection('names'),insert(req.name)
    // Put req.name in database
});


app.post('/car', function(req, res){
    // req.db.collection('names').insert(req.name)
    // Put req.car in database
});