Node.js RESTful APIs with CRUD operations

TL;DR Node.js is a JavaScript runtime built on Chrome's V8 engine for creating server-side applications. A fullstack developer can use it with Express.js, a popular web framework, to build RESTful APIs and manage CRUD operations for users.

Building Robust Node.js RESTful APIs with CRUD Operations: A Fullstack Developer's Guide

As a fullstack developer, creating robust and scalable web applications is an art that requires a deep understanding of various technologies and frameworks. In this article, we'll delve into the world of Node.js, specifically focusing on building RESTful APIs with CRUD (Create, Read, Update, Delete) operations.

What is Node.js?

Node.js is a JavaScript runtime built on Chrome's V8 engine that allows developers to create server-side applications. It provides an event-driven, non-blocking I/O model that makes it ideal for real-time web applications and microservices architecture. With its vast ecosystem of packages and libraries, Node.js has become the go-to choice for fullstack developers.

Setting Up a Node.js Project

To begin building our RESTful API, let's set up a new Node.js project using npm (Node Package Manager). Create a new directory for your project and run the following command to initialize a new npm project:

npm init -y

Next, install the required packages, including Express.js, a popular Node.js web framework for building RESTful APIs.

npm install express

Creating a RESTful API

With our project set up and dependencies installed, let's create a basic RESTful API using Express.js. Create a new file called app.js and add the following code to create an instance of the Express app:

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

app.use(express.json());

// Define routes for CRUD operations
const usersRoute = require('./routes/users');

app.use('/users', usersRoute);

// Start the server
const port = 3000;
app.listen(port, () => {
    console.log(`Server started on port ${port}`);
});

Implementing CRUD Operations

Now that we have our RESTful API set up, let's implement CRUD operations for managing users. Create a new file called users.js and add the following code to define routes for creating, reading, updating, and deleting users:

const express = require('express');
const router = express.Router();

// GET /users: Retrieve all users
router.get('/', (req, res) => {
    const db = req.db;
    db.collection('users').find().toArray((err, docs) => {
        if (!err) {
            res.json(docs);
        } else {
            console.error(err);
            res.status(500).json({ message: 'Error retrieving users' });
        }
    });
});

// POST /users: Create a new user
router.post('/', (req, res) => {
    const db = req.db;
    const newUser = { name: req.body.name, email: req.body.email };
    db.collection('users').insertOne(newUser, (err, result) => {
        if (!err) {
            res.json({ message: 'User created successfully' });
        } else {
            console.error(err);
            res.status(500).json({ message: 'Error creating user' });
        }
    });
});

// GET /users/:id: Retrieve a specific user
router.get('/:id', (req, res) => {
    const db = req.db;
    const id = req.params.id;
    db.collection('users').findOne({ _id: new ObjectID(id) }, (err, doc) => {
        if (!err && doc) {
            res.json(doc);
        } else {
            console.error(err);
            res.status(404).json({ message: 'User not found' });
        }
    });
});

// PUT /users/:id: Update a specific user
router.put('/:id', (req, res) => {
    const db = req.db;
    const id = req.params.id;
    const updatedUser = { name: req.body.name, email: req.body.email };
    db.collection('users').updateOne({ _id: new ObjectID(id) }, { $set: updatedUser }, (err, result) => {
        if (!err && result.modifiedCount === 1) {
            res.json({ message: 'User updated successfully' });
        } else {
            console.error(err);
            res.status(500).json({ message: 'Error updating user' });
        }
    });
});

// DELETE /users/:id: Delete a specific user
router.delete('/:id', (req, res) => {
    const db = req.db;
    const id = req.params.id;
    db.collection('users').deleteOne({ _id: new ObjectID(id) }, (err, result) => {
        if (!err && result.deletedCount === 1) {
            res.json({ message: 'User deleted successfully' });
        } else {
            console.error(err);
            res.status(500).json({ message: 'Error deleting user' });
        }
    });
});

module.exports = router;

Conclusion

In this article, we've covered the basics of building a robust Node.js RESTful API with CRUD operations. We've set up a new project using npm and Express.js, implemented routes for creating, reading, updating, and deleting users, and demonstrated how to handle errors and validate user input.

As a fullstack developer, mastering Node.js and its ecosystem is crucial for building scalable web applications. With this guide, you're now equipped with the knowledge and skills necessary to build robust RESTful APIs using Node.js.