Building a CRUD API with Node.js, Express, and MongoDB: A Comprehensive Guide

In this tutorial, we will learn how to build a complete RESTful CRUD API from scratch using Node.js, Express, and MongoDB. This guide is designed for beginners who want to understand the basics of backend development and how to create a simple CRUD application.

Prerequisites

Before we start, ensure you have the following installed on your machine:

• Node.js: Download and install from nodejs.org.
• Visual Studio Code: A code editor to write your application.

Setting Up the Project

1. Create a Project Folder: Create a new folder for your CRUD app.
2. Open Command Prompt: Navigate to your project folder and open the command prompt.
3. Initialize the Project: Run the command npm init -y to create a package.json file.

Creating the Server

1. Create the Main File: Create a file named index.js. This will be the main file for our backend.
2. Set Up Express: Install Express by running npm install express. Then, set up a basic Express server in index.js:

   const express = require('express');
   const app = express();
   const PORT = 3000;
   
   app.listen(PORT, () => {
       console.log(`Server is running on port ${PORT}`);
   });
   

3. Test the Server: Run the server using node index.js and visit http://localhost:3000 in your browser to see if it’s running.

Setting Up MongoDB

1. Create a MongoDB Atlas Account: Go to MongoDB Atlas and create an account.
2. Create a New Project: Once logged in, create a new project and set up a free cluster.
3. Create a Database User: Set up a username and password for your database.
4. Get the Connection String: Copy the connection string provided by MongoDB Atlas, which will be used to connect your application to the database.

Connecting to MongoDB

1. Install Mongoose: Run npm install mongoose to install Mongoose, which will help us interact with MongoDB.
2. Connect to MongoDB: In index.js, add the following code to connect to your MongoDB database:

   const mongoose = require('mongoose');
   mongoose.connect('your_connection_string', { useNewUrlParser: true, useUnifiedTopology: true })
       .then(() => console.log('Connected to MongoDB'))
       .catch(err => console.error('Could not connect to MongoDB', err));
   

Creating the Product Model

1. Create a Models Folder: Inside your project folder, create a folder named models.
2. Create Product Model: Inside the models folder, create a file named product.js and define the product schema:

   const mongoose = require('mongoose');
   
   const productSchema = new mongoose.Schema({
       name: { type: String, required: true },
       quantity: { type: Number, default: 0 },
       price: { type: Number, required: true },
       image: { type: String, required: false },
   }, { timestamps: true });
   
   const Product = mongoose.model('Product', productSchema);
   module.exports = Product;
   

Implementing CRUD Operations

Create a Product

1. Set Up Routes: Create a folder named routes and a file named productRoutes.js inside it.
2. Define Routes: In productRoutes.js, set up the route to create a product:

   const express = require('express');
   const router = express.Router();
   const Product = require('../models/product');
   
   router.post('/products', async (req, res) => {
       const product = new Product(req.body);
       try {
           await product.save();
           res.status(201).send(product);
       } catch (error) {
           res.status(400).send(error);
       }
   });
   
   module.exports = router;
   

3. Use the Routes: In index.js, import and use the routes:

   const productRoutes = require('./routes/productRoutes');
   app.use(express.json()); // Middleware to parse JSON
   app.use('/api', productRoutes);
   

Read Products

1. Get All Products: Add a route to fetch all products in productRoutes.js:

   router.get('/products', async (req, res) => {
       try {
           const products = await Product.find();
           res.send(products);
       } catch (error) {
           res.status(500).send(error);
       }
   });
   

2. Get Single Product: Add a route to fetch a single product by ID:

   router.get('/products/:id', async (req, res) => {
       try {
           const product = await Product.findById(req.params.id);
           if (!product) return res.status(404).send();
           res.send(product);
       } catch (error) {
           res.status(500).send(error);
       }
   });
   

Update a Product

1. Update Route: Add a route to update a product:

   router.put('/products/:id', async (req, res) => {
       try {
           const product = await Product.findByIdAndUpdate(req.params.id, req.body, { new: true });
           if (!product) return res.status(404).send();
           res.send(product);
       } catch (error) {
           res.status(400).send(error);
       }
   });
   

Delete a Product

1. Delete Route: Add a route to delete a product:

   router.delete('/products/:id', async (req, res) => {
       try {
           const product = await Product.findByIdAndDelete(req.params.id);
           if (!product) return res.status(404).send();
           res.send(product);
       } catch (error) {
           res.status(500).send(error);
       }
   });
   

Testing the API

To test the API, you can use tools like Postman or Insomnia. Here’s how to test each operation:

• Create: Send a POST request to http://localhost:3000/api/products with a JSON body containing product details.
• Read: Send a GET request to http://localhost:3000/api/products to fetch all products or http://localhost:3000/api/products/:id for a specific product.
• Update: Send a PUT request to http://localhost:3000/api/products/:id with updated product details.
• Delete: Send a DELETE request to http://localhost:3000/api/products/:id to remove a product.

Conclusion

In this tutorial, we built a complete CRUD API using Node.js, Express, and MongoDB. We covered the setup, coding, and testing of the API, including best practices for structuring the application. With this knowledge, you can now create your own backend applications and expand your skills in web development.