Approach

We will develop a RESTful API named “gfg-employees” to manage employee data. We’ll handle CRUD operations (Create, Read, Update, Delete) for employee records. Robo3T will serve as the database management tool, while Postman will facilitate sending HTTP requests. Below is a step-by-step guide for implementation.

Step 1: Create a new directory, go to the terminal, and initialize NPM by running the following command.

npm init -y

Step 2: Install body-parser, mongoose, express

• body-parser: A middleware responsible for parsing the incoming request body before it can be handled.
• express:  node.js framework
• mongoose: Mongoose connects MongoDB to the Express web application

npm i body-parser mongoose express 

Step 3: Create an app.js file in the current directory and set up the server. We will import the packages into our project and configure our server.

Step 4: Creating a database on Robo3T. Consider a database of employees with employee_name, employee_department, employee_salary fields.

{

    "employee_name" : "Riya Verma",
    "employee_department" : "IT",
    "employee_salary":"90000"
},
{

    "employee_name" : "Saransh Gupta",
    "employee_department" : "Finance",
    "employee_salary":"75000"
},
{

    "employee_name" : "Harsh Sehgal",
    "employee_department" : "Production",
    "employee_salary":"60000"
},
{

    "employee_name" : "Arihant Kumar",
    "employee_department" : "Marketing",
    "employee_salary":"85000"
},
{

    "employee_name" : "Ananya Sharma",
    "employee_department" : "Human Resource Management",
    "employee_salary":"50000"
}

• Go to Robo3t and create a new connection.
• Create a database named gfg-employees by clicking on the new connection button.
• A database ‘gfg-employees’ will be created. Now click on it and create a new collection called ’employeedatas’
• To insert documents, click on employeedatas and select insert document.
• Copy each document from above and insert it one by one.
• To view all the documents, click on employeedatas.

The following shows how to create a database and insert documents. 

Step 5: Set up MongoDB and write the schema for our employee data to create models. To set up MongoDB, we will use a mongoose. We will connect our application to the MongoDB location and add the database name to the URL string. By default, MongoDB uses port 27017.

mongoose.connect("mongodb://localhost:27017/gfg-employees", {useNewUrlParser: true});

The schema defines the structure of our collection. We will create a schema named employeeSchema consisting of three fields – employee_name, employee_department, and employee_salary. 

const employeeSchema = {
 employee_name: String,
 employee_department: String,
 employee_salary : Number
};

Now we will create a model from the employeeSchema.

const EmployeeData = mongoose.model("EmployeeData", employeeSchema);

Add the following code to your existing code in app.js file. 

Step 6: Accessing all the employees using the GET method. We can fetch all the employees by sending a get request by specifying the route of the resource and a callback function that handles the request.

app.get(route, (req,res)=>{
})

To retrieve all the employees, we have to find the employees and read them from the database.

<ModelName>.find({conditions},function(err,results){
// Using the result
});

Add the following code to your existing app.js file. 

Step to run the application: Start your application by running the following command.

node app.js

Output: We can access the employees at localhost:3000/employees. 

Step 7:  Create a new employee using the POST method. We will create a new employee that will be added to the database. Here, the client sends data to the server. We don’t have a front-end yet, but we do have a server that has access to our database. We will test our API using Postman, rather than creating a form or a front end. Our goal is to send a post request to our server.

We will use the post method:

app.post(route,(req,res)=>{
   ...
})

Once the client sends the post request we need to grab that data by req.body.

Head over to postman and send a post request to localhost:3000/employees. Under the body tab, change the encoding to form-url coding, and add the employee_name, employee_department, and employee_salary in key, along with the value that represents the data that we want to send along with the request.

We need to save this employee in our database.

const <constantName>=new <ModelName>({
<fieldName>:<fielddata>,..
});

Add the following code to the previous code in the app.js file. Restart your server and send a post request using postman.

Output: Go to Robo3T and refresh your collection to view the added article. Now we have an extra entry. 

Step 8: Fetching a specific employee. We will read a specific employee from our database using the findOne method.

<ModelName>.findone({conditions},(req,res)=>{
});

here, we will fetch the employee with the employee_name Ananya Sharma. 

Add the following code to your app.js file. 

Output: We will specify the employee_name  in the URL and the employee whose name matches that will be displayed. We will use %20 in the URL to indicate a space between the Name and the Surname in the employee_name. Spaces are encoded as %20. Hence, we will get employee information from localhost:3000/employees/Ananya%20Sharma. 

Step 9:  Overwriting an employee with the PUT method. To replace an existing employee, we will send a put request.

app.put(route ,(req,res)=>{
...
});

We will update the employee using the Mongoose update method. The overwrite specifies that we want to replace the entire article.  

<ModelName>.update(
{conditions},
{updates},
{overwrite:true}
(err,results)=>{
})

Add the following code to your app.js file 

In this case, we will change our employee data of employee_name Harsh Sehgal as follows: 

by sending a put request to the route localhost:3000/employees/Harsh%20Sehgal

If the server finds a parameter with an employee_name of Harsh Sehgal, it will replace the employee_name with a new name, employee_department with a new department, and update the salary field as well. 

Step 9:  Updating the salary of an employee using the PATCH method. We will update an existing employee by sending a Patch request with the name of the employee we wish to update. To update the employee, we must give the fields we want to change in the body tab. Now that we are changing only one field of an employee rather than the entire employee data, the overwrite method is not needed when we call the update method to update our database. To update the employee, we must give the fields we want to change in the body tab.

Add the following code in your app.js file to modify the employee data.

Output: It Updates only the fields that we provide. The salary of an employee named Riya Verma gets updated to 9500

Step 10: Deleting all the employees using the DELETE method. To delete all the employees from our database we will use deleteMany mongoose method and send a delete request from the postman.

Add the following code to your app.js file. 

Output: We will send a delete request to localhost:3000/employees to remove all our employees. Visit Robo3T and refresh your collection. If we send a delete request from our postman, we will not observe any employees. 

Final Code:

REST (Representational State Transfer) is an architectural style for designing networked applications. A RESTful API is an API that adheres to the principles of REST, making it easy to interact with and understand. In this article, we’ll explore what REST API is in the context of Node.js, its principles, and how to create one.