Express js - Building RESTful APIs

Building RESTful APIs in Express.js 

Introduction to Express.js and RESTful APIs

Express.js is a fast, minimal, and flexible Node.js web application framework that provides a robust set of features for building web and mobile applications. It is widely used for developing RESTful APIs due to its simplicity, scalability, and powerful middleware support.

A RESTful API (Representational State Transfer API) is an architectural style for designing networked applications. It uses HTTP methods such as GET, POST, PUT, DELETE, and PATCH to perform CRUD (Create, Read, Update, Delete) operations.

What is Express.js?

Express.js is built on top of Node.js and simplifies server-side programming. It provides a thin layer of fundamental web application features without obscuring Node.js capabilities.

Key Features of Express.js

• Minimal and flexible framework
• Middleware support
• Routing capabilities
• Easy integration with databases
• High performance and scalability

What is a RESTful API?

RESTful APIs follow a set of constraints and principles that allow communication between client and server. These APIs are stateless and rely on standard HTTP methods.

REST Principles

• Stateless communication
• Client-server architecture
• Uniform interface
• Cacheable responses
• Layered system

Setting Up Express.js Project

Before building a RESTful API, you need to set up a Node.js project and install Express.

mkdir express-api
cd express-api
npm init -y
npm install express

Basic Express Server

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

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

app.listen(3000, () => {
  console.log('Server running on port 3000');
});

Understanding Middleware in Express.js

Middleware functions are functions that have access to the request object (req), response object (res), and next middleware function in the application’s request-response cycle.

Types of Middleware

• Application-level middleware
• Router-level middleware
• Error-handling middleware
• Built-in middleware

app.use(express.json());

Routing in Express.js

Routing refers to how an application’s endpoints respond to client requests. Express provides methods to define routes for different HTTP methods.

app.get('/users', (req, res) => {});
app.post('/users', (req, res) => {});
app.put('/users/:id', (req, res) => {});
app.delete('/users/:id', (req, res) => {});

Building a RESTful API Step-by-Step

Step 1: Create Data Structure

let users = [
  { id: 1, name: 'John' },
  { id: 2, name: 'Jane' }
];

Step 2: GET Request (Read Data)

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

Step 3: POST Request (Create Data)

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

Step 4: PUT Request (Update Data)

app.put('/users/:id', (req, res) => {
  const id = parseInt(req.params.id);
  const user = users.find(u => u.id === id);
  if (user) {
    user.name = req.body.name;
    res.json(user);
  } else {
    res.status(404).send('User not found');
  }
});

Step 5: DELETE Request

app.delete('/users/:id', (req, res) => {
  const id = parseInt(req.params.id);
  users = users.filter(u => u.id !== id);
  res.send('User deleted');
});

Handling Request Parameters

Express allows access to route parameters, query parameters, and request body.

// Route Params
req.params.id

// Query Params
req.query.name

// Body Data
req.body

Error Handling in Express.js

Error handling middleware is used to catch and process errors centrally.

app.use((err, req, res, next) => {
  res.status(500).json({ message: err.message });
});

Using Express Router

Express Router helps organize routes into separate files.

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

router.get('/', (req, res) => {
  res.send('User route');
});

module.exports = router;

Connecting to Database

In real-world applications, APIs connect to databases such as MongoDB or MySQL.

// Example with MongoDB (Mongoose)
const mongoose = require('mongoose');

mongoose.connect('mongodb://localhost:27017/test')
  .then(() => console.log('Connected'))
  .catch(err => console.log(err));

HTTP Status Codes

• 200 OK
• 201 Created
• 400 Bad Request
• 404 Not Found
• 500 Internal Server Error

Authentication and Security

Security is crucial in API development. Common techniques include:

• JWT Authentication
• OAuth
• API Keys
• HTTPS

// Example JWT
const jwt = require('jsonwebtoken');

const token = jwt.sign({ id: 1 }, 'secretKey');

Testing RESTful APIs

Testing ensures API reliability. Tools include:

• Postman
• Insomnia
• Jest
• Supertest

Deploying Express.js API

Deployment platforms include:

• Heroku
• Vercel
• AWS
• DigitalOcean

Express.js is one of the most popular frameworks for building RESTful APIs in Node.js. Its simplicity and flexibility make it ideal for both beginners and advanced developers. By following REST principles and best practices, developers can create scalable, maintainable, and high-performance APIs.