Tutorial Nest: CRUD con repositorios

Dentro de NestJS, uno de los conceptos más comunes es la creación de servicios que interactúan con bases de datos para realizar operaciones CRUD.

CRUD es un acrónimo de "Create, Read, Update, Delete", que se refiere a las operaciones básicas que se pueden realizar sobre un conjunto de datos.

Para implementar métodos CRUD en repositorios, primero se necesita definir un modelo de datos que represente la estructura de los objetos que se almacenarán en la base de datos. Luego, se crea un repositorio que contiene métodos para realizar las operaciones CRUD en estos objetos.

Creación de un servicio CRUD

Este ejemplo asume que ya existe una base de datos configurada y lista para usar con TypeORM.

1. Crear la entidad Task

// src/tasks/task.entity.ts
import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm';

@Entity()
export class Task {
@PrimaryGeneratedColumn()
id: number;

    @Column()
    title: string;

    @Column()
    description: string;

    @Column({ default: false })
    completed: boolean;
}

2. Crear el módulo TasksModule

// src/tasks/tasks.module.ts
import { Module } from '@nestjs/common';
import { TasksController } from './tasks.controller';
import { TasksService } from './tasks.service';
import { TypeOrmModule } from '@nestjs/typeorm';
import { Task } from './task.entity';

@Module({
imports: [TypeOrmModule.forFeature([Task])],
controllers: [TasksController],
providers: [TasksService],
})
export class TasksModule {}

3. Crear el servicio TasksService

// src/tasks/tasks.service.ts
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { Task } from './task.entity';

@Injectable()
export class TasksService {
    constructor(@InjectRepository(Task) private tasksRepository: 
    Repository<Task>) {}

    // Obtener todas las tareas
    findAll(): Promise<Task[]> {
        return this.tasksRepository.find();
    }

    // Obtener una tarea por su ID
    findOne(id: number): Promise<Task> {
        return this.tasksRepository.findOne(id);
    }

    // Crear una nueva tarea
    async create(task: Partial<Task>): Promise<Task> {
        const newTask = this.tasksRepository.create(task);
        return this.tasksRepository.save(newTask);
    }

    // Actualizar una tarea existente por su ID
    async update(id: number, task: Partial<Task>): Promise<Task> {
        await this.tasksRepository.update(id, task);
        return this.tasksRepository.findOne(id);
    }

    // Eliminar una tarea por su ID
    async remove(id: number): Promise<void> {
        await this.tasksRepository.delete(id);
    }
}

4. Crear el controlador TasksController

// src/tasks/tasks.controller.ts
import { Controller, Get, Post, Put, Delete, Param, Body } from '@nestjs/common';
import { TasksService } from './tasks.service';
import { Task } from './task.entity';

@Controller('tasks')
export class TasksController {
    constructor(private readonly tasksService: TasksService) {}

    // Obtener todas las tareas
    @Get()
    findAll(): Promise<Task[]> {
        return this.tasksService.findAll();
    }

    // Obtener una tarea por su ID
    @Get(':id')
    findOne(@Param('id') id: number): Promise<Task> {
        return this.tasksService.findOne(id);
    }

    // Crear una nueva tarea
    @Post()
    create(@Body() task: Partial<Task>): Promise<Task> {
        return this.tasksService.create(task);
    }

    // Actualizar una tarea existente por su ID
    @Put(':id')
    update(@Param('id') id: number, @Body() task: Partial<Task>): 
    Promise<Task> {
        return this.tasksService.update(id, task);
    }

    // Eliminar una tarea por su ID
    @Delete(':id')
    remove(@Param('id') id: number): Promise<void> {
        return this.tasksService.remove(id);
    }
}

5. Importar TasksModule en AppModule:

// src/app.module.ts
import { Module } from '@nestjs/common';
import { TypeOrmModule } from '@nestjs/typeorm';
import { TasksModule } from './tasks/tasks.module'; // Añadir importación de Task

@Module({
imports: [
TypeOrmModule.forRoot({
type: 'mysql',
host: 'localhost',
port: 3306,
username: 'your_username',
password: 'your_password',
database: 'your_database',
entities: [Task],
synchronize: true,
}),
TasksModule,
],
})
export class AppModule {}

6. Archivo main.ts

Es necesario que el archivo main.ts esté configurado correctamente para iniciar la aplicación NestJS:

// src/main.ts
import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';

async function bootstrap() {
const app = await NestFactory.create(AppModule);
await app.listen(3000);
}
bootstrap();

Con esta implementación, se obtiene un CRUD completo de tareas usando NestJS y TypeORM.

Las rutas se pueden probar con una herramienta como Postman o curl para verificar de que estén funcionando correctamente.

• Para obtener todas las tareas: GET http://localhost:3000/tasks
• Para obtener una tarea específica: GET http://localhost:3000/tasks/:id
• Para crear una tarea: POST http://localhost:3000/tasks con un objeto JSON en el cuerpo de la solicitud que contenga las propiedades title y description.
• Para actualizar una tarea: PUT http://localhost:3000/tasks/:id con un objeto JSON en el cuerpo de la solicitud que contenga las propiedades que desees actualizar.
• Para eliminar una tarea: DELETE http://localhost:3000/tasks/:id

Se debe reemplazar :id con el ID de la tarea que se desea obtener, actualizar o eliminar.

Conclusión

Los métodos CRUD en repositorios en NestJS son funciones esenciales para interactuar con una base de datos y realizar operaciones básicas de creación, lectura, actualización y eliminación de registros. Estos métodos son fundamentales para construir aplicaciones web y API RESTful eficientes y escalables.