MVC Architecture With Node.js CRUD Application [Node.js-Express-MongoDB]

const express = require("express");
const app = express();

app.get("/", function (req, res) {
  res.send("Running MVC Application, Student API Project.");
});

app.listen(3000);

 "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1",
    "start": "nodemon index.js"
  },

// Using Node.js `require()`
const mongoose = require('mongoose');

// Using ES6 imports
import mongoose from 'mongoose';

mongoose
  .connect(<Past you connection > )
  .then(() => {
    app.listen(3000, () => {
      console.log(`Node API app is running on port 3000`);
    });
  })
  .catch((error) => {
    console.log(error);
  });

 app.listen(3000, () => {
      console.log(`Node API app is running on port 3000`);
    });

"mongodb+srv://<Username>:<Password>@mongodbcluster01.joofg8v.mongodb.net/<DB_Name>?retryWrites=true&w=majority"

mongoose
  .connect( "mongodb+srv://<Username>:<Password>@mongodbcluster01.joofg8v.mongodb.net/<DB_Name>?retryWrites=true&w=majority"
  )
  .then(() => {
    console.log("connected to MongoDB Atlas");
    app.listen(3000, () => {
      console.log(`Node API app is running on port 3000`);
    });
  })
  .catch((error) => {
    console.log(error);
  });

1. Go to the npm page and search dotenv. I link the url here. npm i dotenv Install the npm package for dotenv for your node js application.
2. Create an env file in node-js. Do not create a js file. Name it .env.
3. Now I'm going to move the DB connection for .env from the Server.js. Create a variable name as a MONGO_CONNECTION and paste the DB connection.

Picture 10. Now you can see the .env and mongoDB connection.

Step 14. Include the .env in index js for the Node js application.

Go to the index.js file and paste this line as a first “require('dotenv').config()”

I created a variable for env MONGO_CONNECTION.

const MONGO_CONNECTION = process.env.MONGO_CONNECTION;

Go to the mongoose.connect(paste your env variable).

mongoose
  .connect(MONGO_CONNECTION)
  .then(() => {
    console.log("connected to MongoDB Atlas");
    app.listen(3000, () => {
      console.log(`Node API app is running on port 3000`);
    });
  })
  .catch((error) => {
    console.log(error);
  });

Picture 11. I underline the steps here, We can change the Listen-PORT also the same way

05. MVC Architecture for Student API Project

Student API Project with MVC

Picture 12. Student API Project MVC Architecture

In this scenario, we have three parts (Model, Controller, and Router).

1. Model: Student Model.
2. Controller: Student Controller (Business Logic)
3. Router /View: Student Route, In the project, I’m not creating a view. I will check the route in POSTMAN.

Step 15. Create models, controllers, and route folders in your project.

Picture 13. MVC folder structure is created.

How To Apply MVC Architecture to our project?

Create a model

Picture 14. Student Model

Step 16. Create a Student Model. Inside the model's folder, create a studentModel.js.

The model requires a Schema from the Mongoose. Create a Schema first.

1. Create a variable as a mongoose, const mongoose = require("mongoose"); That is interactive with the database. We use Mongoose.
2. Create a studentSchema, const studentSchema = mongoose.Schema().

const mongoose = require("mongoose");

const studentSchema = mongoose.Schema(
  {
    name: {
      type: String,
      required: [true, "Please enter a Student name"],
    },
    address: {
      type: String,
      required: true,
    },
    dateOfBirth: {
      type: Date,
      required: true,
    },
    gender: {
      type: String,
      required: true,
    },
    phoneNum: {
      type: Number,
      required: false,
    },
  },
  {
    timestamps: true,
  }
);

const Student = mongoose.model("Student", studentSchema);
module.exports = Student;

Inside the schema, create a student model.

Create a variable for studentSchema as a Student in mongoose.model.const Student = mongoose.model("Student", studentSchema);

Student model export. module.exports = Student;

Create a controller

The controller controls the business logic. It receives the user input through the view layer and processes the information through the model layer.

The basic CRUD operation in MVC. Below are the CRUD operations.

Picture 15. Student CRUD operation.

• Create a Student record in the database.
• Read all Student's records in the database.
• Update a Student record in the database.
• Delete a Student record in the database.

I. Create a student record in the database.

Step 17. Create a student controller. Inside the controller's folder, create a studentController.js.

const student = require("../models/studentModel");

Step 18. Import the student model in studentController.js as Student.

const Student = require("../models/studentModel");

//Create Student
const createStudent = async (req, res) => {
  try {
    const _student = await Student.create(req.body);
    res.status(200).json(_student);
  } catch (error) {
    console.log(error.message);
    res.status(500).json({ message: error.message });
  }
};

module.exports = {
  createStudent,
};

Create a variable for Student.create a response as _student.

    const _student = await Student.create(req.body);
    res.status(200).json(_student);

Student. create(req.body) Student is Model, It is return status (200) success and _student Details.

createStudent is a module. It will be an export for access.

module.exports = {
  createStudent,
};

Create a route

Step 19. Create a Student Route. Inside the routes folder, create a studentRoute.js.

const express = require("express");
const router = express.Router();
const {createStudent}= require("../controllers/studentController");

//Create Student
router.post("/student", createStudent);
module.exports = router;

1. Import the express and use the Router as the router.
2. Import the student controller with the module.

   const express = require("express");
   const router = express.Router();
   const {createStudent}= require("../controllers/studentController");

3. Create the route it is post method = router.post("/student", createStudent);
4. Router module exports.

   //Create Student
   router.post("/student", createStudent);
   module.exports = router;

Step 20. Import the router to the index page.

Go to the index page, import the router, and set the route.

const studentRoute = require("./routes/studentRoute");
app.use(express.json());

//Student Route
app.use("/api", studentRoute);

1. Import the studentRoute is required from studentRoute.
2. Read the JSON format from the request we access express.json().
3. Set studentRoute using express. app.use("/api", studentRoute);

   require("dotenv").config();
   const express = require("express");
   const mongoose = require("mongoose");
   const app = express();
   const MONGO_CONNECTION = process.env.MONGO_CONNECTION;
   
   const studentRoute = require("./routes/studentRoute");
   app.use(express.json());
   
   //Student Route
   app.use("/api", studentRoute);
   
   mongoose
     .connect(MONGO_CONNECTION)
     .then(() => {
       console.log("connected to MongoDB Atlas");
       app.listen(3000, () => {
         console.log(`Node API app is running on port 3000`);
       });
     })
     .catch((error) => {
       console.log(error);
     });
   

Go to the postman and check if the API call works or not. using this route http://localhost:3000/api/student.

Picture 16. Enter the sample student data and send it. It is a post method and gets the response as well.

We can check whether the data was added or not in the database.

Picture 17. Here, we can see the database and Postman response data both are the same.

II . Read all student records in the database.

Step 21. Go to the studentController.js and add this code.

const _students = await Student.find({}); In the MVC pattern, we get the data from the model. Student. find({}) . It Sends the results in the object, It is an HTTP GET method.

//Get All Students
const getAllStudents = async(req, res)=>{
  try {
    const _students = await Student.find({});
    res.status(200).json(_students);
  } catch (error) {
     res.status(500).json({ message: error.message });
  }
}

Here we created the getAllStudents module and exported the module also. module.exports = { createStudent, getAllStudents,};

Step 22. Go to the studentRoute and import the getAllStudents module.

const { createStudent, getAllStudents,} =require("../controllers/studentController");
//Get All Students
router.get("/student", getAllStudents);

Model. Find is HTTP GET method. router.get("/student", getAllStudents);

Check the postman here. GET method and using this route. http://localhost:3000/api/student.

Picture 18: Here, we can see the get all student results.

III . Read a student record in the database.

Step 23. Go to the studentController.js and add this code.

When getting a single record, use the findById method and pass the ID to the params.

//Get the Student
const getStudent = async(req, res)=>{
  try {
    const {id} = req.params;
    const _student = await Student.findById(id);
    res.status(200).json(_student);
  } catch (error) {
     res.status(500).json({ message: error.message });
  }
}
module.exports = {
  createStudent,
  getAllStudents,
  getStudent,
};

1. Get the id from req.params, and pass the id to findById(id); and also export the getStudent module.
2. Go to the studentRoute and import the getStudent module. It is also the HTTP GET method.
3. Check the postman here. GET method and use this route with Id. http://localhost:3000/api/student/{id}.

Picture 19. Here we can see a single record by id.

IV . Update a student record in the database.

Step 24. Add this code in studentController.js.

const updateStudent = async (req, res) => {
  try {
    const { id } = req.params;
    const _student = await Student.findByIdAndUpdate(id, req.body);
    // we cannot find any Student in database
    if (!_student) {
      return res
        .status(404)
        .json({ message: `cannot find any student with ID ${id}` });
    }
    const updatedStudent = await Student.findById(id);
    res.status(200).json(updatedStudent);
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
};

When we update the student record, First, we find the student ID and will update the student details.

const _student = await Student.findByIdAndUpdate(id, req.body); findByIdAndUpdate(id, req.body) There are two type parameters: id is a student ID, and req.body is an update detail.

Find the ID from the student table, If data is there, we can update student details if data is not found, return status 404 and message.

  if (!_student) {
      return res
        .status(404)
        .json({ message: `cannot find any student with ID ${id}` });
    }

1. Export the updateStudent module. And go to the studentRoute and import the updateStudent module. It is the HTTP PUT method.
2. Check the postman here. PUT method and use this route with Id and req.body. http://localhost:3000/api/student/{id}

Picture 20: Here, we can see the updated record by ID with the request body.

Picture 21. Here, we can see the updated record from the database.

IV . Delete a student record in the database.

Step 25. Add this code in studentController.js.

//Delete a Student
const deleteStudent = async (req, res) => {
  try {
    const { id } = req.params;
    const _student = await Student.findByIdAndDelete(id);
    if (!_student) {
      return res
        .status(404)
        .json({ message: `cannot find any student with ID ${id}` });
    }
    res.status(200).json(_student);
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
};

Here also find the data by ID and delete the record. We use the Student.findByIdAndDelete(id) method, this method finds the data by ID; if data is there, then data will be deleted.

const _student = await Student.findByIdAndDelete(id); ID will be passed from request params. const { id } = req.params;

But data is not found and returns the error status 404 and error message.

 if (!_student) {
      return res
        .status(404)
        .json({ message: `cannot find any student with ID ${id}` });
    }

If delete the record res.status(200).json(_student); return the response deleted data.

1. Export the deleteStudent module. And go to the studentRoute and import the deleteStudent module. It is the HTTP DELETE method.
2. Check the postman here. DELETE method and use this route with Id and req.body. http://localhost:3000/api/student/{id}

Picture 22. Here we can see the deleted data.

Picture 23. Check the data by id, but data is not found and returns the error status 404 and error message.

Summary

This article is advanced compared to my previous article. I explained What is MVC. How to apply the MVC architecture in a Node JS project and how to perform CRUD operations using Node Js, Express, Postman, and MongoDB. In this article, Perform CRUD operations API checking with Postman. I hope this article helps those Who have an interest in self-learning. To Keep in touch with me. Next article, I’m going to start a new subject, REACT js.