Basics of Routing

Mastering Backend Development with Node.js: Comprehensive Guide to Express.js Routing and RESTful APIs

In this session, you will delve into routing with Express.js, a crucial concept for managing HTTP requests and defining how your application responds to different routes. Routing in Express.js enables you to handle requests made to specific endpoints, making it essential for building dynamic web applications and RESTful APIs. This session covers the foundational aspects of routing, including the use of route parameters and query strings, and will guide you through creating a simple RESTful API.

You’ll also learn about the distinctions between RESTful APIs and other API styles like GraphQL and gRPC. By the end of this session, you will be able to:

• Define and handle routes using different HTTP methods.
• Utilize route parameters and query strings to build dynamic endpoints.
• Implement a RESTful API with CRUD operations using real-time data.
• Understand alternative API styles and their use cases.
• Apply best practices for routing and API documentation to ensure clarity and maintainability.

Table of Contents

1. Understanding Routing
2. Defining Routes
3. Using Route Parameters and Query Strings
4. Applied Project: Creating a RESTful API with Real-Time Data
5. RESTful APIs and Alternatives
6. Best Practices
7. API Documentation
8. Practice Exercises
9. LeetCode/HackerRank: Routing Challenges
10. Data Structures and Algorithms (DSA) Focus

1. Understanding Routing

Routing in Express.js allows you to define endpoints that your application responds to. Here’s a simple example:

import express from 'express';

const app = express();
const port = 2024;

// Define a route for GET requests to the root URL
app.get('/', (req, res) => {
  res.send('Hello, world!');
});

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

Explanation:

• import express from 'express';: Imports the Express module.
• app.get('/', ...): Sets up a route that responds to GET requests at the root URL (/).
• Callback Function: Sends “Hello, world!” as a response.

2. Defining Routes

Routes are defined for different HTTP methods:

import express from 'express';

const app = express();
const port = 2024;

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

// Define routes for various HTTP methods
app.get('/example', (req, res) => {
  res.send('GET request received');
});

app.post('/example', (req, res) => {
  res.send('POST request received');
});

app.put('/example', (req, res) => {
  res.send('PUT request received');
});

app.delete('/example', (req, res) => {
  res.send('DELETE request received');
});

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

Explanation:

• app.get('/example', ...): Handles GET requests at /example.
• app.post('/example', ...): Handles POST requests at /example.
• app.put('/example', ...): Handles PUT requests at /example.
• app.delete('/example', ...): Handles DELETE requests at /example.

3. Using Route Parameters and Query Strings

Route Parameters: Used to capture dynamic values in the URL.

Example:

import express from 'express';

const app = express();
const port = 2024;

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

// Define route with a parameter
app.get('/products/:id', (req, res) => {
  const productId = req.params.id; // Capture the product ID from the URL
  res.send(`Product ID: ${productId}`);
});

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

Explanation:

• /products/:id: Route with a parameter id.
• req.params.id: Accesses the value of id from the URL.

Query Strings: Used to pass additional data in the URL.

Example:

import express from 'express';

const app = express();
const port = 2024;

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

// Define route with query string
app.get('/search', (req, res) => {
  const searchTerm = req.query.q; // Capture the search term from the query string
  res.send(`Search term: ${searchTerm}`);
});

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

Explanation:

• /search?q=example: q is a query parameter.
• req.query.q: Accesses the value of q.

4. Applied Project: Creating a RESTful API

Project Objective: Build a RESTful API to manage products with CRUD operations. You will create endpoints to perform Create, Read, Update, and Delete operations.

Step-by-Step Implementation:

1. Setup Your Project:
   • Initialize a new Express.js project.
   • Install necessary dependencies using npm install express.
2. Create the RESTful API:Complete Example:

import express from 'express';

const app = express();
const port = 2024;

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

// Sample data: List of products
let products = [
  { id: 1, slug: 'laptop', name: 'Laptop', price: 999.99 },
  { id: 2, slug: 'smartphone', name: 'Smartphone', price: 499.99 },
  { id: 3, slug: 'tablet', name: 'Tablet', price: 299.99 }
];

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

// POST /api/products - Create a new product
app.post('/api/products', (req, res) => {
  const newProduct = req.body; // Expecting { id, slug, name, price }
  products.push(newProduct);
  res.status(201).json(newProduct);
});

// PUT /api/products/:id - Update an existing product
app.put('/api/products/:id', (req, res) => {
  const productId = parseInt(req.params.id, 10); // Capture the ID from the URL
  const updatedProduct = req.body; // Expecting { id, slug, name, price }
  products = products.map(product =>
    product.id === productId ? updatedProduct : product
  );
  res.json(updatedProduct);
});

// DELETE /api/products/:id - Delete a product
app.delete('/api/products/:id', (req, res) => {
  const productId = parseInt(req.params.id, 10); // Capture the ID from the URL
  products = products.filter(product => product.id !== productId);
  res.status(204).end(); // No content to send in response
});

// GET /api/products/slug/:slug - Retrieve product by slug
app.get('/api/products/slug/:slug', (req, res) => {
  const productSlug = req.params.slug; // Capture the slug from the URL
  const product = products.find(p => p.slug === productSlug);
  if (product) {
    res.json(product);
  } else {
    res.status(404).send('Product not found');
  }
});

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

Detailed Explanation:

1. GET /api/products:
   • Purpose: Retrieve all products from the products array.
   • Request: GET http://localhost:2024/api/products
   • Response: JSON array of all products.
   Sample Response:

[
  { "id": 1, "slug": "laptop", "name": "Laptop", "price": 999.99 },
  { "id": 2, "slug": "smartphone", "name": "Smartphone", "price": 499.99 },
  { "id": 3, "slug": "tablet", "name": "Tablet", "price": 299.99 }
]

2. POST /api/products:
   • Purpose: Create a new product and add it to the products array.
   • Request: POST http://localhost:2024/api/products
   • Body: { "id": 4, "slug": "smartwatch", "name": "Smartwatch", "price": 199.99 }
   • Response: JSON object of the newly created product.

Sample Response:

{ "id": 4, "slug": "smartwatch", "name": "Smartwatch", "price": 199.99 }

3. PUT /api/products/:id:
   • Purpose: Update an existing product identified by its id.
   • Request: PUT http://localhost:2024/api/products/2
   • Body: { "id": 2, "slug": "smartphone", "name": "Updated Smartphone", "price": 549.99 }
   • Response: JSON object of the updated product.

Sample Response:

{ "id": 2, "slug": "smartphone", "name": "Updated Smartphone", "price": 549.99 }

4. DELETE /api/products/:id:
   • Purpose: Delete a product identified by its id.
   • Request: DELETE http://localhost:2024/api/products/3
   • Response: Status code 204 No Content indicating successful deletion.
5. GET /api/products/slug/:slug:
   • Purpose: Retrieve a product by its slug.
   • Request: GET http://localhost:2024/api/products/slug/laptop
   • Response: JSON object of the product with the matching slug.

Sample Response:

{ "id": 1, "slug": "laptop", "name": "Laptop", "price": 999.99 }

5. RESTful APIs and Alternatives

RESTful API:

• Definition: An architectural style for designing networked applications using HTTP requests to access and manipulate data.
• Characteristics: Stateless, client-server architecture, cacheable responses.

Alternative API Styles:

1. GraphQL:
   • Definition: A query language for APIs that allows clients to request specific data.
   • Features: Flexible queries, strong typing.
   • Example Query:

query {
  product(id: 1) {
    name
    price
  }
}

2. gRPC:
   • Definition: A high-performance RPC framework using HTTP/2 and Protocol Buffers.
   • Features: Supports multiple languages, efficient serialization.
   • Example Proto File:

service ProductService {
  rpc GetProduct (ProductRequest) returns (ProductResponse);
}

3. SOAP:
   • Definition: A protocol for exchanging structured information using XML.
   • Features: Built-in error handling, security.
   • Example Request:

<soapenv:Envelope xmlns:soapenv="http://schemas.xmlsoap.org/soap/envelope/" xmlns:prod="http://example.com/product">
   <soapenv:Header/>
   <soapenv:Body>
      <prod:GetProductRequest>
         <prod:productId>1</prod:productId>
      </prod:GetProductRequest>
   </soapenv:Body>
</soapenv:Envelope>

6. Best Practices

1. Modularize Routes:

• Reason: Improves code organization and maintainability.
• Implementation: Create separate route files and import them.

2. Use Middleware Efficiently:

• Reason: Common tasks like logging and authentication.
• Implementation: Apply middleware globally or to specific routes.

3. Handle Errors Gracefully:

• Reason: Provides consistent error responses and improves debugging.
• Implementation: Use error-handling middleware.

4. Document APIs Clearly:

• Reason: Helps developers understand how to use the API.
• Implementation: Use tools like OpenAPI or Postman.

7. API Documentation

Why Document APIs?

• Clarity: Helps developers understand API usage.
• Consistency: Reduces errors and ensures correct API use.
• Maintenance: Simplifies updates and debugging.

Types of Documentation:

1. OpenAPI (Swagger):
   • Definition: Specification for defining APIs with interactive documentation.
   • How to Use:
     1. Install Swagger Tools:

npm install swagger-ui-express swagger-jsdoc

2. Create a Swagger Configuration File:

// swagger.js
import swaggerJsdoc from 'swagger-jsdoc';
import swaggerUi from 'swagger-ui-express';

const swaggerDefinition = {
  openapi: '3.0.0',
  info: {
    title: 'Products API',
    version: '1.0.0',
    description: 'API documentation for managing products',
  },
};

const options = {
  swaggerDefinition,
  apis: ['./routes/*.js'],
};

const swaggerSpec = swaggerJsdoc(options);

export default swaggerSpec;

3. Integrate Swagger with Express:

import express from 'express';
import swaggerUi from 'swagger-ui-express';
import swaggerSpec from './swagger.js';

const app = express();
const port = 2024;

app.use('/api-docs', swaggerUi.serve, swaggerUi.setup(swaggerSpec));

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

1. Postman:
   • Definition: Tool for defining, testing, and documenting APIs.
   • How to Use:
     1. Install Postman: Download and install from Postman.
     2. Create a New Collection:
        • Open Postman and click on “New” → “Collection.”
        • Name the collection and add a description.
     3. Add Requests to the Collection:
        • Click on “Add Request” within the collection.
        • Define request method, URL, and body (if applicable).
        • Save the request.
     4. Document Requests:
        • Provide descriptions, parameters, and example responses.
        • Use the “Documentation” tab to add detailed information.

Best Practices for API Documentation:

• Clear Descriptions: Provide detailed endpoint explanations.
• Examples: Include sample requests and responses.
• Versioning: Document different API versions.

8. Practice Exercises

1. Define Routes for Different HTTP Methods:
   • Implement routes for GET, POST, PUT, and DELETE methods.
2. Implement Route Parameters:
   • Create routes with parameters to handle dynamic values.
3. Use Query Strings:
   • Implement routes that process query strings and return appropriate responses.
4. Build a RESTful API:
   • Create an API with CRUD operations and test it using tools like Postman.

9. LeetCode/HackerRank: Routing Challenges

What are LeetCode and HackerRank?

LeetCode and HackerRank are platforms offering coding practice and interview preparation. They provide problems and challenges for improving coding skills.

Account Creation:

1. LeetCode:
   • Visit LeetCode, click “Sign Up,” and register using email, Google, Facebook, or LinkedIn.
2. HackerRank:
   • Visit HackerRank, click “Sign Up,” and register using email, Google, Facebook, or LinkedIn.

Developer Tasks:

• Search for Routing Challenges: Practice problems related to routing and HTTP methods.

10. Data Structures and Algorithms (DSA) Focus

What are Data Structures and Algorithms?

DSA are fundamental concepts for efficiently organizing and processing data.

Focus Areas:

1. HTTP Methods and Routing Techniques:
   • Analyze how different methods and routing techniques impact performance.
2. Optimization:
   • Study optimization strategies for efficient routing and request handling.

Developer Tasks:

• Analyze Routing Performance: Evaluate how routing affects application performance.
• Practice Optimization: Work on optimizing routes and request processing.

This session provides a detailed exploration of routing in Express.js, including practical examples, real-time API data, and comprehensive best practices for API development and documentation.