Routes and Request Handling

When you build a web API, you need a way for clients (like a browser or mobile app) to send requests to specific functions on your server. This is where routes come in!

A route defines how a client's request URL (like /users or /products/1) maps to a particular action in your application code. It's like a street address for your API's functionalities.

Besides the URL, every request also uses an HTTP method, which tells the server what kind of action the client wants to perform. Common methods include:

• GET: Retrieve data (e.g., get a list of users).
• POST: Create new data (e.g., create a new user).
• PUT: Update existing data completely.
• PATCH: Partially update existing data.
• DELETE: Remove data.

NestJS uses decorators like @Get() or @Post() to link these methods to your controller functions.

Let's define a simple route to fetch some data. In NestJS, you use controllers to handle incoming requests and define routes.

The @Controller() decorator defines a base path for all routes within that controller. Then, methods like @Get() define specific endpoints and their HTTP methods.

Here's a basic NestJS app with a /greet endpoint. Run this example, then try accessing http://localhost:3000/greet in your browser or a tool like Postman.

You should see: Hello from NestJS!

Often, you need routes that include dynamic data, like fetching a specific user by their ID (e.g., /users/123). These are called path parameters.

In NestJS, you define path parameters using a colon (:) followed by the parameter name in your @Get() decorator (e.g., @Get(':id')). You then extract its value using the @Param() decorator in your method signature.

This example shows how to get a user ID from the URL path. If you run this, then visit http://localhost:3000/users/123, the output will be:

Query parameters are another way to pass data to your routes, often used for optional filtering, sorting, or pagination (e.g., /items?category=books&limit=5).

These parameters appear after a question mark (?) in the URL, as key-value pairs separated by ampersands (&). NestJS lets you easily access them using the @Query() decorator.

This route uses query parameters to filter items. If you run this, then visit http://localhost:3000/items?category=books&limit=5, you'll see:

For operations that send a lot of data, like creating a new resource (POST) or updating an existing one (PUT), the data is typically sent in the request body.

The request body can contain structured data, often JSON. NestJS provides the @Body() decorator to easily parse and extract this data directly into your controller method's arguments.

This example shows how to accept data in the request body for a POST request. If you send a POST request to http://localhost:3000/products with a JSON body like {"name": "Laptop", "price": 1200}, the output will be:

Consider the following NestJS controller snippet:

import { Controller, Get, Param, Query } from '@nestjs/common';

@Controller('articles')
class ArticlesController {
  @Get(':id')
  getArticleById(@Param('id') id: string): string {
    return `Article ID: ${id}`;
  }

  @Get()
  searchArticles(@Query('keyword') keyword: string): string {
    return `Searching for: ${keyword || 'all articles'}`;
  }
}

Which URL would successfully retrieve an article with ID "123"?

Great job! You've covered the fundamentals of defining API routes and handling different types of incoming data in NestJS:

• Routes map URLs to controller actions.
• HTTP methods (GET, POST, PUT, DELETE) define the action type.
• Path parameters (@Param()) capture dynamic segments from the URL path.
• Query parameters (@Query()) extract optional key-value pairs from the URL string.
• Request body (@Body()) handles data sent with POST/PUT requests.

These are crucial building blocks for any robust RESTful API!