How to Build CRUD Application using Node.js and MongoDB?

How to Build CRUD Application using Node.js and MongoDB?

This Node.js MongoDB tutorial explains how to build CRUD Application using Node.js and MongoDB. Node.js is the most popular JavaScript framework, Node.js Professionals often opt for a NoSQL database which can keep up with Node.js speed. MongoDB is a perfect fit for this kind of requirement as it has a very fast development cycle and performs quite efficiently. How effortlessly you can develop an application using Node.js with MongoDB from scratch.

Node.js is the most popular JavaScript framework when it comes to high-speed application development. Node.js Professionals often opt for a NoSQL database which can keep up with Node.js speed all while maintaining the performance of the application. MongoDB is a perfect fit for this kind of requirement as it has a very fast development cycle and performs quite efficiently. Thus, I bring you this Node.js MongoDB tutorial where I will be demonstrating how effortlessly you can develop an application using Node.js with MongoDB from scratch.

Below are the topics I will be covering in this Node.js MongoDB tutorial:

  • What is NoSQL Database?
  • Introduction to MongoDB
  • Node.js MongoDB Demo

So, let’s get started.

What is NoSQL Database?

Not only SQL database or more popularly known as NoSQL database is a database design approach that provides a mechanism to store and access a wide variety of unstructured data. This unstructured data can contain a mixture of data models, including key-value, document, columnar and graph formats, etc. NoSQL database is especially useful for handling humongous sets of distributed data. These databases have a dynamic schema and no specific query language along with no or very fewer relationships. But it stores the data in the form of collections and documents which enable quick updates.

There is a list of NoSQL databases which are used quite heavily in the industry, some of which I have listed below:

  1. MongoDB
  2. Hbase
  3. Cassandra
  4. Amazon SimpleDB
  5. Hypertable

In this article, I will be focusing on only one of these databases, which by now you might have guessed, that is MongoDB. But before I show you how to work with it, let’s get familiar with its nitty-gritty.

Introduction to MongoDB

MongoDB is an open source non-relational database that stores the data in the form of collections and documents. This kind of databases preserves most of the functionalities while offering horizontal scalability. This eases the work of a developer by providing persistence to the data and enhancing agility.

MongoDB stores the JSON documents in the form of collections having dynamic schemas. It stores all the related information together which enhances the speed of query processing. This way, it also helps in bringing down the gap between the key-value stores and relational databases.

Below I have listed down a few of the most intriguing features of MongoDB:

  • Indexing: It makes use of indexes that helps in improving the search performance.
  • Replication: MongoDB distributes the data across different machines.
  • Ad-hoc Queries: It supports ad-hoc queries by indexing the BSON documents & using a unique query language.
  • Schemaless: It enhances the flexibility of the data and needs no script to modify or update data.
  • Sharding: It makes use of sharding which eases the deployment of very large data sets and provides high throughput operations.

Now that you are familiar with MongoDB, let’s move ahead with this article and see how simple it is to install MongoDB in the system.

MongoDB Installation

Step I: Download the latest version MongoDB server from its official site: https://www.mongodb.com/download-center/community

Step II: Next click on the ‘Server’ tab as shown in the below screenshot.

Step III: If you are looking for any specific version, you can select it from the drop-down list or you can just download the latest version.

Step IV: Select your OS from the drop down. Since I am working on Windows I will go for Windows 64 bit.

Step V: Now, select the package as MSI.

Step VI: Finally, click on ‘Download’ to begin the download process.

Step VII: Once downloaded, double click on the MSI file to open it and proceed with the installation wizard.

Step VIII: Now, in order to start the MongoDB server you have to run the .exe file and assign the database folder. To make the work easier, all you need to do is write down a few lines of code in a notepad file and save it with the .bat extension. In other words, you just need to create a batch file, which will start the MongoDB server for you without any hassle. To create the batch file type in the below code:

cd C:Program FilesMongoDBServer.0in (MongoDB path)
mongod.exe --dbpath F:MongoDBdata (database dump destination)

Now, whenever you want to launch the MongoDB server, all you need to do is double click this batch file and open the MongoDB Compass application.

Step IX: Next, you need to launch the ‘MongoDB Compass’ and agree to its terms of use.

Step X: Now you need to provide the server configurations and hit ‘Connect’.

Step XI: Next, click on ‘Create Database’.

Step XII: Now, provide a relevant name for your database and collection and hit ‘Create Database’.

I guess, now you are all set to get started with the practical part, so without any more delay let’s dive into the code.

Node.js MongoDB Demo

Here I will be creating a CRUD application for Course Management with the help of Node.js and Express.js and use MongoDB to store the data. In this application, I will be taking course details like name, id, duration, and fee as inputs. For that, I will be creating a few view files which will act as an interface. Then in order to handle the data, I will be needing a controller as well which will help in manipulating the data. Finally, I will be needing a few model files to store the data. So basically, I will be following an MVC pattern for this application development. So, lets now jump into development.

Our application will be having the following hierarchy:

NodejsMongoDbDemo

  • package.json
  • script.js
  • controllers
  1. courseController.js
  • img
  1. logo.jpg
  • models
  1. course.model.js
  2. mongodb.js
  • views
  1. course

a. courseAddEdit.hbs

b. list.hbs

2. layouts

  • mainLayout.hbs

So, let’s begin the application development by creating a directory for the project. Once you are done, open the command prompt and navigate to your project directory. Now you need to set up the project configurations for that, type in the below command and provide the necessary details:

npm init

Now, you need to install the required packages. So, in this project, I am using the below packages:

  • express.js: It is a web framework.
  • express-handlebars: It is a template engine and helps in creating client-side applications.
  • mongoose: Helps in communicating with MongoDB.
  • body-parser: Helps in converting the POST data into the request body.
  • nodemon: Helps in automatically restarting the server whenever the code changes.

In order to install these packages, type in the following command:

npm i --s express express-handlebars mongoose body-parser

Since I want to install nodemon such that it can access any file in the directory, I will be installing it with the global command:

npm i -g nodemon

Once you are done installing with the packages, your final JSON file should look like the below file:

package.json

{
"name": "samplenodemongo",
"version": "1.0.0",
"description": "Edureka demo on how to build a Node.js application with MongoDB",
"main": "script.js",
"scripts": {
"test": "echo "Error: no test specified" && exit 1"
},
"author": "Edureka",
"license": "ISC",
"dependencies": {
"body-parser": "^1.19.0",
"express": "^4.16.4",
"express-handlebars": "^3.0.2",
"mongoose": "^5.5.6",
"nodemon": "^1.19.0"
}
}

As you can see, in the dependencies section all the installed packages have been successfully listed. So, lets now create the database we will be using in this demo. For that start the batch file and open MongoDB application. Now, create a new database and provide a collection name. In my application, I will be using ‘EdurekaCoursesDB’ as the database name and ‘courses’ as the collection.

Now, switch back to your code editor where we will be creating the files to establish connectivity between Node.js and MongoDB. For that, first, you need to create a folder inside the project directory and name it ‘model’. Inside this folder, create a javascript file with the name ‘ mongodb.js ‘ and type in the below code:

mongodb.js

const mongoose = require('mongoose');
 
mongoose.connect('mongodb://localhost:27017/EdurekaCoursesDB', {useNewUrlParser: true}, (err) => {
if (!err) {
console.log('Successfully Established Connection with MongoDB')
}
else {
console.log('Failed to Establish Connection with MongoDB with Error: '+ err)
}
});
 
//Connecting Node and MongoDB
require('./course.model');

Now, you need to define the schema of your course database. For that, create a new JS file within the model folder and name it ‘ course.model.js ‘. So, I am using four fields in my course object I am using four fields which are name, id, duration, and fee. To create this file, type in the below-given code.

course.model.js

const mongoose = require('mongoose');
 
//Attributes of the Course object
var courseSchema = new mongoose.Schema({
courseName: {
type: String,
required: 'This field is required!'
},
courseId: {
type: String
},
courseDuration: {
type: String
},
courseFee: {
type: String
}
});
 
mongoose.model('Course', courseSchema);

Now, you need to create the root file called ‘ script.js ‘. This file is the entry point of this application and will contain all the connection paths in it. You need to be really careful while providing the paths in this file as it might result in an error or application failure. Along with this, it is also responsible for invoking the server and establish the connection. In order to create this file, type in the below code:

script.js

require('./models/mongodb');
 
//Import the necessary packages
const express = require('express');
var app = express();
const path = require('path');
const exphb = require('express-handlebars');
const bodyparser = require('body-parser');
 
const courseController = require('./controllers/courseController');
 
app.use(bodyparser.urlencoded({
extended: true
}));
 
//Create a welcome message and direct them to the main page
app.get('/', (req, res) => {
res.send('
 
<h2 style="font-family: Malgun Gothic; color: midnightblue ">Welcome to Edureka Node.js MongoDB Tutorial!!</h2>
 
 
 Click Here to go to <b> <a href="/course">Course Page</a> </b>');
});
app.use(bodyparser.json());
 
//Configuring Express middleware for the handlebars
app.set('views', path.join(__dirname, '/views/'));
app.engine('hbs', exphb({ extname: 'hbs', defaultLayout: 'mainLayout', layoutDir: __dirname + 'views/layouts/' }));
app.set('view engine', 'hbs');
 
//Establish the server connection
//PORT ENVIRONMENT VARIABLE
const port = process.env.PORT || 8080;
app.listen(port, () => console.log(`Listening on port ${port}..`));
 
//Set the Controller path which will be responding the user actions
app.use('/course', courseController);

Next, in order to handle the user requests, you need to create the router file. For that first, create a folder and name it ‘controller’ and within this folder create a file with the name ‘ courseController.js ‘. In this file, we will be dealing with the CRUD operations related to the employee. Below is the code for creating this file:

courseController.js

//Import the dependencies
const express = require('express');
const mongoose = require('mongoose');
//Creating a Router
var router = express.Router();
//Link
const Course = mongoose.model('Course');
 
//Router Controller for READ request
router.get('/',(req, res) => {
res.render("course/courseAddEdit", {
viewTitle: "Insert a New Course for Edureka"
});
});
 
//Router Controller for UPDATE request
router.post('/', (req,res) => {
if (req.body._id == '')
insertIntoMongoDB(req, res);
else
updateIntoMongoDB(req, res);
});
 
//Creating function to insert data into MongoDB
function insertIntoMongoDB(req,res) {
var course = new Course();
course.courseName = req.body.courseName;
course.courseId = req.body.courseId;
course.courseDuration = req.body.courseDuration;
course.courseFee = req.body.courseFee;
course.save((err, doc) => {
if (!err)
res.redirect('course/list');
else
console.log('Error during record insertion : ' + err);
});
}
 
//Creating a function to update data in MongoDB
function updateIntoMongoDB(req, res) {
Course.findOneAndUpdate({ _id: req.body._id }, req.body, { new: true }, (err, doc) => {
if (!err) { res.redirect('course/list'); }
else {
if (err.name == 'ValidationError') {
handleValidationError(err, req.body);
res.render("course/courseAddEdit", {
//Retaining value to be displayed in the child view
viewTitle: 'Update Course Details',
employee: req.body
});
}
else
console.log('Error during updating the record: ' + err);
}
});
}
 
//Router to retrieve the complete list of available courses
router.get('/list', (req,res) => {
Course.find((err, docs) => {
if(!err){
res.render("course/list", {
list: docs
});
}
else {
console.log('Failed to retrieve the Course List: '+ err);
}
});
});
 
//Creating a function to implement input validations
function handleValidationError(err, body) {
for (field in err.errors) {
switch (err.errors[field].path) {
case 'courseName':
body['courseNameError'] = err.errors[field].message;
break;
default:
break;
}
}
}
 
//Router to update a course using it's ID
router.get('/:id', (req, res) => {
Course.findById(req.params.id, (err, doc) => {
if (!err) {
res.render("course/courseAddEdit", {
viewTitle: "Update Course Details",
course: doc
});
}
});
});
 
//Router Controller for DELETE request
router.get('/delete/:id', (req, res) => {
Course.findByIdAndRemove(req.params.id, (err, doc) => {
if (!err) {
res.redirect('/course/list');
}
else { console.log('Failed to Delete Course Details: ' + err); }
});
});
 
module.exports = router;//Import the dependencies
const express = require('express');
const mongoose = require('mongoose');
//Creating a Router
var router = express.Router();
//Link
const Course = mongoose.model('Course');
 
//Router Controller for READ request
router.get('/',(req, res) => {
res.render("course/courseAddEdit", {
viewTitle: "Insert a New Course for Edureka"
});
});
 
//Router Controller for UPDATE request
router.post('/', (req,res) => {
if (req.body._id == '')
insertIntoMongoDB(req, res);
else
updateIntoMongoDB(req, res);
});
 
//Creating function to insert data into MongoDB
function insertIntoMongoDB(req,res) {
var course = new Course();
course.courseName = req.body.courseName;
course.courseId = req.body.courseId;
course.courseDuration = req.body.courseDuration;
course.courseFee = req.body.courseFee;
course.save((err, doc) => {
if (!err)
res.redirect('course/list');
else
console.log('Error during record insertion : ' + err);
});
}
 
//Creating a function to update data in MongoDB
function updateIntoMongoDB(req, res) {
Course.findOneAndUpdate({ _id: req.body._id }, req.body, { new: true }, (err, doc) => {
if (!err) { res.redirect('course/list'); }
else {
if (err.name == 'ValidationError') {
handleValidationError(err, req.body);
res.render("course/courseAddEdit", {
//Retaining value to be displayed in the child view
viewTitle: 'Update Course Details',
employee: req.body
});
}
else
console.log('Error during updating the record: ' + err);
}
});
}
 
//Router to retrieve the complete list of available courses
router.get('/list', (req,res) => {
Course.find((err, docs) => {
if(!err){
res.render("course/list", {
list: docs
});
}
else {
console.log('Failed to retrieve the Course List: '+ err);
}
});
});
 
//Creating a function to implement input validations
function handleValidationError(err, body) {
for (field in err.errors) {
switch (err.errors[field].path) {
case 'courseName':
body['courseNameError'] = err.errors[field].message;
break;
default:
break;
}
}
}
 
//Router to update a course using it's ID
router.get('/:id', (req, res) => {
Course.findById(req.params.id, (err, doc) => {
if (!err) {
res.render("course/courseAddEdit", {
viewTitle: "Update Course Details",
course: doc
});
}
});
});
 
//Router Controller for DELETE request
router.get('/delete/:id', (req, res) => {
Course.findByIdAndRemove(req.params.id, (err, doc) => {
if (!err) {
res.redirect('/course/list');
}
else { console.log('Failed to Delete Course Details: ' + err); }
});
});
 
module.exports = router;//Import the dependencies
const express = require('express');
const mongoose = require('mongoose');
//Creating a Router
var router = express.Router();
//Link
const Course = mongoose.model('Course');
 
//Router Controller for READ request
router.get('/',(req, res) => {
res.render("course/courseAddEdit", {
viewTitle: "Insert a New Course for Edureka"
});
});
 
//Router Controller for UPDATE request
router.post('/', (req,res) => {
if (req.body._id == '')
insertIntoMongoDB(req, res);
else
updateIntoMongoDB(req, res);
});
 
//Creating function to insert data into MongoDB
function insertIntoMongoDB(req,res) {
var course = new Course();
course.courseName = req.body.courseName;
course.courseId = req.body.courseId;
course.courseDuration = req.body.courseDuration;
course.courseFee = req.body.courseFee;
course.save((err, doc) => {
if (!err)
res.redirect('course/list');
else
console.log('Error during record insertion : ' + err);
});
}
 
//Creating a function to update data in MongoDB
function updateIntoMongoDB(req, res) {
Course.findOneAndUpdate({ _id: req.body._id }, req.body, { new: true }, (err, doc) => {
if (!err) { res.redirect('course/list'); }
else {
if (err.name == 'ValidationError') {
handleValidationError(err, req.body);
res.render("course/courseAddEdit", {
//Retaining value to be displayed in the child view
viewTitle: 'Update Course Details',
employee: req.body
});
}
else
console.log('Error during updating the record: ' + err);
}
});
}
 
//Router to retrieve the complete list of available courses
router.get('/list', (req,res) => {
Course.find((err, docs) => {
if(!err){
res.render("course/list", {
list: docs
});
}
else {
console.log('Failed to retrieve the Course List: '+ err);
}
});
});
 
//Creating a function to implement input validations
function handleValidationError(err, body) {
for (field in err.errors) {
switch (err.errors[field].path) {
case 'courseName':
body['courseNameError'] = err.errors[field].message;
break;
default:
break;
}
}
}
 
//Router to update a course using it's ID
router.get('/:id', (req, res) => {
Course.findById(req.params.id, (err, doc) => {
if (!err) {
res.render("course/courseAddEdit", {
viewTitle: "Update Course Details",
course: doc
});
}
});
});
 
//Router Controller for DELETE request
router.get('/delete/:id', (req, res) => {
Course.findByIdAndRemove(req.params.id, (err, doc) => {
if (!err) {
res.redirect('/course/list');
}
else { console.log('Failed to Delete Course Details: ' + err); }
});
});
 
module.exports = router;

Now, that we are done with backend files, the next step is to create the Views. For that first, you need to create a wrapper for the child views. But before that, create a folder with name ‘ views’. Inside this folder create two more folders with names ‘ course’ and ‘ layouts’ respectively with .hbs extension. Now, navigate inside the ‘layouts’ folder and create the wrapper with the name ‘ mainLayout.hbs’. This file will contain the basic skeleton of the application which will be reflected in the child views as well. In this file, I am inserting an image as well, so for that I will create a local folder with name img and save my image inside.

To create this file, type in the below codes:

mainLayout.hbs

<!DOCTYPE html>
<html>
<head>
<title>Edureka Node.js MongoDB Demo</title>
<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/4.0.0/css/bootstrap.min.css" integrity="sha384-Gn5384xqQ1aoWXA+058RXPxPg6fy4IWvTNh0E263XmFcJlSAwiGgFAW/dAiS6JXm" crossorigin="anonymous">
<img src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-wp-preserve="%3Cscript%20src%3D%22https%3A%2F%2Fajax.googleapis.com%2Fajax%2Flibs%2Fjquery%2F3.2.1%2Fjquery.min.js%22%3E%3C%2Fscript%3E" data-mce-resize="false" data-mce-placeholder="1" class="mce-object" width="20" height="20" alt="&lt;script&gt;" title="&lt;script&gt;" />
<img src="data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7" data-wp-preserve="%3Cscript%20src%3D%22https%3A%2F%2Fmaxcdn.bootstrapcdn.com%2Fbootstrap%2F3.3.7%2Fjs%2Fbootstrap.min.js%22%3E%3C%2Fscript%3E" data-mce-resize="false" data-mce-placeholder="1" class="mce-object" width="20" height="20" alt="&lt;script&gt;" title="&lt;script&gt;" />
</head>
 
<body class = "bg-info">
 
 
<div align="center">
<!-- Inserting the image -->
<img src="/static/edurekaLogo.png" alt="Edureka Logo">
</div>
 
 
 
 
<div class="row">
 
 
<div class="col-md-6 offset-md-3" style="background-color: #fff; margin-top: 40px; padding:20px;">
<!-- retrieving HTML String from the child Views -->
{{{body}}}
</div>
 
 
</div>
 
 
</body>
</html>

Finally, inside the course folder, we will be creating two child views, one of which will be used for course addition or update and the second view will display the complete list of the available courses. Let’s first focus on the first view i.e courseAddEdit.hbs which will look like the below screenshot.

So, let me now show, how to build this view.

As you can see in the screenshot, the page will be containing four input fields and two buttons. One button will be submitting details filled in by the user into the database and the second button will display the complete list of courses available in the database. In order to make sure that the inputs are correct, you need to add some validations as well. Once done, you will be able to see this view using ‘/course’ URL. Below is the code, you will be needing to create courseAddEdit.hbs file:

courseAddEdit.hbs

<!-- Obtaining value from the course controller -->
 
<h3>{{viewTitle}}</h3>
<form action="/course" method="POST">
<input type="hidden" name="_id" value="{{course._id}}">
 
<div class = "form-group">
<label>Course Name</label>
<input type="text" maxlength="100" class="form-control" name="courseName" placeholder="Course Name" value="{{course.courseName}}">
 
<div class="text-danger">
{{course.courseNameError}}</div>
</div>
<div class = "form-group">
<label>Course ID</label>
<input type="number" min='10000' max='99999' class="form-control" name="courseId" placeholder="Course Id" value="{{course.courseId}} " required>
</div>
<div class = "form-row">
<div class = "form-group col-md-6">
<label>Course Duration</label>
<input type="number" min='10' max='99' class="form-control" name="courseDuration" placeholder="Course Duration (Hrs)" "{{course.courseDuration}} " required>
</div>
<div class = "form-group col-md-6">
<label>Course Fee</label>
<input type="number" min='100' max="100000" class="form-control" name="courseFee" placeholder="Course Fee (USD)" "{{course.courseFee}} " required>
</div>
</div>
<div class="form-group">
<button type="submit" class="btn btn-info"><i class="fa fa-database"></i> Submit</button>
<a class="btn btn-secondary" href="/course/list"><i class="fa fa-list-alt"></i> View All Courses</a>
</div>
</form>

Now, let me show you the next view i.e list.hbs, which will retrieve the complete list of available courses from the database and display them on your screen:

In this view, I am using a table to display the list of courses. This table will have five columns where the first four will display the course details while the last column will enable you to edit/delete a record directly from the application interface. The controllers of these functions have been already created in the script.js file. So, the only thing left is to add the view and in order to do so create a list.hbs file and type in the below-written code.

list.hbs

<div>
<a class="btn btn-secondary" href="/course"><i class="fa fa-plus"></i> Create New</a> 
 
<h3 align="center">Edureka's Course List</h3>
</div>
<table class="table table-striped">
<thead>
<tr>
<th>Course Name</th>
<th>Course Id</th>
<th>Course Duration(Hrs)</th>
<th>Course Fee(USD)</th>
<th></th>
</tr>
</thead>
<tbody>
{{#each list}}
<tr align="center">
<td>{{this.courseName}}</td>
<td>{{this.courseId}}</td>
<td>{{this.courseDuration}}</td>
<td>{{this.courseFee}}</td>
<td>
<a href="/course/{{this._id}}"> Edit </a>
<a href="/course/delete/{{this._id}}" onclick="return confirm('Are you sure to delete this record ?');"> Delete </a>
</td>
</tr>
{{/each}}
</tbody>
</table>

This concludes are the coding part, now it’s time to test our application. For that, open the command prompt and navigate to the project folder or if you are using an IDE open the terminal and type in the below command to start the server.

nodemon script.js

Now you can launch your application in any browser at http://localhost:8080.

Once you have added your own data, you can go back in MongoDB and check whether the data has been added there or not. If you refer the below screenshot, you will see all my data has been successfully added. Which means my MongoDB is connected and working perfectly with my Node.js API.
With this, we come to an end of this Node.js MongoDB Tutorial. Hope I was able to keep the concepts clear and helped you in understanding how exactly MongoDB works with Node.js.

How to connect to MongoDB database from Node.js?

How to connect to MongoDB database from Node.js?

Use Node.js? Want to learn MongoDB? In today’s post, we’ll work through connecting to a MongoDB database from a Node.js script, retrieving a list of databases, and printing the results to your console.

In today’s post, we’ll work through connecting to a MongoDB database from a Node.js script, retrieving a list of databases, and printing the results to your console.

Set up

Before we begin, we need to ensure you’ve completed a few prerequisite steps.

Install Node.js

First, make sure you have a supported version of Node.js installed (the MongoDB Node.js Driver requires Node 4.x or greater and for these examples, I've used Node.js 10.16.3).

Install the MongoDB Node.js Driver

The MongoDB Node.js Driver allows you to easily interact with MongoDB databases from within Node.js applications. You’ll need the driver in order to connect to your database and execute the queries described in this Quick Start series.

If you don’t have the MongoDB Node.js Driver installed, you can install it with the following command.

npm install mongodb

At the time of writing, this installed version 3.3.2 of the driver. Running npm list mongodb will display the currently installed driver version number. For more details on the driver and installation, see the official documentation.

Create a free MongoDB Atlas cluster and load the sample data

Next, you’ll need a MongoDB database. Your database will be stored inside of a cluster. At a high level, a cluster is a set of nodes where copies of your database will be stored.

The easiest way to get started with MongoDB is to use Atlas, MongoDB’s fully-managed database-as-a-service. Head over to Atlas and create a new cluster in the free tier. Once your tier is created, load the sample data.

Get started with an M0 cluster on Atlas today. It's free forever, and it’s the easiest way to try out the steps in this blog series.

If you’re not familiar with how to create a new cluster and load the sample data, check out this video tutorial from MongoDB Developer Advocate Maxime Beugnet.

Get your cluster’s connection info

The final step is to prep your cluster for connection.

In Atlas, navigate to your cluster and click CONNECT. The Cluster Connection Wizard will appear.

The Wizard will prompt you to whitelist your current IP address and create a MongoDB user if you haven’t already done so. Be sure to note the username and password you use for the new MongoDB user as you’ll need them in a later step.

Next, the Wizard will prompt you to choose a connection method. Select Connect Your Application. When the Wizard prompts you to select your driver version, select Node.js and 3.0 or later. Copy the provided connection string.

For more details on how to access the Connection Wizard and complete the steps described above, see the official documentation.

Connect to your database from a Node.js application

Now that everything is set up, it’s time to code! Let’s write a Node.js script that connects to your database and lists the databases in your cluster.

Import MongoClient

The MongoDB module exports MongoClient, and that’s what we’ll use to connect to a MongoDB database. We can use an instance of MongoClient to connect to a cluster, access the database in that cluster, and close the connection to that cluster.

const {MongoClient} = require('mongodb');

Create our main function

Let’s create an asynchronous function named main() where we will connect to our MongoDB cluster, call functions that query our database, and disconnect from our cluster.

The first thing we need to do inside of main() is create a constant for our connection URI. The connection URI is the connection string you copied in Atlas in the previous section. When you paste the connection string, don’t forget to update <username> and <password> to be the credentials for the user you created in the previous section. Note: the username and password you provide in the connection string are NOT the same as your Atlas credentials.

/**
 * Connection URI. Update <username>, <password>, and <your-cluster-url> to reflect your cluster.
 * See https://docs.mongodb.com/ecosystem/drivers/node/ for more details
 */
const uri = "mongodb+srv://<username>:<password>@<your-cluster-url>/test?retryWrites=true&w=majority";

Now that we have our URI, we can create an instance of MongoClient.

const client = new MongoClient(uri);

Note: When you run this code, you may see DeprecationWarnings around the URL string parser and the Server Discover and Monitoring engine. If you see these warnings, you can remove them by passing options to the MongoClient. For example, you could instantiate MongoClient by calling new MongoClient(uri, { useNewUrlParser: true, useUnifiedTopology: true }). See the Node.js MongoDB Driver API documentation for more information on these options.

Now we’re ready to use MongoClient to connect to our cluster. client.connect() will return a promise. We will use the await keyword when we call client.connect() to indicate that we should block further execution until that operation has completed.

await client.connect();

Now we are ready to interact with our database. Let’s build a function that prints the names of the databases in this cluster. It’s often useful to contain this logic in well named functions in order to improve the readability of your codebase. Throughout this series, we’ll create new functions similar to the function we’re creating here as we learn how to write different types of queries. For now, let’s call a function named listDatabases().

await listDatabases(client);

Let’s wrap our calls to functions that interact with the database in a try/catch statement so that we handle any unexpected errors.

try {
    await client.connect();

    await listDatabases(client);

} catch (e) {
    console.error(e);
}

We want to be sure we close the connection to our cluster, so we’ll end our try/catch with a finally statement.

finally {
    await client.close();
}

Once we have our main() function written, we need to call it. Let’s send the errors to the console.

main().catch(console.err);

Putting it all together, our main() function and our call to it will look something like the following.

async function main(){
    /**
     * Connection URI. Update <username>, <password>, and <your-cluster-url> to reflect your cluster.
     * See https://docs.mongodb.com/ecosystem/drivers/node/ for more details
     */
    const uri = "mongodb+srv://<username>:<password>@<your-cluster-url>/test?retryWrites=true&w=majority";

    const client = new MongoClient(uri);

    try {
        // Connect to the MongoDB cluster
        await client.connect();

        // Make the appropriate DB calls
        await  listDatabases(client);

    } catch (e) {
        console.error(e);
    } finally {
        await client.close();
    }
}

main().catch(console.err);

List the databases in our cluster

In the previous section, we referenced the listDatabases() function. Let’s implement it!

This function will retrieve a list of databases in our cluster and print the results in the console.

async function listDatabases(client){
    databasesList = await client.db().admin().listDatabases();

    console.log("Databases:");
    databasesList.databases.forEach(db => console.log(` - ${db.name}`));
};

Save Your File

You’ve been implementing a lot of code. Save your changes, and name your file something like connection.js. To see a copy of the complete file, visit the nodejs-quickstart GitHub repo.

Execute Your Node.js Script

Now you’re ready to test your code! Execute your script by running a command like the following in your terminal: node connection.js

You will see output like the following:

Databases:
 - sample_airbnb
 - sample_geospatial
 - sample_mflix
 - sample_supplies
 - sample_training
 - sample_weatherdata
 - admin
 - local

What’s next?

Today, you were able to connect to a MongoDB database from a Node.js script, retrieve a list of databases in your cluster, and view the results in your console. Nice!

In future posts in this series, we’ll dive into each of the CRUD (create, read, update, and delete) operations as well as topics like change streams, transactions, and the aggregation pipeline, so you’ll have the tools you need to successfully interact with data in your databases.

In the meantime, check out the following resources:

Series versions

This examples in this article were created with the following application versions:

MongoDB: 4.0
MongoDB Node.js Driver: 3.3.2
Node.js: 10.16.3

How to Perform the CRUD Operations Using MongoDB and Node.js?

How to Perform the CRUD Operations Using MongoDB and Node.js?

In this intro to using MongoDB with Node.js, you'll learn the basics of how to connect to a MongoDB database using Node.js. And how to perform the CRUD Operations using MongoDB and Node.js

In this intro to using MongoDB with Node.js, Developer Advocate Lauren Schaefer walks through the basics of how to connect to a MongoDB database using Node.js. Then she gives a high-level explanation of how MongoDB stores data in documents and collections. Finally, she works through each of the CRUD (Create, Read, Update, and Delete operations). She explains how to use insertOne(), insertMany(), findOne(), find(), updateOne() with and without upsert, updateMany(), deleteOne(), and deleteMany().

Chapters:
00:00 Intro
00:40 Set Up
08:51 How MongoDB Stores Data
11:01 Creating Documents
20:04 Reading Documents
30:58 Updating Documents
45:52 Deleting Documents
51:07 Summary

How to Use MongoDB as a Real-time database with Node.js

How to Use MongoDB as a Real-time database with Node.js

Have you ever run into a scenario where you wanted to update your UI as soon as there is some change to your Mongo database

Have you ever run into a scenario where you wanted to update your UI as soon as there is some change to your Mongo database ? For example, A new user gets added and you wanted that change to reflect in you UI without having to make an API call or constantly polling for changes. If so, then this post is for you.

While the go to would be to use real time databases like firebase or RethinkDB, you actually can achieve this using your MongoDB too and it is pretty simple. MongoDB has something called [change streams](https://docs.mongodb.com/manual/changeStreams/) that allows you to listen to your database.

The method I’m going to show uses [replicaSets](https://docs.mongodb.com/manual/replication/) , you can also achieve the same using [sharded clusters](https://docs.mongodb.com/manual/sharding/). (click those links to read more about replicasets and sharded clusters)

  • So, the first step would be to convert your stand alone MongoDB to replica sets. This is because [change streams](https://docs.mongodb.com/manual/changeStreams/) is not available with standalone MongoDB (Honestly I was about to give up on seeing that, but trust me it’s simple).
$ mongod --port 27017 --replSet rs0

PS: Stop your current standalone mongo and then run the above command.

The above command starts your mongo instance as a [replicaSet](https://docs.mongodb.com/manual/replication/) named as rs0.

  • Now with your mongo running as [replicaSet](https://docs.mongodb.com/manual/replication/), before creating a new database we must initiate our replication set. To do so, open a new window and do the following
$ mongo
$ rs.initiate() 
  • Now let’s go and create our database. I use Robo 3T to manage my databases, you can create it in terminal using $use . I’m creating a db called UserDB.

Create a new Database

  • Now our DB part is set. Scaffold an Express application and install Mongoose. My User model looks like this,
var mongoose = require("mongoose");
var Schema = mongoose.Schema;

var UserSchema = new Schema({
  name: {
    type: String,
    required: [true, 'Need User name']
  }
});

var User = mongoose.model('User', UserSchema);

module.exports = User;

User model

  • Now assume I have two users inside my User collection of UserDB. Now I want to subscribe to my UserDB for any changes on User collection. In your app.js code, the mongoDB connection string should look like this,
require('./models/connection').connectMongoDB('mongodb://localhost/UserDB?replicaSet=rs0');

I’m passing my dbURL to my connection module. (we need to explicitly mention the replicaSet).

const socket_io = require('socket.io');
var io = socket_io();
const User = require('../models/User');

const changeStream = User.watch();

changeStream.on('change', (change) => {
    console.log(change); // You could parse out the needed info and send only that data. 
    io.emit('changeData', change);
}); 

io.on('connection', function () {
    console.log('connected');
});

var socket = io;
module.exports = socket;

I listen to the changes in User collection using the watch() method, and whenever there is any change, the change event listener provided by changeStreams gets fired. It accepts a callback function that receives the changed data as parameter.

We can go ahead and test it to see if it works. Run an update operation onUser collection and at the same time in another tab watch for the console.log messages of your app. You can see the changes real time. At this place, We can now forward this to the front end using socket.io

You’re mongoDB is now acting as a real time DB

_Thank you for reading. If you enjoyed this article, please share it with others who may enjoy it as well.!