Is it necessary to open MongoDB connection every time I want to work with the DB?

Question

In the example I am working with is this code:

//lets require/import the mongodb native drivers.
var mongodb = require('mongodb');

//We need to work with "MongoClient" interface in order to connect to a mongodb server.
var MongoClient = mongodb.MongoClient;

// Connection URL. This is where your mongodb server is running.
var url = 'mongodb://localhost:27017/my_database_name';

// Use connect method to connect to the Server
MongoClient.connect(url, function (err, db) {
  if (err) {
    console.log('Unable to connect to the mongoDB server. Error:', err);
  } else {
    //HURRAY!! We are connected. :)
    console.log('Connection established to', url);

    // Get the documents collection
    var collection = db.collection('users');

    //Create some users
    var user1 = {name: 'modulus admin', age: 42, roles: ['admin', 'moderator', 'user']};
    var user2 = {name: 'modulus user', age: 22, roles: ['user']};
    var user3 = {name: 'modulus super admin', age: 92, roles: ['super-admin', 'admin', 'moderator', 'user']};

    // Insert some users
    collection.insert([user1, user2, user3], function (err, result) {
      if (err) {
        console.log(err);
      } else {
        console.log('Inserted %d documents into the "users" collection. The documents inserted with "_id" are:', result.length, result);
      }
      //Close connection
      db.close();
    });
  }
});

As you may see, he is doing an operation in the connect function. I would like to keep it modular and separate the connection from DB operations.

My suggestion would be to make a singleton on db variable and reuse that one. At least that's what I would do in Java to which I am used to.

However, I am not sure as in the example he hasn't suggested anything like that.

As you said, you can just make connection to db on say server start. For later uses you can just get the collection and proceed — jerry, Aug 01 '16 at 08:12
What is the time to live of the connection? Can I leave it open forever and close only if the app crashes? — Ondrej Tokar, Aug 01 '16 at 08:14

Paul · Accepted Answer · 2016-08-01T08:23:00.573

I would recommend against maintaining one connection if you want any kind of scalability.

There are a number of options for connection pooling, etc, but most folks who spend any time at all with Node and MongoDB end up moving to Mongoose at some point.

In addition to adding a nice schema layer, it offers connection abstraction so that you can default to a shared connection by calling mongoose.connect(), or you can create multiple connections or participate in connection pooling by calling mongoose.createConnection(). In both cases, you call it without a callback, and the mongoose machinery will defer subsequent calls to the module until after the connection is established, so that your code doesn't have to care.

Something like your use case might look like so:

// in your app.js or server.js file
var mongoose = require('mongoose');
mongoose.connect(config.db.url); // assuming you have some module that handles config variables

Then in ./models/user.js

const mongoose = require('mongoose'),
         Schema   = mongoose.Schema;

   const UserSchema = new Schema({
      name: String,
      age: Number,
      roles: [String]
   });
   mongoose.model('User',UserSchema);

finally, in lets say a seed function to create your initial batch of users:

const mongoose = require('mongoose'),
      User     = mongoose.model('User');

// create some users
var user1 = new User({name: 'modulus admin', age: 42, roles: ['admin', 'moderator', 'user']});
var user2 = new User({name: 'modulus user', age: 22, roles: ['user']});

user1.save(console.log);
user2.save(console.log);

No problem; decided to add some sample code, which I hope helps. — Paul, Aug 01 '16 at 08:23

score 3 · Answer 2 · answered Jan 21 '19 at 16:42

I believe maintaining a single connection is the best as mentioned in another thread:

The primary comitter in node-mongodb-native says

You open do MongoClient.connect once when your app boots up and reuse the db object. It's not a singleton connection pool each .connect creates a new connection pool. So open it once an[d] reuse across all requests.

score 1 · Answer 3 · answered Aug 01 '16 at 08:22

Say on server start initiate the mongo connection.

Server.js:

...
        var db = require('./db');//require db.js
        db.openMongoConnection(function(error)
        {
            if(error)
            {
                console.log(error);
                console.log("cannot make the connection with database");
            }
            else
            {
               server.listen(7400);//say ur server listening on 7000 port
            }
        }

db.js

    var db1;
    var MongoClient = require('mongodb').MongoClient;
     exports.openMongoConnection = function(callback)
     {
            MongoClient.connect(<YourUrl1>,function(err,dbInstance)
            {
                if(err)
                {
                    callback(err);
                }
                else
                {
                    db1 = dbInstance;
                    callback(null);
                }
            });
     };


exports.getCollection = function(collectionName, callback){
  dbInstance.collection(collectionName, function(err, collectionInstance){
    if(err)
    {
       callback(err);
    }
    else
    {
       callback(null, collectionInstance)
    }
  });
}

Then you can call the getCollection to use at anytime by requiring dbInsance

Is it necessary to open MongoDB connection every time I want to work with the DB?

3 Answers3

Linked