Cfrgtkky

I've been reading and reading and still am confused on what is the best way to share the same database (MongoDb) connection across whole NodeJs app. As I understand connection should be open when app starts and reused between modules. My current idea of the best way is that server.js (main file where everything starts) connects to database and creates object variable that is passed to modules. Once connected this variable will be used by modules code as necessary and this connection stays open. E.g.:

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

    var mongo = {}; // this is passed to modules and code



    MongoClient.connect("mongodb://localhost:27017/marankings", function(err, db) {

        if (!err) {

            console.log("We are connected");



            // these tables will be passed to modules as part of mongo object

            mongo.dbUsers = db.collection("users");

            mongo.dbDisciplines = db.collection("disciplines");



            console.log("aaa " + users.getAll()); // displays object and this can be used from inside modules



        } else

            console.log(err);

    });



    var users = new(require("./models/user"))(app, mongo);

    console.log("bbb " + users.getAll()); // not connected at the very first time so displays undefined

then another module models/user looks like that:

Users = function(app, mongo) {



Users.prototype.addUser = function() {

    console.log("add user");

}



Users.prototype.getAll = function() {



    return "all users " + mongo.dbUsers;



    }

}



module.exports = Users;

Now I have horrible feeling that this is wrong so are there any obvious problems with this approach and if so how to make it better?

You can create a mongoUtil.js module that has functions to both connect to mongo and return a mongo db instance:

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



var _db;



module.exports = {



  connectToServer: function( callback ) {

    MongoClient.connect( "mongodb://localhost:27017/marankings", function( err, db ) {

      _db = db;

      return callback( err );

    } );

  },



  getDb: function() {

    return _db;

  }

};

To use it, you would do this in your app.js:

var mongoUtil = require( 'mongoUtil' );



mongoUtil.connectToServer( function( err ) {

  // start the rest of your app here

} );

And then, when you need access to mongo somewhere, you can do this:

var mongoUtil = require( 'mongoUtil' );

var db = mongoUtil.getDb();



db.collection( 'users' ).find();

The reason this works is that in node, when modules are require'd, they only get loaded/sourced once so you will only ever end up with one instance of _db and mongoUtil.getDb() will always return that same instance.

Note, code not tested.

If you are using Express, then you can use express-mongo-db module that allows you to get db connection in request object.

Install

npm install --save express-mongo-db

server.js

var app = require('express')();



var expressMongoDb = require('express-mongo-db');

app.use(expressMongoDb('mongodb://localhost/test'));

routes/users.js

app.get('/', function (req, res, next) {

    req.db // => Db object

});

Here's how I do it with contemporary syntax, based on go-oleg's example. Mine is tested and functional.

I put some comments in the code.

./db/mongodb.js

 const MongoClient = require('mongodb').MongoClient

 const uri = 'mongodb://user:password@localhost:27017/dbName'

 let _db



 const connectDB = async (callback) => {

     try {

         MongoClient.connect(uri, (err, db) => {

             _db = db

             return callback(err)

         })

     } catch (e) {

         throw e

     }

 }



 const getDB = () => _db



 const disconnectDB = () => _db.close()



 module.exports = { connectDB, getDB, disconnectDB }

./index.js

 // Load MongoDB utils

 const MongoDB = require('./db/mongodb')

 // Load queries & mutations

 const Users = require('./users')



 // Improve debugging

 process.on('unhandledRejection', (reason, p) => {

     console.log('Unhandled Rejection at:', p, 'reason:', reason)

 })



 const seedUser = {

     name: 'Bob Alice',

     email: 'test@dev.null',

     bonusSetting: true

 }



 // Connect to MongoDB and put server instantiation code inside

 // because we start the connection first

 MongoDB.connectDB(async (err) => {

     if (err) throw err

     // Load db & collections

     const db = MongoDB.getDB()

     const users = db.collection('users')



     try {

         // Run some sample operations

         // and pass users collection into models

         const newUser = await Users.createUser(users, seedUser)

         const listUsers = await Users.getUsers(users)

         const findUser = await Users.findUserById(users, newUser._id)



         console.log('CREATE USER')

         console.log(newUser)

         console.log('GET ALL USERS')

         console.log(listUsers)

         console.log('FIND USER')

         console.log(findUser)

     } catch (e) {

         throw e

     }



     const desired = true

     if (desired) {

         // Use disconnectDB for clean driver disconnect

         MongoDB.disconnectDB()

         process.exit(0)

     }

     // Server code anywhere above here inside connectDB()

 })

./users/index.js

 const ObjectID = require('mongodb').ObjectID



 // Notice how the users collection is passed into the models

 const createUser = async (users, user) => {

     try {

         const results = await users.insertOne(user)

         return results.ops[0]

     } catch (e) {

         throw e

     }

 }



 const getUsers = async (users) => {

     try {

         const results = await users.find().toArray()

         return results

     } catch (e) {

         throw e

     }

 }



 const findUserById = async (users, id) => {

     try {

         if (!ObjectID.isValid(id)) throw 'Invalid MongoDB ID.'

         const results = await users.findOne(ObjectID(id))

         return results

     } catch (e) {

         throw e

     }

 }



 // Export garbage as methods on the Users object

 module.exports = { createUser, getUsers, findUserById }

go-oleg is basically right, but in these days you (probably) dont want use "mongodb" itself, rather use some framework, which will do a lot of "dirty work" for you.

For example, mongoose is one of the most common. This is what we have in our initial server.js file :

const mongoose = require('mongoose');

const options = {server: {socketOptions: {keepAlive: 1}}};

mongoose.connect(config.db, options);

This is everything what is needed to set it up. Now use this anywhere in your code

const mongoose = require('mongoose');

And you get that instance you set up with mongoose.connect

Initialize the connection as a promise:

const MongoClient = require('mongodb').MongoClient

const uri = 'mongodb://...'

const client = new MongoClient(uri)

const connection = client.connect() // initialized connection

And then call the connection whenever you wish you perform an action on the database:

    // if I want to insert into the database...

    const connect = connection

    connect.then(() => {

        const doc = { id: 3 }

        const db = client.db('database_name')

        const coll = db.collection('collection_name')

        coll.insertOne(doc, (err, result) => {

            if(err) throw err

        })

    })