Odtnhj

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
 )
 )