CRUD sencillo con Framework NestJS

Introducción

Para casi todas las aplicaciones es necesario hacer un CRUD con ciertos elementos de base de datos. Pero en sí ¿Qué es un CRUD?. CRUD es un acrónimo que cada una de sus letras significa:

• C (Create): Que es el procedimiento en el cual se crea un objeto en base de datos.
• R (Read): Cuando realizamos la acción de leer objeto u objetos de la base de datos.
• U (Update): Cuando queremos actualizar uno o más elemento (por lo general es uno, pero siempre habrán donde se tenga que actualizar varios en una sola petición)
• D (Delete): Para indicar que se debe remover un objeto de la base de datos.

Para poder ejecutar este tutorial, necesitas haber instalado y poder ejecutar NestJS con lo básico, igualmente desde este enlace puedes hacer la parte de instalación.

Manos a la obra

Primero que nada, les regalo la colección JSON con las API Request que usaremos y que pueden importar fácilmente en la aplicación Postman, les dejó el enlace aquí. Haremos un CRUD de cursos, donde listaremos cuales tenemos en espera, en progreso y finalizados.

Para realizar el CRUD, necesitaremos un lugar donde guardar los datos y la lógica que supondrá almacenarla, actualizar, listarla y eliminarla. Para ello trabajaremos en nuestro archivo src/app.service.ts (Básicamente el framework nos recomienda trabajar nuestra lógica en los archivos services de nuestro módulos), nos debe quedar de la siguiente manera:

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

// Recomendación pasar enum e interfaces a archivos dedicados a tal fin
export enum State {
  wait,
  progress,
  completed
}

export interface ICourseKey {
  id:number;
}

export interface ICourseAttributes {
  name: string;
  state: State;
}

export interface ICourse extends ICourseKey, ICourseAttributes {}

@Injectable()
export class AppService {

  private courses: ICourse[] = []

  async getCourses(): Promise<ICourse[]>{
    return this.courses
  }

  async findCourse( id: number): Promise<ICourse>{
    return this.courses.find((item) => item.id == <number>id)
  }

  async createCourse( course: ICourseAttributes ): Promise<ICourse>{

    const idNext = (this.courses.length)? this.courses[this.courses.length - 1].id + 1: 1
    const newLength = this.courses.push({ id:idNext, ...course })
    
    return this.courses[newLength - 1]
  }

  async updateCourse( id: number, course: ICourseAttributes ): Promise<ICourse>{

    const updateIndex: number = this.courses.findIndex(item => item.id == <number>id)
    this.courses[updateIndex].name = course.name
    this.courses[updateIndex].state = course.state

    return this.courses[updateIndex]
  }

  async deleteCourse(id: number): Promise<ICourse> {

    const startIndex:number = this.courses.findIndex(item => item.id === id)
    const deleteCourse = this.courses.splice(startIndex, 1)

    return deleteCourse[0]
  }

}

Donde la primara parte se crean las interfaces y enum que usaremos para este CRUD. Cabe destacar que estos archivos por lo general se colocan en un archivo aparte destinado para ello, pero para hacerlo más rápido lo coloque aquí. Si se fijan los estoy exportando, precisamente para que puedan ser usados en el exterior.

Como vemos en el enum State dejamos claro que solo existen 3 tipos de estado y dividimos en tres partes las características del curso, donde una interfaz indica las llaves que identifica un objeto y el otro los atributos, para finalmente unirse en ICourse.

Luego llegamos a la clase AppService, donde se concentrá la lógica del CRUD y la variable donde almacenamos los cursos.

Donde courses es la variable donde almacenamos la información de nuestros cursos y lo siguiente son los métodos asíncronos, donde en cada uno retornamos una promesa ya de sea un objeto o varios objetos de tipo ICourse. Igualmente aquí describo que hace cada método para que lo puedan analizar:

• getCourses: Obtiene un listado de todos los cursos.
• findCourse: Obtiene un curso mediante el id (Identificador) del curso.
• createCourse: Crea un curso y lo guarda en la lista de cursos.
• updateCourse: Actualiza un curso de la lista de cursos guardados, mediante su id (Identificador).
• deleteCourse: Eliminar un curso de la lista de cursos guardados, mediante su id (Identificador).

import { Controller, Get, Post, Body, Put, Param, Delete } from '@nestjs/common';
import { AppService, ICourseAttributes } from './app.service';

@Controller()
export class AppController {

  constructor(private readonly appService: AppService) {}

  @Get()
  getCourses(){
    return this.appService.getCourses()
  }

  @Post()
  createCourse(@Body() course:ICourseAttributes){
    return this.appService.createCourse(course)
  }

  @Delete(':id')
  deleteCourse(@Param('id') id:number){
    return this.appService.deleteCourse(id)
  }
}

Como vemos en el controlador ya fue inyectado el objeto appService, donde posee todos los métodos pertinentes para el CRUD.

Elementos importantes:

@Get: Decorador que indica que para ejecutar este método accedemos con el método GET de una petición API Rest.
@Post: Decorador que indica que para ejecutar este método accedemos con el método POST de una petición API Rest.
@Delete: Decorador que indica que para ejecutar este método accedemos con el método DELETE de una petición API Rest.
@Put: Decorador que indica que para ejecutar este método accedemos con el método PUT de una petición API Rest.
@Body: Decorador que indica obtener los valores del body de la petición API Rest.
@Param: Decorador que indica obtener los valores dispuestos en la URL. Previamente debe indicar que valores recibirá la API, como trabajamos con express sobre Nestjs, debemos colocar por delante ":" para indicar el parámetro a recibir.

Ya en este punto pueden crear cursos, luego consultarlos y si quieren los pueden eliminar. Para que lo puedan ver en ejecución y probar con Postman, deben ejecutar el siguiente comando en el terminal:

yarn start:dev

IMPORTANTE:  Aquí solo muestro obtener todos los cursos, crear un curso y eliminarlo, queda como tarea obtener un solo curso y actualizar un curso sabiendo su id. Es decir deben hacer funcionar todas las API Request que están en la colección que les dí en un principio.

Conclusión

Hasta aquí ha llegado este tutorial de como implementar un CRUD con NestJS, realmente no es difícil aplicarlo, sino hay que seguir ciertas pautas, para obtener un desarrollo más limpio y organizado. Sin más me despido, espero les vaya muy bien con las API restantes que dejé como tarea, hasta pronto.