**Course Title:** Mastering NestJS: Building Scalable Server-Side Applications **Section Title:** Controllers and Routing **Topic:** Handling HTTP requests and responses In this topic, we will delve into the world of HTTP requests and responses in NestJS. We will explore how to handle different types of HTTP requests, how to return responses, and how to use middleware to enhance our application's functionality. ### Overview of HTTP Requests and Responses In the context of web development, HTTP (Hypertext Transfer Protocol) is a protocol used for transferring data between a client (usually a web browser) and a server. When a client sends a request to a server, the server processes the request and returns a response. The request and response are both composed of headers and a body. #### HTTP Request Methods There are several HTTP request methods that can be used to interact with a server: * **GET**: Retrieves data from the server. * **POST**: Sends data to the server to create a new resource. * **PUT**: Updates an existing resource on the server. * **DELETE**: Deletes a resource from the server. #### HTTP Response Status Codes HTTP response status codes indicate the outcome of a request. Here are some common status codes: * **200 OK**: The request was successful. * **404 Not Found**: The requested resource was not found. * **500 Internal Server Error**: An error occurred on the server. ### Handling HTTP Requests in NestJS In NestJS, we can handle HTTP requests using controllers. A controller is a class that handles incoming requests and returns responses. #### Creating a Controller To create a controller, we can use the `@Controller` decorator and specify the path of the controller. For example: ```typescript import { Controller, Get } from '@nestjs/common'; @Controller('users') export class UsersController { @Get() getAllUsers(): string { return 'Get all users'; } } ``` In this example, we have created a `UsersController` that handles GET requests to the `/users` path. #### Handling Different Types of Requests We can handle different types of requests using different decorators. For example: ```typescript import { Controller, Get, Post, Put, Delete } from '@nestjs/common'; @Controller('users') export class UsersController { @Get() getAllUsers(): string { return 'Get all users'; } @Post() createUser(): string { return 'Create a new user'; } @Put(':id') updateUser(): string { return 'Update a user'; } @Delete(':id') deleteUser(): string { return 'Delete a user'; } } ``` In this example, we have handled different types of requests using different decorators. ### Returning Responses We can return responses using the `@Res` decorator. For example: ```typescript import { Controller, Get, Res } from '@nestjs/common'; @Controller('users') export class UsersController { @Get() getAllUsers(@Res() res): string { return res.status(200).send('Get all users'); } } ``` In this example, we have returned a response with a status code of 200. ### Using Middleware We can use middleware to enhance our application's functionality. Middleware is a function that runs before or after a controller. For example: ```typescript import { Controller, Get, Res, UseInterceptors } from '@nestjs/common'; import { Interceptor } from './interceptor'; @Controller('users') export class UsersController { @Get() @UseInterceptors(Interceptor) getAllUsers(@Res() res): string { return res.status(200).send('Get all users'); } } ``` In this example, we have used a middleware to intercept the request. ### Conclusion In this topic, we have covered how to handle HTTP requests and responses in NestJS. We have explored how to handle different types of requests, how to return responses, and how to use middleware to enhance our application's functionality. ### What's Next? In the next topic, we will cover how to implement route guards for authentication. ### Leave a Comment or Ask for Help If you have any questions or need help with implementing route guards for authentication, please leave a comment below. ### External Resources * [NestJS Documentation](https://docs.nestjs.com/) * [NestJS GitHub Repository](https://github.com/nestjs/nest) ### Practice Exercise Implement a route guard for authentication in a NestJS application. ### Solution ```typescript import { Injectable } from '@nestjs/common'; import { CanActivate, ExecutionContext } from '@nestjs/common'; import { Reflector } from '@nestjs/core'; @Injectable() export class AuthGuard implements CanActivate { constructor(private readonly reflector: Reflector) {} canActivate(context: ExecutionContext): boolean { const requiredRoles = this.reflector.get<string[]>('roles', context.getHandler()); if (!requiredRoles) { return true; } const request = context.switchToHttp().getRequest(); const user = request.user; return requiredRoles.includes(user.role); } } ``` ```typescript import { Controller, Get, UseGuards } from '@nestjs/common'; import { AuthGuard } from './auth.guard'; @Controller('users') export class UsersController { @Get() @UseGuards(AuthGuard) getAllUsers(): string { return 'Get all users'; } } ``` In this example, we have implemented a route guard for authentication using the `AuthGuard` class. The `AuthGuard` class checks if the user has the required roles. If the user has the required roles, the `canActivate` method returns `true`, allowing the request to proceed. Otherwise, it returns `false`, preventing the request from proceeding.