Beginner's Tutorial for CRUD Operations in NodeJS and MongoDB
Tags: webdev, javascript, programming, tutorial
Published: 2024-07-16 21:40:48

## Introduction

CRUD operations stand for Create, Read, Update, and Delete. This procedure allows you to work with data from the MongoDB database.

With these four operations, you can create, read, update, and delete data in MongoDB.


## What is MongoDB

[MongoDB](https://www.mongodb.com/) is a powerful and flexible solution for handling modern data needs. As a leading [NoSQL database](https://www.mongodb.com/resources/basics/databases/nosql-explained), MongoDB offers a dynamic schema design, enabling developers to store and manage data in a way that aligns seamlessly with contemporary application requirements.

## What is Nodejs

[Node.js](https://nodejs.org/en/about) is a runtime environment that allows you to run JavaScript on the server side, rather than just in the browser. It's built on Chrome's V8 JavaScript engine, making it fast and efficient. With Node.js, you can build scalable network applications easily, using a single programming language for both client and server-side code. It's especially good for handling many simultaneous connections and real-time applications like chat servers or online games.

## Prequisite

- 
Install Node.js: Download and install Node.js from the official [website](https://nodejs.org/en/about) if you haven't already.

- 
Install MongoDB: Install MongoDB on your machine. Follow the instructions on the official MongoDB [website](https://www.mongodb.com/).

## Step 1: Initialize a new project



Open your preferred code editor (VS code) and cd into the directory where you want to create the project, then enter the command below to create a new project. 

```
npm init
```
Next, use the command below to install the necessary packages.

```
 npm install express mongodb
```
To ensure that everything is working properly, add '"serve": "node index.js"' beneath the script in the package.JSON for starting the program. 


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/12kx8hhxmx8q55p6411q.PNG)

## Create and test express.js server

In the root directory create an `index.js` file and enter the following code in it. 

```
const express = require('express')
const app = express()

app.listen(3000, () =>{
    console.log('Server is running on port 3000')
});

app.get('/', (req, res) =>{
    res.send("Hello Node API")
})
```
In this code, we create a basic Node.js server using the Express framework, which listens on port 3000. When you visit the root URL ("/"), it responds with the message "Hello Node API".

Now run the application with the command 'npm run serve' to observe the results, as shown below.


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/dh0vrvk32qnd8pefexdu.PNG)

To test if the server is working enter` localhost:3000` on the browser and see the results as shown below.


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/pvpcbm2hp6eu5tvitxba.PNG)

## Creating MongoDB connection

Visit[ mongodb](https://www.mongodb.com/) and sign in into your account or create one if not yet.

Create a new project.  Give it a name and click "Create Project."


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/alrubq6ot9x8cb987tr2.PNG)

Click the Create button, and then select the free m0 template. Scroll down, give your cluster a name, and click Create deployment.


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/m8exxrnrm5i6pu4nnsvr.PNG)


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/530ah5f8spqwi0fih291.PNG)

On the following screen, enter a username and password for your cluster; make sure to copy or remember the password. Click Create Database user. 

After that click on the Choose a connection method button and select Connect
![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/b0p4g1h3ya512mfd7k63.PNG) via drivers, copy the connection string.

To access mongodb we need a dependency called mongoose, so make sure to install it ` npm i mongoose` and add it at the top in the `index.js` file `const mongoose = require('mongoose');`.

Create a `db.js` file in the root directory and paste the following code, replacing <password> with the password you created.

```
const mongoose = require('mongoose');

mongoose.connect("mongodb+srv://admindan:admin1234@crudbackend.5goqnqm.mongodb.net/?retryWrites=true&w=majority&appName=crudbackend")
.then(() => {
    console.log('Connected to the database');
})
.catch((error) => {
    console.log('Connection failed', error);
});

module.exports = mongoose;
```

Import `const mongoose = require('./db');` at the top of the `index.js` file


To test if the database is connecting run the application and you should see results on the terminal as shown below.


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/whebactnow9cddqez5eu.PNG)

## Creating CRUD functions

Now that we've our database connected, we need a model to store our data in the mongodb. 

Make a models folder in the root directory, then create a file called "product.model.js" and insert the following code into it.

```
const mongoose = require("mongoose");

const ProductSchema = mongoose.Schema(
  {
    name: {
      type: String,
      required: [true, "Please enter product name"],
    },

    quantity: {
      type: Number,
      required: true,
      default: 0,
    },

    price: {
      type: Number,
      required: true,
      default: 0,
    },

    image: {
      type: String,
      required: false,
    },
  },
  {
    timestamps: true,
  }
);


const Product = mongoose.model("Product", ProductSchema);

module.exports = Product;
```

- 

## Create: defining a function to insert data into mongodb

We're creating a function for storing data in our MongoDB collection. Create a controllers folder in the root directory and a file called 'product.controller.js' within it. Paste the following code in it.

```
const Product = require("../models/product.model");

const getProducts = async (req, res) => {
  try {
    const products = await Product.find({});
    res.status(200).json(products);
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
};

const getProduct = async (req, res) => {
  try {
    const { id } = req.params;
    const product = await Product.findById(id);
    res.status(200).json(product);
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
};

const createProduct = async (req, res) => {
  try {
    const product = await Product.create(req.body);
    res.status(200).json(product);
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
};

const updateProduct = async (req, res) => {
  try {
    const { id } = req.params;

    const product = await Product.findByIdAndUpdate(id, req.body);

    if (!product) {
      return res.status(404).json({ message: "Product not found" });
    }

    const updatedProduct = await Product.findById(id);
    res.status(200).json(updatedProduct);
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
};

const deleteProduct = async (req, res) => {
  try {
    const { id } = req.params;

    const product = await Product.findByIdAndDelete(id);

    if (!product) {
      return res.status(404).json({ message: "Product not found" });
    }

    res.status(200).json({ message: "Product deleted successfully" });
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
};

module.exports = {
  getProducts,
  getProduct,
  createProduct,
  updateProduct,
  deleteProduct,
};
```
In this code, we define CRUD operations for our Product model It includes:

- 
getProducts: Fetches all products.

- 
getProduct: Fetches a product by its ID.

- 
createProduct: Creates a new product with provided data.

- 
updateProduct: Updates a product by its ID.

- 
deleteProduct: Deletes a product by its ID.

Each function handles possible errors and returns appropriate HTTP responses.

## Define routes

Create a routes folder at the root directory and in it create product.route.js. Insert the below code in it.

```
const express = require("express");
const Product = require("../models/product.model.js");
const router = express.Router();
const {getProducts, getProduct, createProduct, updateProduct, deleteProduct} = require('../controllers/product.controller.js');


router.get('/', getProducts);
router.get("/:id", getProduct);

router.post("/", createProduct);

// update a product
router.put("/:id", updateProduct);

// delete a product
router.delete("/:id", deleteProduct);




module.exports = router;
```
In this code, we set up Express routes for CRUD operations for our  Product model. it imports the necessary modules, creates an Express router, and defines routes for:

Fetching all products (GET /).
Fetching a single product by ID (GET /:id).
Creating a new product (POST /).
Updating a product by ID (PUT /:id).
Deleting a product by ID (DELETE /:id).

Finally, it exports the router for use in the main application.

## Testing your API

Now that we've created our CRUD operations, let's test them. We are going to use [insomnia](https://app.insomnia.rest/app/dashboard/organizations) if you don't have it you can download and create an account.

Follow the steps outlined below to test create operation ( POST REQUEST).

- 
Open Insomnia: Launch the Insomnia application.

- 
Create a New Request: Click on the "+" button to create a new request.

- 
Set Request Type: Select "POST" from the dropdown menu next to the request name.

- 
Enter URL: Input the URL of your API endpoint ( http://localhost:3000/api/products)

- 
Enter Request Body: Click on the "Body" tab, select "JSON," and enter the JSON data you want to send.

- 
Send Request: Click the "Send" button to send the request to the server.

- 
View Response: Inspect the response from the server in the lower pane of Insomnia.

The api for creating a product on the MongoDB was successful, as indicated by the status 200 ok in the image below, which illustrates how it should operate.


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/969ppxgws45d6dypvpz6.PNG)

Thus, you ought to be able to view the item created when you navigate to the database and select Browse Collection.


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/cqqrn3xo64rgfnpfkm27.PNG)

## Test Read operations 

The technique of testing a get request is almost the same as what we discussed above; you make a new request and select GET from the dropdown menu.


![Image description](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/arf1pnvdl0njv47gklst.PNG)

Proceed to try the final two options, which are update and remove (PUT, DELETE) from the dropdown menu.

## Conclusion 

With this beginner's tutorial, you should now have a solid foundation for performing CRUD operations using NodeJS and MongoDB. For more tech insights, follow me on [X](https://x.com/musembiwebdev) and connect on [LinkedIn](https://www.linkedin.com/in/daniel-musembi-a05852283/).