Ufdjrw

I am creating a Node/Express API server to use as a backend for a React single page application. Currently, I am using the MongoDB Node.js driver (not mongoose) to connect to my MongoDB instance.

My question is where is the correct place to store MongoDB queries (insertOne, FindOne, etc...)? I am hoping that someone with experience in a production team can give some insight.

So far I have been given some advice from people with similar experience, but there seems to be quite a lot of contradiction. Here are the two main practices I've seen:

1. Connect to MongoDB and query inside controller functions.

I have been told that it is okay to connect and query the database from inside the controller functions. Here is an example of how that would look:

App structure:

├── app.js
├── controllers
│   └── users.js
├── db
│   └── mongodb.js
├── routes
│   └── users.js

Connect to MonogoDB in several functions inside /controllers, reusing the same connection throughout the application as recommended. Here is an example /controllers/users.js:

import initMongo from '../db/mongodb';

export const registerUser = (req, res) => 
 initMongo().then((db) => 
 // Register User Code Here
 );
;


export const loginUser = (req, res) => 
 initMongo().then((db) => 
 // Login User Code Here
 );
;

Here is an example `/db/mongodb.js':

import MongoClient from 'mongodb';

let cachedDb = null;

/**
 * @description Initialzies the DB instance.
 *
 * @returns Promise A resolved promise with the DB instance.
 */
export default () => 
 if (cachedDb && cachedDb.serverConfig.isConnected()) 
 return Promise.resolve(cachedDb);
 

 return MongoClient.connect(process.env.MONGO_URL, 
 useNewUrlParser: true,
 ).then(client => 
 cachedDb = client.db('databaseName');
 return Promise.resolve(cachedDb);
 );
;

The controller functions are then called by specific routes in /routes/users.js, like so:

router.post('/register', registerUser);
router.post('/login', loginUser);

2. Create a Models folder and store all DB queries there:

I have also been told to break the DB queries out into a models folder and then reference the queries from there in your controllers like so:

App Structure

├── app.js
├── controllers
│   └── users.js
├── db
│   └── mongodb.js
├── models
│   └── users.js
├── routes
│   └── users.js

Sample /controllers/users.js file:

import UserModel from '../models/users';

export const registerUser = (req, res) => 
 const user = new UserModel();
 user.createUser(req.body.user);
;

Sample /models/users.js file:

export default function User() 
 this.createUser = (newUser) => 
 // MongoDB insertOne Query
 

Is there any benefit to using one of these methods of the other? Is there a recommended way in a multi-person production team? Am I an idiot and should just be using Mongoose?

I would also love to hear opinions on which method would be easier for unit testing with a platform such as Jest.