Building RESTful APIs in Node.js with Practical Examples

Building RESTful APIs with Node.js

A RESTful API in Node.js allows applications to communicate using HTTP methods like GET, POST, PUT, and DELETE. It facilitates data exchange between clients and servers, enabling web applications to fetch or manipulate resources. Using Node.js, you can build a lightweight and efficient API server, and frameworks like Express.js make this process even simpler.

This guide demonstrates how to create, implement, and test a RESTful API in Node.js, complete with examples and best practices.

Syntax:

Below is the standard structure for a RESTful API in Node.js using Express.js:

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

app.use(express.json());

// Define routes
app.get('/api/resource', (req, res) => res.send('Get Resource'));
app.post('/api/resource', (req, res) => res.send('Create Resource'));
app.put('/api/resource/:id', (req, res) => res.send('Update Resource'));
app.delete('/api/resource/:id', (req, res) => res.send('Delete Resource'));

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

Examples and Code

1. Setting Up Your Node.js Project

Code:

# Initialize a new Node.js project
npm init -y

# Install Express.js for routing
npm install express

Explanation:

• npm init -y: Creates a basic package.json file.
• npm install express: Installs the Express.js framework for managing HTTP routes.

2. Creating a Basic API Server

Code:

// Import the Express module
const express = require('express');

// Create an Express application
const app = express();

// Define the port
const port = 3000;

// Parse JSON payloads
app.use(express.json());

// Define a GET endpoint
app.get('/api/products', (req, res) => {
    res.send(['Product1', 'Product2', 'Product3']); // Return a list of products
});

// Start the server
app.listen(port, () => {
    console.log(`API server is running at http://localhost:${port}`);
});

Explanation:

• app.get: Defines a route to handle GET requests to /api/products.
• res.send: Sends a response containing an array of products.

3. CRUD Operations in a RESTful API

Code:

// Import Express
const express = require('express');
const app = express();
const port = 3000;

// Parse JSON payloads
app.use(express.json());

// In-memory data storage
let products = [
    { id: 1, name: 'Laptop' },
    { id: 2, name: 'Smartphone' },
];

// GET: Retrieve all products
app.get('/api/products', (req, res) => {
    res.send(products);
});

// POST: Add a new product
app.post('/api/products', (req, res) => {
    const product = { id: products.length + 1, name: req.body.name };
    products.push(product);
    res.status(201).send(product); // Return the newly created product
});

// PUT: Update a product
app.put('/api/products/:id', (req, res) => {
    const product = products.find(p => p.id === parseInt(req.params.id));
    if (!product) return res.status(404).send('Product not found.');

    product.name = req.body.name; // Update the product name
    res.send(product);
});

// DELETE: Remove a product
app.delete('/api/products/:id', (req, res) => {
    const productIndex = products.findIndex(p => p.id === parseInt(req.params.id));
    if (productIndex === -1) return res.status(404).send('Product not found.');

    const deletedProduct = products.splice(productIndex, 1);
    res.send(deletedProduct);
});

// Start the server
app.listen(port, () => {
    console.log(`API server running at http://localhost:${port}`);
});

Explanation:

• GET: Fetch all products.
• POST: Add a new product.
• PUT: Update a product by its ID.
• DELETE: Remove a product by its ID.
• res.status: Sets the HTTP status code for responses (e.g., 201 for resource creation).

Testing the API

1. Use tools like Postman or cURL to test API endpoints:

• Example GET request with cURL:

Code:

curl http://localhost:3000/api/products

2. For POST, PUT, and DELETE, send JSON payloads:

Code:

curl -X POST -H "Content-Type: application/json" -d '{"name":"Tablet"}' http://localhost:3000/api/products

Features of a RESTful API

1. Stateless:

Each request contains all information needed for the server to fulfill it.

2. Uniform Interface:

Standard HTTP methods (GET, POST, PUT, DELETE) are used.

3. Scalability:

RESTful APIs are highly scalable and can handle a wide range of clients.

4. Separation of Concerns:

Clean separation between client and server logic.

Best Practices for Building APIs

1. Validation:

Use libraries like Joi or express-validator to validate incoming data.

Code:

const Joi = require('joi');
const schema = Joi.object({
    name: Joi.string().min(3).required(),
});

2. Error Handling:

Implement centralized error handling:

Code:

app.use((err, req, res, next) => {
    console.error(err.stack);
    res.status(500).send('Something went wrong!');
});

3. Use Environment Variables:

Store sensitive data (e.g., database credentials) in .env files.

4. Pagination:

Add pagination for large datasets to improve performance.

5. API Documentation:

Use tools like Swagger or Postman to document the API.

Advanced Topics

1. Connecting to a Database:

Replace in-memory storage with a database like MongoDB or MySQL for persistence.

2. Authentication:

Secure APIs using authentication mechanisms like JWT (JSON Web Tokens).

3. Versioning:

Support multiple API versions (e.g., /api/v1/resource and /api/v2/resource).

Practical Guides to Node.js Snippets and Examples.