Creating and Managing REST APIs with Express.js

Express.js is a popular, lightweight web framework for Node.js that simplifies the process of building RESTful APIs. It provides an easy-to-use routing system, middleware support, and built-in utilities for handling requests and responses. This guide walks you through creating and managing REST APIs using Express.js.

1. Setting Up an Express.js Project

Before creating a REST API, ensure you have Node.js installed. Then, follow these steps:

1.1 Initialize a Node.js Project

Run the following command in your terminal to create a new project:

mkdir express-rest-api && cd express-rest-api
npm init -y

This creates a package.json file to manage dependencies.

1.2 Install Express.js

npm install express

This command installs Express.js as a dependency.

2. Creating a Basic Express Server

Create an index.js file and add the following code to set up a simple Express server:

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

// Middleware to parse JSON requests
app.use(express.json());

app.get('/', (req, res) => {
    res.send('Welcome to the Express.js REST API');
});

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

Run the server using:

node index.js

Visit http://localhost:3000 in your browser to see the response.

3. Defining REST API Endpoints

3.1 Creating Routes for CRUD Operations

A REST API typically includes Create, Read, Update, and Delete (CRUD) operations. Define the following routes in index.js:

let users = [];

// Create (POST)
app.post('/users', (req, res) => {
    const user = req.body;
    user.id = users.length + 1;
    users.push(user);
    res.status(201).json(user);
});

// Read (GET)
app.get('/users', (req, res) => {
    res.json(users);
});

// Read Single User (GET)
app.get('/users/:id', (req, res) => {
    const user = users.find(u => u.id === parseInt(req.params.id));
    if (!user) return res.status(404).json({ message: 'User not found' });
    res.json(user);
});

// Update (PUT)
app.put('/users/:id', (req, res) => {
    const user = users.find(u => u.id === parseInt(req.params.id));
    if (!user) return res.status(404).json({ message: 'User not found' });

    Object.assign(user, req.body);
    res.json(user);
});

// Delete (DELETE)
app.delete('/users/:id', (req, res) => {
    users = users.filter(u => u.id !== parseInt(req.params.id));
    res.status(204).send();
});

4. Using Middleware for Request Handling

Middleware functions process requests before they reach route handlers.

4.1 Logging Requests

const morgan = require('morgan');
app.use(morgan('dev'));

Install Morgan:

npm install morgan

4.2 Handling CORS (Cross-Origin Resource Sharing)

const cors = require('cors');
app.use(cors());

Install CORS:

npm install cors

5. Connecting to a Database

For persistence, connect the API to a database like MongoDB. Install Mongoose:

npm install mongoose

Modify index.js to connect to MongoDB:

const mongoose = require('mongoose');
mongoose.connect('mongodb://localhost:27017/expressapi', { useNewUrlParser: true, useUnifiedTopology: true })
    .then(() => console.log('Connected to MongoDB'))
    .catch(err => console.error(err));

6. Error Handling in Express.js

Use error-handling middleware to manage errors gracefully:

app.use((err, req, res, next) => {
    console.error(err);
    res.status(500).json({ message: 'Internal Server Error' });
});

7. Testing the API with Postman or Curl

Use Postman or cURL to test API endpoints. Example cURL command for creating a user:

curl -X POST http://localhost:3000/users -H "Content-Type: application/json" -d '{"name": "John Doe", "email": "john@example.com"}'

8. Deploying the API

To deploy the API, use PM2 for process management and NGINX for reverse proxy.

npm install -g pm2
pm2 start index.js

For cloud deployment, use services like Heroku, Vercel, or AWS.

Conclusion

Express.js makes it simple to build and manage RESTful APIs. By following best practices like middleware integration, database connections, and error handling, you can create scalable and efficient APIs for modern applications.