Tutorial Nest: Métodos PUT en controladores

En NestJS se proporcionan varios decoradores que facilitan la creación de rutas API RESTful. Uno de estos decoradores es @Put(), que se utiliza específicamente para manejar solicitudes HTTP PUT.

Concepto de método PUT

El método PUT en HTTP es utilizado principalmente para actualizar un recurso existente o, en algunos casos, para crear un recurso si no existe.

En términos simples, el método PUT es una forma de decir: "Aquí tienes la nueva versión de este recurso, por favor, actualiza o crea este recurso con la información proporcionada".

Uso de @Put() en NestJS

Para manejar las solicitudes PUT en NestJS, se utiliza el decorador @Put() en los métodos de un controlador.

A continuación, se muestra cómo implementar un método PUT en un controlador utilizando NestJS.

Creación de un controlador básico

Primero, suponiendo que se tiene un recurso llamado "producto", se puede crear un controlador llamado productos.controller.ts:

import { Controller } from '@nestjs/common';

@Controller('productos')
export class ProductosController {}

Implementación del método PUT

Dentro de este controlador, se puede agregar un método para actualizar un producto utilizando el decorador @Put():

import { Controller, Put, Body, Param } from '@nestjs/common';

@Controller('productos')
export class ProductosController {

  @Put(':id')
  actualizarProducto(@Param('id') id: string, @Body() productoDto: any): string {
    // Aquí se actualizaría el producto con el ID y los datos proporcionados
    return `Producto con ID ${id} actualizado con éxito`;
  }
}

Explicación:

1. @Put(':id'): Este decorador indica que el método actualizarProducto manejará las solicitudes PUT que vengan con un ID en la URL (por ejemplo, PUT /productos/123).

2. @Param('id') id: string: Este fragmento recupera el valor id desde la URL y lo pasa al parámetro id del método.

3. @Body() productoDto: any: Esto recupera el cuerpo de la solicitud HTTP y lo pasa al parámetro productoDto. En una aplicación real, en lugar de usar any, se usaría una clase o interfaz específica para validar los datos entrantes.

Uso avanzado de @Put() en NestJS

A medida que las aplicaciones crecen en complejidad, se pueden utilizar más características de NestJS para mejorar y refinar la implementación de los métodos PUT.

Validación del cuerpo de la solicitud

NestJS se integra fácilmente con class-validator y class-transformer para validar y transformar el cuerpo de la solicitud. Usando estos paquetes, se puede garantizar que los datos enviados en una solicitud PUT cumplan con ciertas reglas y estructuras.

Supongamos que el producto tiene ciertas propiedades específicas que se quieren validar. Se podría crear un DTO (Data Transfer Object) para esto:

import { IsString, IsNotEmpty, IsNumber } from 'class-validator';

export class ProductoDto {
  @IsString()
  @IsNotEmpty()
  nombre: string;

  @IsNumber()
  precio: number;
}

Y luego, en el controlador:

import { Controller, Put, Body, Param } from '@nestjs/common';
import { ProductoDto } from './producto.dto';

@Controller('productos')
export class ProductosController {

  @Put(':id')
  actualizarProducto(@Param('id') id: string, @Body() productoDto: ProductoDto): string {
    // Aquí se actualizaría el producto con el ID y los datos proporcionados
    return `Producto con ID ${id} actualizado con éxito`;
  }
}

Con esta configuración, NestJS se encargaría automáticamente de validar que el cuerpo de la solicitud cumple con las reglas definidas en ProductoDto. Si no es así, la solicitud sería rechazada automáticamente antes de llegar al método del controlador.

Manejo de errores

Una buena práctica es manejar posibles errores que puedan ocurrir durante la actualización.

NestJS proporciona una serie de excepciones que se pueden utilizar para manejar distintos tipos de errores.

import { Controller, Put, Body, Param, NotFoundException } from '@nestjs/common';
import { ProductoDto } from './producto.dto';

@Controller('productos')
export class ProductosController {

    private productos = []; // Supongamos que tenemos una lista de productos en memoria

    @Put(':id')
    actualizarProducto(@Param('id') id: string, @Body() productoDto: ProductoDto): string {
        // Lógica para verificar si el producto existe
        const productoExistente = this.productos.find(producto => producto.id === id);

        if (!productoExistente) {
            throw new NotFoundException(`Producto con ID ${id} no encontrado`);
        }

        // Lógica para actualizar el producto
        // Supongamos que productoDto contiene los nuevos datos a actualizar
        productoExistente.nombre = productoDto.nombre;
        productoExistente.precio = productoDto.precio;

        return `Producto con ID ${id} actualizado con éxito`;
    }
}

Aquí, si el producto no se encuentra, se lanza una excepción NotFoundException, que NestJS manejará enviando una respuesta con un código de estado HTTP 404.

Conclusión

El uso del método PUT en NestJS es poderoso y flexible. Con una combinación de decoradores, validación de datos y manejo de errores, se pueden construir APIs robustas y confiables.