Métodos DELETE en controladores

En NestJS, la capacidad de eliminar recursos es tan fundamental como crearlos o actualizarlos. El método HTTP DELETE está diseñado precisamente para este propósito: permitir la eliminación de un recurso específico identificado por su ID o cualquier otro parámetro único en tu API.

Para definir un método DELETE en un controlador de NestJS, utilizamos el decorador @Delete() sobre la función que manejará las solicitudes.

Creación de un controlador con método DELETE

Para empezar, se creará un controlador.

NestJS proporciona una serie de decoradores que facilitan la definición de rutas y métodos HTTP. El decorador @Delete() es clave aquí, ya que especifica que el método subsiguiente se utilizará para manejar las solicitudes HTTP DELETE.

Ejemplo:

// src/items/items.controller.ts
import { Controller, Delete, Param, HttpCode, HttpStatus, NotFoundException } from '@nestjs/common';

@Controller('items')
export class ItemsController {
  // Simulación de una base de datos en memoria para el ejemplo
  private items: string[] = ['item1', 'item2', 'item3'];

  @Delete(':id')
  @HttpCode(HttpStatus.NO_CONTENT) // Para una eliminación exitosa, respondemos con 204 No Content
  async deleteItem(@Param('id') id: string): Promise<void> {
    // Aquí iría la lógica para eliminar el ítem de la base de datos.
    const initialLength = this.items.length;
    this.items = this.items.filter(item => item !== id);

    if (this.items.length === initialLength) {
      // Si el ID no existe o no se encontró el ítem para eliminar
      throw new NotFoundException(`Ítem con ID "${id}" no encontrado.`);
    }

    // No devolvemos nada explícitamente; NestJS enviará 204 No Content
  }
}

En este ejemplo, tenemos un controlador para items. El método deleteItem está designado para manejar las solicitudes DELETE dirigidas a /items/:id, donde :id es un parámetro que representa el identificador del ítem a eliminar.

El decorador @Param('id') se utiliza para extraer el valor del parámetro id de la ruta. Así, si alguien envía una solicitud DELETE a /items/123, el método deleteItem recibirá '123' como el valor de id.

Hemos añadido @HttpCode(HttpStatus.NO_CONTENT) para indicar que, en caso de éxito, la API debe responder con un código de estado 204 No Content. Esta es la respuesta RESTful estándar para una eliminación exitosa que no necesita devolver ningún contenido en el cuerpo de la respuesta.

Integración con un Servicio para la Lógica de Eliminación

El método anterior es sólo un esqueleto. En una aplicación real, la lógica de eliminación no residirá directamente en el controlador. En su lugar, se delega a un servicio que gestiona la interacción con la base de datos o cualquier otro sistema de persistencia.

Ejemplo con un servicio:

Primero, se crea un servicio:

// src/items/items.service.ts
import { Injectable, NotFoundException } from '@nestjs/common';

@Injectable()
export class ItemsService {
  private items: string[] = ['item1', 'item2', 'item3', '404']; // Simulación de ítems existentes

  async delete(id: string): Promise<void> {
    // Aquí iría la lógica real para eliminar el ítem de la base de datos.
    // Simulamos la eliminación:
    const initialLength = this.items.length;
    this.items = this.items.filter(item => item !== id);

    if (this.items.length === initialLength) {
      // Si el ítem no se encontró y no se pudo eliminar
      throw new NotFoundException(`Ítem con ID "${id}" no encontrado.`);
    }
    // Si la eliminación fue exitosa, no se devuelve nada.
  }
}

Luego, se integra el servicio en el controlador:

// src/items/items.controller.ts
import { Controller, Delete, Param, HttpCode, HttpStatus, NotFoundException } from '@nestjs/common';
import { ItemsService } from './items.service'; // Importa el servicio

@Controller('items')
export class ItemsController {

  constructor(private readonly itemsService: ItemsService) {} // Inyección de dependencias

  @Delete(':id')
  @HttpCode(HttpStatus.NO_CONTENT) // Establecemos el código de estado 204 para éxito
  async deleteItem(@Param('id') id: string): Promise<void> {
    await this.itemsService.delete(id);
    // El servicio se encarga de la lógica y las excepciones.
    // Si el servicio no lanza un error, NestJS responderá con 204 No Content.
  }
}

Ahora, el método deleteItem del controlador utiliza el servicio ItemsService para llevar a cabo la eliminación real del ítem.

Manejo de errores

En una aplicación real, es fundamental manejar las situaciones donde no se puede eliminar un ítem, ya sea porque no existe, el usuario no tiene permisos, o por algún error interno. NestJS proporciona un sistema de excepciones robusto para gestionar estos escenarios de forma eficiente.

En el ejemplo del servicio, ya hemos visto cómo lanzar una NotFoundException si el ítem no se encuentra. NestJS intercepta automáticamente estas excepciones y genera la respuesta HTTP adecuada (en este caso, un 404 Not Found).

// src/items/items.service.ts (fragmento)
import { Injectable, NotFoundException } from '@nestjs/common';

@Injectable()
export class ItemsService {
    // ...
    async delete(id: string): Promise<void> {
        // Lógica de eliminación...
        if (/* ítem no encontrado */) {
            throw new NotFoundException(`Ítem con ID "${id}" no encontrado.`);
        }
        // ...
    }
}

Consideraciones adicionales para el manejo de errores:

• Otros Tipos de Excepciones: Existen otras excepciones integradas en NestJS, como ForbiddenException (para problemas de permisos), BadRequestException (para solicitudes inválidas), etc., que puedes usar para distintos escenarios.
• Centralización de Errores (Filtros de Excepción): Para un manejo más avanzado y centralizado de los errores en tu aplicación, NestJS ofrece los Filtros de Excepción. Te recomendamos revisar la lección "Gestión de errores en controladores" para aprender cómo implementar filtros de excepción personalizados que te permitirán manejar errores de manera uniforme en toda tu API.

Conclusión

Los métodos DELETE en los controladores de NestJS ofrecen una forma efectiva y estándar de eliminar datos específicos. Al combinar el uso del decorador @Delete(), la inyección de dependencias en servicios para la lógica de negocio, el manejo de excepciones y la respuesta 204 No Content para eliminaciones exitosas, puedes construir APIs RESTful que son claras, robustas y se adhieren a las mejores prácticas.