Node.js Series

In this part of our Node.js series, we will dive into one of the most powerful and essential components of modern web development: RESTful APIs. A RESTful API (Representational State Transfer) allows your server to interact with client applications by exposing structured endpoints and data. Using Express.js, we'll walk through building a simple REST API that handles CRUD (Create, Read, Update, Delete) operations.

What is a RESTful API?

A RESTful API is an architectural style for building web services that use HTTP requests to access and manipulate data. Each HTTP request method (GET, POST, PUT, DELETE) corresponds to a specific operation in CRUD:

• GET: Retrieve data.
• POST: Create new data.
• PUT/PATCH: Update existing data.
• DELETE: Remove data.

RESTful APIs are stateless, meaning that each API call from a client must contain all the necessary information for the server to fulfill the request.

Setting Up the Project

If you haven’t already, set up an Express project as we did in the earlier parts of this series. Install the necessary dependencies:

npm init -y
npm install express mongoose body-parser

Now, create a simple Express server:

// app.js
const express = require('express');
const mongoose = require('mongoose');
const bodyParser = require('body-parser');

const app = express();

// Middleware
app.use(bodyParser.json());

// MongoDB connection
mongoose.connect('mongodb://localhost:27017/restful_api', {
  useNewUrlParser: true,
  useUnifiedTopology: true
});

const db = mongoose.connection;
db.on('error', console.error.bind(console, 'MongoDB connection error:'));
db.once('open', () => {
  console.log('Connected to MongoDB');
});

const PORT = 3000;
app.listen(PORT, () => {
  console.log(`Server is running on http://localhost:${PORT}`);
});

Defining the Data Model

For this example, let’s create a simple data model for managing a collection of tasks. Each task will have a title and a description.

// taskModel.js
const mongoose = require('mongoose');

const taskSchema = new mongoose.Schema({
  title: { type: String, required: true },
  description: { type: String, required: true }
});

const Task = mongoose.model('Task', taskSchema);

module.exports = Task;

Defining RESTful Routes

Now, let's create the routes for the API, which will handle all the CRUD operations for our tasks. In Express, these routes are linked to specific HTTP methods.

// app.js (continued)
const Task = require('./taskModel');

// 1. Get all tasks (GET /tasks)
app.get('/tasks', async (req, res) => {
  try {
    const tasks = await Task.find();
    res.status(200).json(tasks);
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
});

// 2. Get a single task by ID (GET /tasks/:id)
app.get('/tasks/:id', async (req, res) => {
  try {
    const task = await Task.findById(req.params.id);
    if (!task) {
      return res.status(404).json({ message: 'Task not found' });
    }
    res.status(200).json(task);
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
});

// 3. Create a new task (POST /tasks)
app.post('/tasks', async (req, res) => {
  const task = new Task({
    title: req.body.title,
    description: req.body.description
  });
  try {
    const newTask = await task.save();
    res.status(201).json(newTask);
  } catch (error) {
    res.status(400).json({ message: error.message });
  }
});

// 4. Update a task by ID (PUT /tasks/:id)
app.put('/tasks/:id', async (req, res) => {
  try {
    const updatedTask = await Task.findByIdAndUpdate(
      req.params.id,
      {
        title: req.body.title,
        description: req.body.description
      },
      { new: true }
    );
    if (!updatedTask) {
      return res.status(404).json({ message: 'Task not found' });
    }
    res.status(200).json(updatedTask);
  } catch (error) {
    res.status(400).json({ message: error.message });
  }
});

// 5. Delete a task by ID (DELETE /tasks/:id)
app.delete('/tasks/:id', async (req, res) => {
  try {
    const task = await Task.findByIdAndDelete(req.params.id);
    if (!task) {
      return res.status(404).json({ message: 'Task not found' });
    }
    res.status(200).json({ message: 'Task deleted successfully' });
  } catch (error) {
    res.status(500).json({ message: error.message });
  }
});

Testing Your API

To test your API, you can use tools like Postman or curl. Here are some sample requests you can try:

1. Create a new task:

   • Method: POST
   • URL: http://localhost:3000/tasks
   • Body (JSON):

    {
      "title": "Learn Node.js",
      "description": "Complete the Node.js tutorial series"
    }
   

2. Get all tasks:

   • Method: GET
   • URL: http://localhost:3000/tasks

3. Get a task by ID:

   • Method: GET
   • URL: http://localhost:3000/tasks/:id

4. Update a task:

   • Method: PUT
   • URL: http://localhost:3000/tasks/:id
   • Body (JSON):

    {
      "title": "Learn Express.js",
      "description": "Build RESTful APIs with Express"
    }
   

5. Delete a task:

   • Method: DELETE
   • URL: http://localhost:3000/tasks/:id

Conclusion

Building RESTful APIs is a fundamental skill for modern web development. Express.js, combined with MongoDB, provides a powerful and flexible platform for creating scalable APIs that support various operations like creating, reading, updating, and deleting data.

In the next part of our series, we will explore deploying your Node.js application to the cloud and making it accessible to the world.

Stay tuned for more advanced Node.js development techniques!

Start Your JavaScript Journey

If you're new to JavaScript or want a refresher, visit my blog on BuyMeACoffee to get started with the basics.

👉 Introduction to JavaScript: Your First Steps in Coding

Series Index

Follow and Subscribe:

• YouTube: devDive with Dipak
• Website: Dipak Ahirav
• Whatsapp Channel:DevDiveWithDipak
• Email: dipaksahirav@gmail.com
• LinkedIn: Dipak Ahirav