14 Oct How to Build a REST API with NodeJS: A Beginner’s Guide

Building a REST API is a foundational skill for any developer looking to create web applications or microservices. With Node.js, creating an API is fast, efficient, and relatively simple, especially when using tools like Express.js. In this guide, we’ll walk through the process of building a basic REST API using Node.js, Express.js, and MongoDB. By the end, you’ll have a working API that can handle Create, Read, Update, and Delete (CRUD) operations.

What is a REST API?

A REST API (Representational State Transfer) is an architectural style that allows communication between client and server over HTTP. It’s based on standard HTTP methods like GET, POST, PUT, and DELETE, making it easy to use and understand. REST APIs are widely used in web development because they are lightweight, scalable, and language-agnostic, which means any client that can make HTTP requests can interact with them.

Why Use NodeJS for Building REST APIs?

Node.js is an excellent choice for building REST APIs for several reasons:

1. Asynchronous and Non-Blocking: Node.js handles I/O operations asynchronously, making it efficient for handling multiple requests simultaneously.

2. Fast Development: With Express.js (a lightweight framework built on top of Node.js), you can quickly set up routes and middleware to handle API requests.\

3. JavaScript Everywhere: Node.js allows you to use JavaScript on both the client and server sides, which simplifies development for teams already familiar with JS.

The Stack We’ll Use

For this guide, we’ll use the following tools:

• Node.js: Our runtime for building the API.
• Express.js: A web framework that simplifies handling HTTP requests and routing.
• MongoDB: A NoSQL database that will store our data.
• Mongoose: An ODM (Object Data Modeling) library for MongoDB, making it easy to work with MongoDB from Node.js.

Setting Up the Project

Before we dive into the code, let’s set up the project.

1. Install Node.js: If you haven’t installed Node.js yet, you can download it from Node.js official website.
2. Create a New Project: Open your terminal and create a new directory for your project:

mkdir my-rest-api cd my-rest-api

3. Initialize npm: Initialize your project with npm (Node Package Manager) to create a package.json file:

npm init -y

4. Install Dependencies: We’ll need to install Express, Mongoose, and a few other dependencies:

npm install express mongoose body-parser nodemon

• express: Our framework for building the API.
• mongoose: For interacting with MongoDB.
• body-parser: To handle JSON request bodies.
• nodemon: To automatically restart the server when you make changes (for development purposes).

Here’s how we’ll structure our project:

my-rest-api/ │ ├── models/ │   └── post.js ├── routes/ │   └── posts.js ├── app.js ├── package.json 

• models/: Contains our Mongoose model (Post).
• routes/: Contains the API routes.
• app.js: Our main entry point for the application.

Step 1: Set Up Express

In your app.js file, you’ll want to set up Express and configure middleware like body-parser to handle JSON:

const express = require('express'); const mongoose = require('mongoose'); const bodyParser = require('body-parser'); const app = express(); require('dotenv/config');  // Middleware app.use(bodyParser.json());  // Import Routes const postsRoute = require('./routes/posts'); app.use('/posts', postsRoute);  // Routes app.get('/', (req, res) => {   res.send('Welcome to our API!'); });  // Connect to MongoDB mongoose.connect(   process.env.DB_CONNECTION,   { useNewUrlParser: true, useUnifiedTopology: true },   () => console.log('Connected to MongoDB') );  // Start the server app.listen(3000, () => {   console.log('Server is running on http://localhost:3000'); }); 

Step 2: Define the Mongoose Model

Next, let’s create a Mongoose model for the data we’ll store. For this example, we’ll create a simple blog post model.

In the models/post.js file:

const mongoose = require('mongoose');  const PostSchema = mongoose.Schema({   title: {     type: String,     required: true   },   description: {     type: String,     required: true   },   date: {     type: Date,     default: Date.now   } });  module.exports = mongoose.model('Post', PostSchema); 

This schema defines what a “post” will look like in our MongoDB collection.

Step 3: Create API Routes

Now, let’s create the routes that will handle the CRUD operations. These routes will reside in the routes/posts.js file.

const express = require('express'); const router = express.Router(); const Post = require('../models/post');  // GET ALL POSTS router.get('/', async (req, res) => {   try {     const posts = await Post.find();     res.json(posts);   } catch (err) {     res.json({ message: err });   } });  // GET SPECIFIC POST router.get('/:postId', async (req, res) => {   try {     const post = await Post.findById(req.params.postId);     res.json(post);   } catch (err) {     res.json({ message: err });   } });  // CREATE A NEW POST router.post('/', async (req, res) => {   const post = new Post({     title: req.body.title,     description: req.body.description   });    try {     const savedPost = await post.save();     res.json(savedPost);   } catch (err) {     res.json({ message: err });   } });  // DELETE A POST router.delete('/:postId', async (req, res) => {   try {     const removedPost = await Post.remove({ _id: req.params.postId });     res.json(removedPost);   } catch (err) {     res.json({ message: err });   } });  // UPDATE A POST router.patch('/:postId', async (req, res) => {   try {     const updatedPost = await Post.updateOne(       { _id: req.params.postId },       { $set: { title: req.body.title } }     );     res.json(updatedPost);   } catch (err) {     res.json({ message: err });   } });  module.exports = router; 

Step 4: Connect to MongoDB

To connect to a MongoDB database, you’ll need to set up a MongoDB cluster. You can use MongoDB Atlas for a free cloud-based solution or install MongoDB locally.

Once you have your MongoDB URI, store it in a .env file in the root of your project:

DB_CONNECTION=mongodb+srv://<username>:<password>@cluster0.mongodb.net/myFirstDatabase?retryWrites=true&w=majority 

Step 5: Testing the API

With everything set up, you can now run your server using nodemon:

npx nodemon app.js 

Your API will be running on http://localhost:3000.

Sample Requests

1. GET All Posts:

GET http://localhost:3000/posts 

2. POST a New Post:

POST http://localhost:3000/posts Content-Type: application/json  {   "title": "My first post",   "description": "This is a description of my first post" } 

3. GET a Specific Post:

GET http://localhost:3000/posts/<postId> 

4. UPDATE a Post:

PATCH http://localhost:3000/posts/<postId> Content-Type: application/json  {   "title": "Updated title" } 

5. DELETE a Post:

DELETE http://localhost:3000/posts/<postId> 

Conclusion

Congratulations! You’ve just built a simple REST API using Node.js, Express.js, and MongoDB. This API can handle CRUD operations for blog posts, but the same principles can be applied to almost any kind of application that needs a back-end. By learning how to build REST APIs, you’ve gained a key skill that will serve you well in modern web development. Now, go ahead and experiment with new features, add more routes, or even build out a front-end to interact with your API. Happy coding!