NestJS has rapidly become a favorite for developers crafting scalable and efficient server-side applications. One of the core features that contribute to this is its powerful architecture, which emphasizes modularity and ease of use. In this article, we'll delve into the fundamental concepts of controllers and routing in NestJS, helping you streamline your API development process.

Understanding Controllers

Controllers in NestJS serve as the entry point for incoming requests. They handle incoming routes and implement the business logic for processing requests and returning responses. Think of controllers as the coordinators of your application, linking incoming requests with the appropriate service providers.

Here's how you can create a simple controller in NestJS:

Example: Creating a Basic Controller

1. Create the Controller

   You can generate a controller using the NestJS CLI:

   nest generate controller users

   This command creates a new users.controller.ts file.

2. Define the Controller

   Open the users.controller.ts file and define your controller to handle user-related operations:

   import { Controller, Get, Post, Body } from '@nestjs/common';
   import { UsersService } from './users.service';
   import { CreateUserDto } from './dto/create-user.dto';
   
   @Controller('users')
   export class UsersController {
     constructor(private readonly usersService: UsersService) {}
   
     @Get()
     findAll() {
       return this.usersService.findAll();
     }
   
     @Post()
     create(@Body() createUserDto: CreateUserDto) {
       return this.usersService.create(createUserDto);
     }
   }

In this snippet, we define a UsersController. It has two route handlers:

• findAll() responds to GET requests at the /users endpoint.
• create() handles POST requests at the same endpoint, using the provided user data from the request body.

Routing in NestJS

Routing in NestJS allows you to define how your application responds to different HTTP requests. This includes GET, POST, PUT, DELETE, and more. NestJS provides decorators to facilitate this process within your controllers.

Example: Routing Decorators

Let’s break down the decorators we’ve used in the previous example:

• @Controller('users'): This decorator specifies the route prefix for all routes in this controller. In this case, the routes will be prefixed with /users.

• @Get(): This decorator specifies that the method should handle GET requests. You can also define a specific endpoint by passing a string argument, such as @Get('all').

• @Post(): Similarly, this decorator indicates that the method handles POST requests.

• @Body(): This decorator extracts the request body from POST requests, allowing you to easily access input data.

Advanced Routing Features

To expand on basic routing, you can define more sophisticated routes by leveraging parameters, query strings, and even wildcard routes.

Example: Route Parameters and Query Strings

Enhance your UsersController with route parameters to fetch a specific user:

@Get(':id')
findOne(@Param('id') id: string) {
  return this.usersService.findOne(id);
}

In this addition, the findOne() method responds to GET requests at /users/:id, where :id is a dynamic parameter representing the user ID. The @Param() decorator extracts this parameter from the request.

For query strings, you can use the @Query() decorator, like so:

@Get()
findAll(@Query('age') age: number) {
  return this.usersService.findAllByAge(age);
}

In this case, you can request users based on their age by accessing: /users?age=30.

Creating and Handling DTOs

Data Transfer Objects (DTOs) are crucial for ensuring that the data sent in requests conforms to a specific structure. Using DTOs can help prevent unwanted data from reaching your application logic.

Example: Define a DTO

1. Create a DTO Class

   Create a create-user.dto.ts file:

   export class CreateUserDto {
     readonly username: string;
     readonly password: string;
   }

2. Integrate DTO in the Controller

   Notice how we used CreateUserDto in our create() method. This ensures that any incoming requests conform to the expected structure, allowing you to validate the data before processing.

Best Practices for Controllers and Routing

As you build your application, consider the following best practices:

1. Keep Controllers Thin: Delegate business logic to services. Controllers should primarily direct traffic and handle requests.

2. Use DTOs for Validation: Implement DTOs and leverage class-validator for request validation to ensure that your APIs remain robust.

3. Organize Routes Clearly: Group related routes logically by using controller prefixes, which can help maintain clarity in larger applications.

4. Modularize Your Code: Utilize NestJS’s module system to separate concerns and improve maintainability.

5. Consistent Naming Conventions: Follow a consistent naming scheme for endpoints, controllers, and services to ease navigation and understanding of your codebase.

Armed with the knowledge of controllers and routing, you're well on your way to building powerful APIs with NestJS. With its clear structure and focus on best practices, you’ll find yourself developing reliable backend systems that are both efficient and maintainable.