NodeJS MongoDB REST API

Building RESTful API using NodeJS and MongoDB (Express, Body-Parser & Mongo Driver)

blogs/technical/nodejs-mongodb-rest-api/nodejs-mongodb-rest-api.jpg

I am taking this opportunity to provide some programming options for a  popular topic of REST (REST stands for REpresentational State Transfer. When a RESTful API is called, the server will transfer to the client a representation of the state of the requested resource) API (Application Programming Interface) for those who wish to use a micro service based modular application. In this article I am going to use **JavaScript** (JS) as my preferred language, and I will show how to develop a custom **RESTful** API using **NodeJS** and **MongoDB**.

## Prerequisites:

1.  Install Node.js by following the appropriate guidelines for your local machine from [NodeJS](https://nodejs.org/en/download/).
2.  Signup for [MongoDB Atlas](https://www.mongodb.com/cloud/atlas) which is a offering from MongoDB on cloud with database as a service. It offers us a free sandbox environment so that we can utilise on building our REST API.
3.  Code Editor like [Visual Studio Code](https://code.visualstudio.com/) or [IntelliJ](https://www.jetbrains.com/idea/) (I used IntelliJ for all my development work)

## Create your NodeJS project

Create an application folder where our application code will reside. To initialize a NodeJS application use node package manager and type the following command. Complete the project name, description and license information
```
npm init
```
On completion the ```package.json``` file will be created inside your application folder

## Install application dependencies

For purpose of this project we will need to install the following node package dependencies 

 - [Express](https://expressjs.com/) (web application framework)
 - [Body-Parser](https://www.npmjs.com/package/body-parser) (middleware to parse incoming request bodies)
 - [MongoDB](https://www.npmjs.com/package/mongodb) driver (to communicate and run queries with MongoDB Atlas)
 - [Dotenv](https://www.npmjs.com/package/dotenv) (to load your environment variables from .env file)
 - [Nodemon](https://www.npmjs.com/package/nodemon) (a development tool automatically restarting the node application when file changes in the directory are detected)

```
npm install express mongodb body-parser
```

## Configure application start up for development
Modify the ```pacakge.json``` to enabled ```nodemon```

```
"start": "nodemon server.js"
```

## Build application skeleton

Open your IDE and create a file called ```server.js``` which will be the main entry point to the application. Let's add the following lines in the code
```
// Import express  
const express = require('express');  
// Import Body parser  
const bodyParser = require('body-parser');  
// Initialise the app  
const app = express();  
  
// Configure bodyparser to handle requests  
app.use(bodyParser.urlencoded({  
    extended: true  
}));  
app.use(bodyParser.json());

// Import dotenv and configure
const dotenv = require('dotenv');  
dotenv.config();  
  
// Read port number from .env file
const port = process.env.PORT;  
  
// Start the server on above port#
app.listen(port , function() {  
    console.log('RESTful API server started on: ' + port);  
});
```
In above code segment, I have initialised the express framework and configure the body-parser, to parse incoming pieces of data. I used the express framework to start the server at a given port read from a .env file using dotenv package.

## Adding MongoDB connection
Let's create a file called ```db.js``` and add our MongoDB driver code and queries
```
// Filename db.js
const MongoClient = require('mongodb').MongoClient;  
let atlas_connection_uri;  
let cachedDb = null;  
  
module.exports.get = async function () {  
  //Getting MONGODB ATLAS CONNECTION URI from environment file .env
  atlas_connection_uri = process.env.MONGODB_ATLAS_CLUSTER_URI;  
  
  // Read database name from environment file .env
  var database = process.env.DB_NAME;  
  
    if (cachedDb) {  
        return Promise.resolve(cachedDb);  
    }  
    const client = await MongoClient.connect(atlas_connection_uri, { useNewUrlParser: true, useUnifiedTopology: true });  
    cachedDb = client.db(database);  
    return cachedDb;  
};  
```
In above I have established a MongoClient connection to Mongo ATLAS DB which I read from my environment file .env. Also I kept a global connection variable called `'cachedDb'` to cache DB connection to optimise the number of connections to the database.
Then we will define a bunch of operations to find, update, insert documents using MongoDB driver functions, You can find documentation for these in MongoDB [API documentation](https://mongodb.github.io/node-mongodb-native/3.6/api/)
```  
module.exports.findDocument = async function (db, collection, query) {  
    return await db.collection(collection).findOne(query);  
};  
  
module.exports.findDocuments = async function (db, collection, query, sort) {  
    return await sort ? db.collection(collection).find(query).sort(sort).toArray() : db.collection(collection).find(query).toArray();  
};  
  
module.exports.findDistintValues = async function (db, collection, field, query) {  
    return await db.collection(collection).distinct(field, query);  
};  
  
module.exports.findSequence = async function(db, collection, query) {  
    const update = { "$inc": { "sequence": 1 } };  
    const options = { "returnNewDocument": true };  
    var response = await db.collection(collection).findOneAndUpdate(query, update, options);  
    return JSON.parse(JSON.stringify(response)).value;  
};  
  
module.exports.insertDocument = async function (db, collection, document) {  
    return await db.collection(collection).insertOne(document);  
};  
  
module.exports.updateDocument = async function (db, collection, query, update) {  
    return await db.collection(collection).updateOne(query, update);  
};
```

## Adding an endpoint route

Now let's connect the application with MongoDB by adding a route file `'router.js'` and registering the route with the application which will be starting with an endpoint called `'/api'`

```
// Import routes  
let apiRoutes = require("./router");

// Use Api routes in the App  
app.use('/api', apiRoutes);
```
In our route file let's add a POST and GET endpoint to add and retrieve active menu list for our application
```
// Filename: router.js  
// Initialize express router  
const router = require('express').Router();  
const db = require('./db');  
  
// Post a menu   
router.post('/submitMenu', async function (req, res) {  
    const database = await db.get();  
    const collection = "menu";  
    let menu = req.body;  
    const result = await db.insertDocument(database, collection, menu);  
    res.json({  
        status: 'success',  
        message: 'Menu List retrieved successfully',  
        data: result
  });  
});

// Get menuList response  
router.get('/menuList/:active', async function (req, res) {  
    const database = await db.get();  
    const collection = "menu";  
    let active = (req.params.active === 'true');  
    const docs = await db.findDocuments(database, collection, {"active" : active}, {"sequence": 1});  
    console.log("Menu List : " + JSON.stringify(docs));  
    res.json({  
        status: 'success',  
        message: 'Menu List retrieved successfully',  
        data: docs  
  });  
});
```
In above code first I have defined a POST endpoint to `/submitMenu` to insert a menu details submitted from browser. After that I have derfined a GET endpoint which will listen to `/menuList` and a request parameter called active whcih we expect to have boolean value (true/false). 

Finally make sure we add our environment variables in ```.env``` file

```
# .env
NODE_ENV=development
PORT=PORT_NUMBER
# Set your database/API connection information here
MONGODB_ATLAS_CLUSTER_URI=ATLAS_DB_URL_CONNECTION
DB_NAME=DATABASE_NAME
```

## Test the APIs

Now, things are starting to come together. Let’s test out our application.
First let's start our application
```
npm start
```

Then use cURL command to send a POST submission request to the endpoint

```
curl -X POST \
    -H 'content-type:application/json' \
    -d '{"sequence":"1", "name": "Home", "link": "/", "active": "true"}' \
    http://localhost:PORT_NUMBER/submitMenu
```

If we do not receive any errors, we’ll see the menu document for Home page added into MongoDB database of `DATABASE_NAME` and under collection menu. Feel free to add more documents to your collection.

Let’s test our GET endpoint using cURL, a command-line tool for transferring data and supports HTTP; a very good ad-hoc tool for testing REST services.

```
curl -X GET http://localhost:PORT_NUMBER/menuList/true
data:
{
    "sequence":"1", 
    "name": "Home", 
    "link": "/", 
    "active": "true"
}
```

## Conclusion

In this tutorial, we’ve learned how to develop a REST API and connect it with MongoDB to fetch and manipulate the data. You can try out other MongoDB functions to explore further. 
