Tenemos que crear un archivo llamado src/filter/http-exception.filter.ts

import {
  ExceptionFilter,
  Catch,
  ArgumentsHost,
  HttpException,
  HttpStatus,
} from '@nestjs/common';
import { Request, Response } from 'express';
import { Prisma } from '../../generated/prisma/client';

@Catch()
export class AllExceptionsFilter implements ExceptionFilter {
  catch(exception: unknown, host: ArgumentsHost) {
    const ctx = host.switchToHttp();
    const response = ctx.getResponse<Response>();
    const request = ctx.getRequest<Request>();

    let status = HttpStatus.INTERNAL_SERVER_ERROR;
    let message: string | string[] = 'Error interno del servidor';

    // Error de NestJS (404, 400, etc.)
    if (exception instanceof HttpException) {
      status = exception.getStatus();
      const exceptionResponse = exception.getResponse();
      message =
        typeof exceptionResponse === 'object'
          ? (exceptionResponse as any).message
          : exceptionResponse;
    }

    // Error de Prisma — constraint unique (email o dni duplicado)
    else if (exception instanceof Prisma.PrismaClientKnownRequestError) {
      if (exception.code === 'P2002') {
        status = HttpStatus.CONFLICT; // 409
        const fields = (exception.meta?.target as string[])?.join(', ');
        message = `Ya existe un registro con ese ${fields}`;
      }
      // Error de FK — registro relacionado no existe
      else if (exception.code === 'P2003') {
        status = HttpStatus.BAD_REQUEST; // 400
        message = 'El registro relacionado no existe';
      }
      // Registro no encontrado al hacer update/delete
      else if (exception.code === 'P2025') {
        status = HttpStatus.NOT_FOUND; // 404
        message = 'Registro no encontrado';
      }
    }

    response.status(status).json({
      success: false,
      statusCode: status,
      message,
      timestamp: new Date().toISOString(),
      path: request.url,
    });
  }
}

@catch = Captura cualquier excepcion
@catch(HttpException) = Captura solo errores HTTP.
ArgumentHost = Es una bastraccion que permite acceder al request/response independientemente del protocolo (HTTP, WebSocket, microservicios)

Luego registrarlo globalmente en el main.ts. importando el mismo archivo creado y registrándolo de manera global.

...
import { AllExceptionsFilter } from './filters/http-exception.filter';

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

  // Exception Filter global
  app.useGlobalFilters(new AllExceptionsFilter());

...
}

Aunque existen niveles de aplicación como a un método o a un controlador (todos los endpoints) con @UseFilters() y toda la aplicación con app.useGlobalFilters()

Antes el error genérico era algo como:

{ "statusCode": 500, "message": "Internal server error" }

Ahora seria algo asi

{
  "success": false,
  "statusCode": 409,
  "message": "Ya existe un registro con ese email",
  "timestamp": "2026-06-19T03:00:00.000Z",
  "path": "/docente"
}

Eso seria, podemos gestionar diferentes errores de manera centralizada.

¡Saludos!

Extendiendo el proyecto de Usuario: Enlace

Podemos incluirle el Swagger para documentar la API.

instalar

npm install @nestjs/swagger

Es asi que al archivo de main.ts le voy a incluir o habilitar Swagger, hay que importar en el main y agregar las siguientes lineas

import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';

// Swagger
  const config = new DocumentBuilder()
      .setTitle('Sistema de Usuario API')
      .setDescription('API para gestion de usuarios')
      .setVersion('1.0')
      .addTag('usuario')
      .build();

  const document = SwaggerModule.createDocument(app, config);
  SwaggerModule.setup('api', app, document);

Quedando el archivo main.ts de la siguiente manera.

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { ValidationPipe } from '@nestjs/common'; // Validator
import { DocumentBuilder, SwaggerModule } from '@nestjs/swagger';

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

  app.useGlobalPipes(new ValidationPipe({
    whitelist: true, // Elimina los campos que no estan en los DTOs
    forbidNonWhitelisted: true, // Lanza un error si llegan campos extra
    transform: true,  // Transforma tipos automaticamente.
  }));

  // Swagger
  const config = new DocumentBuilder()
      .setTitle('Sistema de Usuario API')
      .setDescription('API para gestion de usuarios')
      .setVersion('1.0')
      .addTag('usuario')
      .build();

  const document = SwaggerModule.createDocument(app, config);
  SwaggerModule.setup('api', app, document);

  await app.listen(process.env.PORT ?? 3000);
}
bootstrap();

Luego hay que decorar los DTOs, importando el ApiProperty y utilizar el decorador en cada campo con la estructura de datos con example y description.

import { IsEmail, IsNotEmpty, IsString, IsNumber, Min, Max } from 'class-validator';
import { Type } from 'class-transformer';
import { ApiProperty } from '@nestjs/swagger';

export class CreateUsuarioDto {

    @ApiProperty({ example: 'Jefferson', description: 'Nombre del usuario'})
    @IsNotEmpty({message: 'El nombre es obligatorio'})
    @IsString()
    nombre!: string;

    @ApiProperty({ example: 'jeffsp@gmail.com', description: 'Correo del usuario'})
    @IsNotEmpty()
    @IsEmail({}, {message: 'Email inválido'})
    email!: string;

    @ApiProperty({ example: '30', description: 'Edad del usuario'})
    @IsNumber()
    @Min(18, {message: 'Debe de ser mayor de 18'})
    @Max(99)
    @Type( () => Number) //Aqui se utiliza la clase transform explicitamente.
    edad!: number;
}

Finalmente, mejorar el controlador con: ApiTags, ApiOperation y ApiResponse

import { Controller, Get, Post, Body, Patch, Param, Delete } from '@nestjs/common';
import { UsuarioService } from './usuario.service';
import { CreateUsuarioDto } from './dto/create-usuario.dto';
import { UpdateUsuarioDto } from './dto/update-usuario.dto';
import { ApiTags, ApiOperation, ApiResponse } from '@nestjs/swagger';

@ApiTags('usuario')
@Controller('usuario')
export class UsuarioController {
  constructor(private readonly usuarioService: UsuarioService) {}

  @ApiOperation({summary:'Crear nuevo usuario'})
  @ApiResponse({status:201, description:'Usuario creado'})
  @ApiResponse({status:400, description:'Datos inválidos'})
  @Post()
  create(@Body() createUsuarioDto: CreateUsuarioDto) {
    return this.usuarioService.create(createUsuarioDto);
  }

  @ApiOperation({summary: 'Listar todos los usuarios'})
  @ApiResponse({status:200, description:'Lista de usuarios'})
  @Get()
  findAll() {
    return this.usuarioService.findAll();
  }

  @ApiOperation({summary: 'Obtener usuario por ID'})
  @ApiResponse({status:200, description: 'Usuario encontrado'})
  @ApiResponse({status:404, description: 'Usuario no encontrado'})
  @Get(':id')
  findOne(@Param('id') id: string) {
    return this.usuarioService.findOne(+id);
  }

  @ApiOperation({summary: 'Actualizar usuario'})
  @ApiResponse({status: 200, description: 'Usuario actualizado'})
  @Patch(':id')
  update(@Param('id') id: string, @Body() updateUsuarioDto: UpdateUsuarioDto) {
    return this.usuarioService.update(+id, updateUsuarioDto);
  }

  @ApiOperation({summary: 'Eliminar usuario'})
  @ApiResponse({status: 200, description: 'Usuario Eliminado'})
  @Delete(':id')
  remove(@Param('id') id: string) {
    return this.usuarioService.remove(+id);
  }
}

Descripción de decoradores:

• @ApiTags(‘usuario’) = Agrupa endpoints bajo una sección en la UI
• @ApiProperty() = Documenta cada campo del DTO con ejemplo
• @ApiOperation() = Describe qué hace el endpoint
• @ApiResponse() = Documenta los posibles códigos de respuesta

Ello seria suficiente para tener una API documentada.

Una vez configurado, accede a http://localhost:3000/api para ver la documentación interactiva.

¡Saludos!

Descripción

class-transform

Se encarga de cambiar al tipo correcto de dato.

En el servicio no se ven por que hacen su trabajo antes de que llegue el request ahí. El servicio recibe los datos ya validados y transformados.

Donde actúan los transformers en el Param(‘id’) del controlador.

// Sin transform: true
@Get(':id')
findOne(@Param('id') id: string) {  // id llega como STRING "1"
  return this.usuarioService.findOne(+id); // necesitas el +id para convertir
}

// Con transform: true puedes hacer esto:
@Get(':id')
findOne(@Param('id', ParseIntPipe) id: number) { // id ya llega como NUMBER
  return this.usuarioService.findOne(id); // sin el +
}

El @body tambien convierte los tipos automaticamente

// Si el DTO tiene edad: number
// y el cliente manda: { "edad": "25" }  ← string
// transform: true lo convierte a número automáticamente antes de llegar al servicio

Se coloco un transform explicito dentro del DTO create (CreateUsuarioDto)

@Type(() => Number)

class-validator

Valida que los datos sean los correctos.

ValidationPipe

Se encarga de orquestar ambos.

Vamos a utilizar el validator y transformers.

Lo primero hay que instalar las dependencias.

npm install class-validator class-transformer

voy a modificar el archivo principal main.ts importante los ValidationPipe y agregando unas lineas para su uso.

import { ValidationPipe } from '@nestjs/common'; // Validator

  app.useGlobalPipes(new ValidationPipe({
    whitelist: true, // Elimina los campos que no estan en los DTOs
    forbidNonWhitelisted: true, // Lanza un error si llegan campos extra
    transform: true,  // Transforma tipos automaticamente.
  }));

Sin whitelist considera que el campo extra llega al servicio
Con whitelist: true considera que campo extra se elimina silenciosamente
Con forbidNonWhitelisted: true >> lanza error 400

Quedando de esta manera.

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { ValidationPipe } from '@nestjs/common'; // Validator

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

  app.useGlobalPipes(new ValidationPipe({
    whitelist: true, // Elimina los campos que no estan en los DTOs
    forbidNonWhitelisted: true, // Lanza un error si llegan campos extra
    transform: true,  // Transforma tipos automaticamente.
  }));

  await app.listen(process.env.PORT ?? 3000);
}
bootstrap();

He generado una entidad llamada Usuario para poder hacer las validaciones.

nest g resource Usuario

Entonces vamos a utilizar arrays en memoria dado que no me he conectado a una base de datos prisma.

// Usaremos arrays en memoria, dado que no conecte a prisma
export class Usuario {
    id!: number;
    nombre!: string;
    email!: string;
    edad!: number;
}

DTOs (Simple sin validaciones)

export class CreateUsuarioDto {
    nombre!: string;
    email!: string;
    edad!: number;    
}

Ahora le voy a incluir las validaciones en una primera version.

import { IsEmail, IsNotEmpty, IsString, IsNumber, Min, Max } from 'class-validator';
import { Type } from 'class-transformer';

export class CreateUsuarioDto {

    @IsNotEmpty({message: 'El nombre es obligatorio'})
    @IsString()
    nombre!: string;

    @IsNotEmpty()
    @IsEmail({}, {message: 'Email inválido'})
    email!: string;

    @IsNumber()
    @Min(18, {message: 'Debe de ser mayor de 18'})
    @Max(99)
    @Type( () => Number) //Aqui se utiliza la clase transform explicitamente.
    edad!: number;
}

import { PartialType } from '@nestjs/mapped-types';
import { CreateUsuarioDto } from './create-usuario.dto';

export class UpdateUsuarioDto extends PartialType(CreateUsuarioDto) {}

Se define el servicio.

import { Injectable, NotFoundException } from '@nestjs/common';
import { CreateUsuarioDto } from './dto/create-usuario.dto';
import { UpdateUsuarioDto } from './dto/update-usuario.dto';
import { Usuario } from './entities/usuario.entity'; // Importar entity

@Injectable()
export class UsuarioService {

  // Array en memoria como una base de datos temporal
  private usuarios: Usuario[] = []
  private idCounter = 1;

  create(data: CreateUsuarioDto): Usuario {
    const usuario: Usuario = {
      id: this.idCounter++,
      ...data,
    };
    this.usuarios.push(usuario);
    return usuario;
  }

  findAll(): Usuario[] {
    return this.usuarios;
  }

  findOne(id: number): Usuario {
    const usuario = this.usuarios.find(u => u.id === id);
    if (!usuario) throw new NotFoundException(`Usuario ${id} no encontrado`);
    return usuario;
  }

  update(id: number, data: UpdateUsuarioDto): Usuario {
    const usuario = this.findOne(id);
    Object.assign(usuario, data) // Actualiza solo los campos enviados
    return usuario;
  }

  remove(id: number): {message: string} {
    const index = this.usuarios.findIndex(u => u.id ===id);
    if (index === -1) throw new NotFoundException(`Usuario ${id} no encontrado`);
    this.usuarios.splice(index, 1);
    return {message: `Usuario ${id} eliminado`};
  }
  
}

En el controlador y el modulo, no hay mayor cambio.

Formas de validar la operaciones CRUD de Usuario.

# Crear
Invoke-WebRequest -Uri http://localhost:3000/usuario -Method POST -Headers @{"Content-Type"="application/json"} -Body '{"nombre":"Jeff","email":"jeff@gmail.com","edad":25}' | Select-Object -ExpandProperty Content

# Listar
Invoke-WebRequest -Uri http://localhost:3000/usuario -Method GET | Select-Object -ExpandProperty Content | ConvertFrom-Json

# Actualizar
Invoke-WebRequest -Uri http://localhost:3000/usuario/1 -Method PATCH -Headers @{"Content-Type"="application/json"} -Body '{"nombre":"Jeff Santillan"}' | Select-Object -ExpandProperty Content

# Eliminar
Invoke-WebRequest -Uri http://localhost:3000/usuario/1 -Method DELETE | Select-Object -ExpandProperty Content

Validaciones

Error por ingreso de edad superior a 99

Mensaje de error por que no se ingreso un nombre:

Mensaje de error por un email no valido.

Se logra la validación de manera exitosa.

{
  "id": 1,
  "nombre": "Jeff",
  "email": "jeff@gmail.com",
  "edad": 25
}

¡Saludos!

Vamos a empezar definiendo la funcionalidad para curso.

CURSO:

Entity:

export class Curso {
    id!: number;
    nombre!: string;
    codigo!: string;
    creditos!: number;
    docenteId!: number;
}

DTOs, create y update:

export class CreateCursoDto {
    nombre!: string;
    codigo!: string;
    creditos!: number;
    docenteId!: number;
}

import { PartialType } from '@nestjs/mapped-types';
import { CreateCursoDto } from './create-curso.dto';

export class UpdateCursoDto extends PartialType(CreateCursoDto) {}

Services

import { Injectable, NotFoundException } from '@nestjs/common';
import { CreateCursoDto } from './dto/create-curso.dto';
import { UpdateCursoDto } from './dto/update-curso.dto';
import { PrismaService } from '../prisma/prisma.service';

@Injectable()
export class CursoService {

  constructor(private prisma: PrismaService){}

  async create(data: CreateCursoDto) {    
    // Necesario es verificar que el docente exista antes de crear un curso.
    const docente = await this.prisma.docente.findUnique({
      where: { id: data.docenteId},
    });
    if(!docente) throw new NotFoundException(`Docente ${data.docenteId} no encontrado`);
    return this.prisma.curso.create({data});
  }

  findAll() {
    return this.prisma.curso.findMany({
      include: {
        docente: true, //Muestra al docente.
      }
    });
  }

  async findOne(id: number) {
    const curso = await this.prisma.curso.findUnique({
      where: {id},
      include: { docente: true}
    });
    if(!curso) throw new NotFoundException(`Curso ${id} no encontrado`);
    return curso;
  }

  async update(id: number, data: UpdateCursoDto) {
    await this.findOne(id);
    return this.prisma.curso.update({ where: {id}, data });
  }

  async remove(id: number) {
    await this.findOne(id);
    return this.prisma.curso.delete({ where: {id} });
  }
}

Hay validaciones importantes como la existencia previa de un docente antes de crear el curso.

Controller

import { Controller, Get, Post, Body, Patch, Param, Delete } from '@nestjs/common';
import { CursoService } from './curso.service';
import { CreateCursoDto } from './dto/create-curso.dto';
import { UpdateCursoDto } from './dto/update-curso.dto';

@Controller('curso')
export class CursoController {
  constructor(private readonly cursoService: CursoService) {}

  @Post()
  create(@Body() body: CreateCursoDto) {
    return this.cursoService.create(body);
  }

  @Get()
  findAll() {
    return this.cursoService.findAll();
  }

  @Get(':id')
  findOne(@Param('id') id: string) {
    return this.cursoService.findOne(+id);
  }

  @Patch(':id')
  update(@Param('id') id: string, @Body() body: UpdateCursoDto) {
    return this.cursoService.update(+id, body);
  }

  @Delete(':id')
  remove(@Param('id') id: string) {
    return this.cursoService.remove(+id);
  }
}

Module

import { Module } from '@nestjs/common';
import { CursoService } from './curso.service';
import { CursoController } from './curso.controller';

@Module({
  controllers: [CursoController],
  providers: [CursoService],
})
export class CursoModule {}

MATRICULA:

Para concluir

Entity:

export class Matricula {
    id!: number;
    alumnoId!: number; //FK de alumno
    cursoId!: number; //FK de curso
    fecha!: Date;
    estado!: string;
}

Aqui estamos declarando las foreign keys o las llaves que relacionan con otra tabla.

DTOs, create y update:

export class CreateMatriculaDto {
    alumnoId!: number; //FK de alumno
    cursoId!: number; //FK de curso
}

import { PartialType } from '@nestjs/mapped-types';
import { CreateMatriculaDto } from './create-matricula.dto';

export class UpdateMatriculaDto extends PartialType(CreateMatriculaDto) {
    estado!: string; // ACTIVO | RETIRADO | APROBADO
}

Services

import { BadRequestException, Injectable, NotFoundException } from '@nestjs/common';
import { CreateMatriculaDto } from './dto/create-matricula.dto';
import { UpdateMatriculaDto } from './dto/update-matricula.dto';
import { PrismaService } from '../prisma/prisma.service';

@Injectable()
export class MatriculaService {

  constructor(private prisma: PrismaService){};

  async create(data: CreateMatriculaDto) {
    // Verificar que el alumno existe
    const alumno = await this.prisma.alumno.findUnique({
      where: { id: data.alumnoId }
    });
    if(!alumno) throw new NotFoundException(`Alumno ${data.alumnoId} no encontrado`);

    // Verificar que un curso existe
    const curso = await this.prisma.curso.findUnique({
      where: { id: data.cursoId }
    });
    if(!curso) throw new NotFoundException(`Curso ${data.cursoId} no encontrado`);

    // Verificar que no esta matriculado
    const existe = await this.prisma.matricula.findUnique({
      where: {
        alumnoId_cursoId: {
          alumnoId: data.alumnoId,
          cursoId: data.cursoId
        }
      }
    });
    if (existe) throw new BadRequestException('El alumno ya está matriculado en este curso');

    return this.prisma.matricula.create({
      data, 
      include: {
        alumno: true,
        curso: { include: {docente: true} }
      }
    });

  }

  findAll() {
    return this.prisma.matricula.findMany({
      include: {
        alumno: true,
        curso: { include: { docente: true }} // Curso con su correspondiente docente.
      }
    })
  }

  async findOne(id: number) {
    const matricula = await this.prisma.matricula.findUnique({
      where: {id},
      include: {
        alumno: true,
        curso: { include: { docente: true}}
      }
    });
    if (!matricula) throw new NotFoundException(`Matricula ${id} no encontrada`);
    return matricula;
  }

  async update(id: number, data: UpdateMatriculaDto) {
    await this.findOne(id);
    return this.prisma.matricula.update({ where: {id}, data})
  }

  async remove(id: number) {
    await this.findOne(id) ;
    return this.prisma.matricula.delete({ where : {id} });
  }

  // Curso de un alumno especifico
  findByAlumno(alumnoId: number){
    return this.prisma.matricula.findMany({
      where: { alumnoId },
      include: {
        curso: { include : {docente: true}}
      }
    });
  }

}

Controller

import { Controller, Get, Post, Body, Patch, Param, Delete } from '@nestjs/common';
import { MatriculaService } from './matricula.service';
import { CreateMatriculaDto } from './dto/create-matricula.dto';
import { UpdateMatriculaDto } from './dto/update-matricula.dto';

@Controller('matricula')
export class MatriculaController {
  constructor(private readonly matriculaService: MatriculaService) {}

  @Post()
  create(@Body() body: CreateMatriculaDto) {
    return this.matriculaService.create(body);
  }

  @Get()
  findAll() {
    return this.matriculaService.findAll();
  }

  @Get(':id')
  findOne(@Param('id') id: string) {
    return this.matriculaService.findOne(+id);
  }

  @Patch(':id')
  update(@Param('id') id: string, @Body() body: UpdateMatriculaDto) {
    return this.matriculaService.update(+id, body);
  }

  @Delete(':id')
  remove(@Param('id') id: string) {
    return this.matriculaService.remove(+id);
  }

  // Curso de un alumno especifico
  @Get('alumno/:alumnoId')
  findByAlumno(@Param('alumnoId') alumnoId: string){
    return this.matriculaService.findByAlumno(+alumnoId);
  }

}

Module

import { Module } from '@nestjs/common';
import { MatriculaService } from './matricula.service';
import { MatriculaController } from './matricula.controller';

@Module({
  controllers: [MatriculaController],
  providers: [MatriculaService],
})
export class MatriculaModule {}

Con esto concluimos el registro de matricula de un alumno dentro de un curso.

Operaciones para Curso

Crear un curso con el docente con ID 1

Invoke-WebRequest -Uri http://localhost:3000/curso -Method POST -Headers @{"Content-Type"="application/json"} -Body '{"nombre":"Matematicas","codigo":"MAT101","creditos":4,"docenteId":1}' | Select-Object -ExpandProperty Content

Invoke-WebRequest -Uri http://localhost:3000/curso -Method POST -Headers @{"Content-Type"="application/json"} -Body '{"nombre":"Programacion","codigo":"PRG101","creditos":5,"docenteId":1}' | Select-Object -ExpandProperty Content

Listar cursos

Invoke-WebRequest -Uri http://localhost:3000/curso -Method GET -UseBasicParsing | Select-Object -ExpandProperty Content | ConvertFrom-Json

Obtener curso por ID

Invoke-WebRequest -Uri http://localhost:3000/curso/1 -Method GET | Select-Object -ExpandProperty Content | ConvertFrom-Json

Actualizar curso

Invoke-WebRequest -Uri http://localhost:3000/curso/1 -Method PATCH -Headers @{"Content-Type"="application/json"} -Body '{"nombre":"Matematica Avanzada"}' | Select-Object -ExpandProperty Content

Eliminar

Invoke-WebRequest -Uri http://localhost:3000/curso/1 -Method DELETE | Select-Object -ExpandProperty Content

Todas las operaciones ya estan disponibles para el curso.

Operaciones para Matricula

Matricular alumno a un curso.

Invoke-WebRequest -Uri http://localhost:3000/matricula -Method POST -Headers @{"Content-Type"="application/json"} -Body '{"alumnoId":1,"cursoId":1}' -UseBasicParsing | Select-Object -ExpandProperty Content

Ver todas las matriculas

Invoke-WebRequest -Uri http://localhost:3000/matricula -Method GET -UseBasicParsing | Select-Object -ExpandProperty Content | ConvertFrom-Json

Curso de un alumno en especifico.

Invoke-WebRequest -Uri http://localhost:3000/matricula/alumno/1 -Method GET -UseBasicParsing | Select-Object -ExpandProperty Content | ConvertFrom-Json

¡Saludos!

Definimos las entidades y los DTOs.

Entities (Entidades):

docente.entity.ts

export class Docente {
    id!: number;
    nombre!: string;
    apellido!: string;
    dni!: string;
    email!: string;
}

DTOs (Data Transfer Object)

create-docente.dto.ts

export class CreateDocenteDto {
    nombre!: string;
    apellido!: string;
    dni!: string;
    email!: string;
}

Para actualizar se entiende que extiende de Create

update-docente.dto.ts

import { PartialType } from '@nestjs/mapped-types';
import { CreateDocenteDto } from './create-docente.dto';

export class UpdateDocenteDto extends PartialType(CreateDocenteDto) {}

Ahora si empezamos con el servicio.

docente.service.ts

import { Injectable, NotFoundException } from '@nestjs/common';
import { PrismaService } from '../prisma/prisma.service';
import { CreateDocenteDto } from './dto/create-docente.dto';
import { UpdateDocenteDto } from './dto/update-docente.dto';

@Injectable()
export class DocenteService {

  constructor(private prisma: PrismaService){}

  create(data: CreateDocenteDto) {
    return this.prisma.docente.create({ data })
  }

  findAll() {
    return this.prisma.docente.findMany({
      include: { cursos: true }
    });
  }

  async findOne(id: number) {
    const docente = await this.prisma.docente.findUnique({
      where: { id },
      include: { cursos: true }
    });
    if (!docente) throw new NotFoundException('Docente ${id} no ha sido encontrado');
    return docente;
  }

  async update(id: number, data: UpdateDocenteDto) {
    await this.findOne(id);
    return this.prisma.docente.update({
      where: { id },
      data
    });
  }

  async remove(id: number) {
    await this.findOne(id);
    return this.prisma.docente.delete({ where: { id }});
  }
}

Finalmente, creamos o si utilizamos los generadores, solo tendríamos que adecuar el Controller por que ya viene todo pre hecho.

docente.controller.ts

import { Controller, Get, Post, Body, Patch, Param, Delete } from '@nestjs/common';
import { DocenteService } from './docente.service';
import { CreateDocenteDto } from './dto/create-docente.dto';
import { UpdateDocenteDto } from './dto/update-docente.dto';

@Controller('docente')
export class DocenteController {
  constructor(private readonly docenteService: DocenteService) {}

  @Post()
  create(@Body() body: CreateDocenteDto) {
    return this.docenteService.create(body);
  }

  @Get()
  findAll() {
    return this.docenteService.findAll();
  }

  @Get(':id')
  findOne(@Param('id') id: string) {
    return this.docenteService.findOne(+id);
  }

  @Patch(':id')
  update(@Param('id') id: string, @Body() body: UpdateDocenteDto) {
    return this.docenteService.update(+id, body);
  }

  @Delete(':id')
  remove(@Param('id') id: string) {
    return this.docenteService.remove(+id);
  }
}

Para este caso utilizamos el método PATCH en lugar de PUT, así tendremos que enviar el cambio o el body del cambio puntual y no toda la estructura.

Modulo. Realmente, no hay nada que modificar aquí si fue creado con los generadores.

docente.module.ts

import { Module } from '@nestjs/common';
import { DocenteService } from './docente.service';
import { DocenteController } from './docente.controller';

@Module({
  controllers: [DocenteController],
  providers: [DocenteService],
})
export class DocenteModule {}

Bien, vamos a probar con PowerShell.

Levantamos el servicio con:

npm run start:dev

Los comandos para crear, listar, consultar único registro, actualizar y eliminar.

Utilizaremos el comando : Select-Object -ExpandProperty Content para que solo se muestra la respuesta en formato json.

| Select-Object -ExpandProperty Content

Se puede complementar con:

| ConvertFrom-Json

Considera también incluir el parámetro -UseBasicParsing

-UseBasicParsing

Crear

Invoke-WebRequest -Uri http://localhost:3000/docente -Method POST -Headers @{"Content-Type"="application/json"} -Body '{"nombre":"Carlos","apellido":"Perez","dni":"12345678","email":"carlos@edu.pe"}' | Select-Object -ExpandProperty Content

Listar

Invoke-WebRequest -Uri http://localhost:3000/docente -Method GET | Select-Object -ExpandProperty Content

Obtener un registro por ID

Invoke-WebRequest -Uri http://localhost:3000/docente/1 -Method GET | Select-Object -ExpandProperty Content

Actualizar

Invoke-WebRequest -Uri http://localhost:3000/docente/1 -Method PUT -Headers @{"Content-Type"="application/json"} -Body '{"nombre":"Carlos Alberto"}' | Select-Object -ExpandProperty Content

Eliminar

Invoke-WebRequest -Uri http://localhost:3000/docente/1 -Method DELETE | Select-Object -ExpandProperty Content

Ya tenemos las funciones hacia la tabla operando.

¡Saludos!

Considera que la tablas:

• Alumno = No depende de nadie
• Docente = No depende de nadie
• Curso = Depende de Docente
• Matricula = Depende de Alumno y Curso.

Así que lo mejor es empezar con alumno

Empezamos por Entities y los DTOs,

Entities:

export class Alumno {
    id!: number;
    nombre!: string;
    apellido!: string;
    dni!: string;
    email!: string;
    createdAt!: Date;
}

DTOs

export class CreateAlumnoDto {
    nombre!: string;
    apellido!: string;
    dni!: string;
    email!: string;    
}

Actualizar extiende parcial (PartialType) así que no es necesario definir, ya que incluye los datos de CreateAlumnoDto.

import { PartialType } from '@nestjs/mapped-types';
import { CreateAlumnoDto } from './create-alumno.dto';

export class UpdateAlumnoDto extends PartialType(CreateAlumnoDto) {  
}

Ahora si hay que elaborar el servicio.

import { Injectable, NotFoundException } from '@nestjs/common';
import { CreateAlumnoDto } from './dto/create-alumno.dto';
import { UpdateAlumnoDto } from './dto/update-alumno.dto';

import { PrismaService } from '../prisma/prisma.service';

@Injectable()
export class AlumnoService {

  constructor(private prisma: PrismaService){}

  create(data: CreateAlumnoDto) {
    return this.prisma.alumno.create({ data })
  }

  findAll() {
    return this.prisma.alumno.findMany();
  }

  async findOne(id: number) {
    const alumno = await this.prisma.alumno.findUnique({ where: {id} });
    if (!alumno) throw new NotFoundException('Alumno ${id} no fue encontrado');
    return alumno;
  }

  async update(id: number, data: UpdateAlumnoDto) {
    await this.findOne(id);
    return this.prisma.alumno.update({where: {id}, data});
  }

  async remove(id: number) {
    await this.findOne(id);
    return this.prisma.alumno.delete({where: {id} });
  }
}

finalmente, el controlador practicamente, ya viene implementado.

import { Controller, Get, Post, Body, Patch, Param, Delete } from '@nestjs/common';
import { AlumnoService } from './alumno.service';
import { CreateAlumnoDto } from './dto/create-alumno.dto';
import { UpdateAlumnoDto } from './dto/update-alumno.dto';

@Controller('alumno')
export class AlumnoController {
  constructor(private readonly alumnoService: AlumnoService) {}

  @Post()
  create(@Body() createAlumnoDto: CreateAlumnoDto) {
    return this.alumnoService.create(createAlumnoDto);
  }

  @Get()
  findAll() {
    return this.alumnoService.findAll();
  }

  @Get(':id')
  findOne(@Param('id') id: string) {
    return this.alumnoService.findOne(+id);
  }

  @Patch(':id')
  update(@Param('id') id: string, @Body() updateAlumnoDto: UpdateAlumnoDto) {
    return this.alumnoService.update(+id, updateAlumnoDto);
  }

  @Delete(':id')
  remove(@Param('id') id: string) {
    return this.alumnoService.remove(+id);
  }
}

Ejecutemos el proyecto.

npm run start:dev

Registro un alumno con el Invoke-WebRequest

Invoke-WebRequest -Uri http://localhost:3000/alumno -Method POST -Headers @{"Content-Type"="application/json"} -Body '{"nombre":"Jeff","apellido":"Santillan","dni":"12345678","email":"jeff@gmail.com"}'

Recuperamos los alumnos registrados.

Invoke-WebRequest -Uri http://localhost:3000/alumno -Method GET

Ya estamos haciendo uso de nuestra base de datos sqlite con prisma.

¡Saludos!

nest new matricula-app

Luego vamos a utilizar Prisma para gestionar los datos.

En caso de no tener prisma es necesario instalarlo con npm

npm install prisma @prisma/client

Tenemos que estar dentro de la carpeta del proyecto para poder ejecutar el comando de prisma npx.

Vamos a definir el proveedor de base de datos que utilizare, para este ejercicio será sqlite.

npx prisma init --datasource-provider sqlite

Tenemos que editar el archivo de prisma/schema.prisma del proyecto con la estructura de datos a trabajar.

Se presenta la definición de tablas solo con campos sencillos, sin relaciones aún

model Alumno {
  id Int @id @default(autoincrement())
  nombre String
  apellido String
  dni String @unique
  email String @unique
  createdAt Datetime @default(now())  
}

model Docente {
  id Int @id @default(autoincrement())
  nombre String
  apellido String
  dni String @unique
  email String @unique    
}

model Curso {
  id Int @id @default(autoincrement())
  nombre String
  codigo String @unique
  creditos Int    
}

model Matricula {
  id Int @id @default(autoincrement())
  fecha Datetime @default(now())
  estado String @default("ACTIVO")
}

Ahora vamos a establecer las FK y relaciones 1:n y n:1 con comentarios.

model Alumno {
  id         Int         @id @default(autoincrement())
  nombre     String
  apellido   String
  dni        String      @unique
  email      String      @unique
  createdAt  DateTime    @default(now())
  matriculas Matricula[] // Relación 1:N — un alumno puede tener múltiples matrículas
}

model Docente {
  id       Int     @id @default(autoincrement())
  nombre   String
  apellido String
  dni      String  @unique
  email    String  @unique
  cursos   Curso[] // Relación 1:N — un docente puede dictar múltiples cursos
}

model Curso {
  id         Int         @id @default(autoincrement())
  nombre     String
  codigo     String      @unique // Código único del curso, ej: MAT101
  creditos   Int
  docenteId  Int         // FK → Docente (responsable del curso)
  docente    Docente     @relation(fields: [docenteId], references: [id]) // Relación N:1 — muchos cursos pueden tener un docente
  matriculas Matricula[] // Relación 1:N — un curso puede tener múltiples alumnos matriculados
}

model Matricula {
  id       Int      @id @default(autoincrement())
  alumnoId Int      // FK → Alumno
  cursoId  Int      // FK → Curso
  fecha    DateTime @default(now())
  estado   String   @default("ACTIVO") // Estados posibles: ACTIVO | RETIRADO | APROBADO
  alumno   Alumno   @relation(fields: [alumnoId], references: [id]) // Relación N:1 — muchas matrículas pertenecen a un alumno
  curso    Curso    @relation(fields: [cursoId], references: [id])   // Relación N:1 — muchas matrículas pertenecen a un curso

  @@unique([alumnoId, cursoId]) // Restricción: un alumno no puede matricularse dos veces al mismo curso
}

Luego hay que ejecutar la migracion

npx prisma migrate dev --name init

Migración realizada se creo el archivo de base de datos sqlite -> dev.db

El nombre del archivo se definió en la DATABASE_URL del archivo .env, también vemos que ya se creo.

Nota: Prisma 7 ya trae instalado el dotenv, asi que no es necesario instalarlo directamente.

• Se creó el archivo dev.db
• Se creó la migración como historial de cambios prisma/migrations/20260607033831_init/migration.sql
• Las 4 tablas han sido creadas.

Lo siguiente es generar el cliente de prisma con:

npx prisma generate

Ahora si necesitamos empezar a crear los recursos (resources) -> module, service, controller, DTOs y entities

Se va a utilizar el comando resource para crear todo.

g = generate

nest g resource alumno
nest g resource docente
nest g resource curso
nest g resource matricula

Hara unas preguntas, responder con

• What transport layer do you use? >> REST API
• Would you like to generate CRUD entry points? >> Yes

Se genera todo.

Replicar para cada entidad / tabla.

Instalar adapter para integrar prisma con nestjs y lograr consultas a sqlite

npm install @prisma/adapter-better-sqlite3
npm install better-sqlite3
npm install --save-dev @types/better-sqlite3

Luego tenemos que crear un archivo de module y service para prisma.

nest generate module prisma
nest generate service prisma

cada uno de estos archivos hay que editarlos.

prisma/prisma.service.ts

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

import { PrismaClient } from '../../generated/prisma/client';
import { PrismaBetterSqlite3 } from '@prisma/adapter-better-sqlite3';

@Injectable()
export class PrismaService extends PrismaClient implements OnModuleInit {
    
    constructor(){
        const adapter = new PrismaBetterSqlite3({ url: 'file:./dev.db' });
        super({adapter})
    }
    
    async onModuleInit() {
        await this.$connect();
    }

}

luego el archivo del module.

prisma/module.ts

import { Global, Module } from '@nestjs/common';
import { PrismaService } from './prisma.service';

@Global()
@Module({
  providers: [PrismaService],
  exports: [PrismaService]
})
export class PrismaModule {}

y también asegurarnos que el module este importando a nivel de la app.module.ts

Si utilizaron los generadores el module se importara solo.

Luego hay que corregir un error de conflicto en las configuraciones de prisma por formato.

prisma/schema.prisma (Donde se definieron las tablas) hay que aclarar el formato del modulo (moduleFormat) como «cjs»

generator client {
  provider = "prisma-client"
  output   = "../generated/prisma"
  moduleFormat = "cjs"
}

datasource db {
  provider = "sqlite"  
}

luego ejecutar un npx prisma generate

npx prisma generate

Finalmente, ejecutar el proyecto para validar que todo esta funcionando.

npm run start:dev

Parte II – Visitar

Prisma.io – Enlace

¡Saludos!

Para ello utilizamos el cliente de nest para generar los modulos, servicios y controladores.

dentro de la carpeta todo se va a crear cada archivo TS (Typescript).

Procedemos a diseñar el modelo junto con el servicio.

Interfaz

export interface Todo {
    id: number;
    title: string;
    completed: boolean;
}

Servicio

import { Injectable, NotFoundException } from '@nestjs/common';
import { Todo } from './todo.model';

@Injectable()
export class TodoService {

    private todos: Todo[] = [];
    private idCounter = 1;

    findAll(): Todo[] {
        return this.todos;
    }

    findOne(id: number): Todo {
        const todo = this.todos.find(t => t.id === id);
        if(!todo) throw new NotFoundException('Todo ${id} no fue encontrado'); // Importar en @nestjs/common
        return todo;
    }

    create(title: string): Todo {
        const todo: Todo = {id: this.idCounter++, title, completed: false };
        this.todos.push(todo);
        return todo;
    }

    update(id: number, title?: string, completed?: boolean): Todo {
        const todo = this.findOne(id);
        if(title !== undefined) todo.title = title;
        if(completed !== undefined) todo.completed = completed;        
        return todo;
    }

    remove(id: number): void{
        const index = this.todos.findIndex(t => t.id === id);
        if (index === -1) throw new NotFoundException('Todo no encontrado');
        this.todos.splice(index, 1);
    }

}

Ahora toca crear el controlador.

Controlador:

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

@Controller('todos')
export class TodoController {

    // Constructor
    constructor(private readonly todoService: TodoService) {}

    @Get()
    findAll(){
        return this.todoService.findAll();
    }

    @Get(':id')
    findOne(@Param('id') id: string){
        return this.todoService.findOne(+id);
    }

    @Post()
    create(@Body() body: { title: string }){
        return this.todoService.create(body.title);
    }

    @Put(':id')
    update(@Param('id') id: string, @Body() body: {title?: string, completed?: boolean }) {
        return this.todoService.update(+id, body.title, body.completed);
    }

    @Delete(':id')
    remove(@Param('id') id: string){
        return this.todoService.remove(+id);
    }

}

Luego de culminado el modelo, servicio y controlador. Llego el momento de probar la aplicación.

Levantamos el servicio con el comando:

npm run start:dev

En el navegador veremos que la web ya levanta con el puerto 3000 en localhost

Vamos a utilizar Invoke-Request de preferencia para poder crear un registro.

Invoke-WebRequest -Uri http://localhost:3000/todos -Method POST -Headers @{"Content-Type"="application/json"} -Body '{"title":"Aprender NestJS"}'

Luego vamos a leer con el curl a pesar que a veces Powershell no lo reconozca o interprete bien.

curl https://localhost:3000/todos

También es valido probarlo directo del navegador.

Eso seria todo.

Nota: La información se esta guardando en memoria de arrays, aun no hemos conectado a una base de datos, de momento solo es el uso de la estructura de NestJS.

¡Saludos!

Para lograr la instalación del Cliente, es necesario utilizar el gestor de paquetes de Node.js (npm).

Nota: Para windows de preferencia ejecutar un power shel con modo Administrador.

npm install -g @nestjs/cli

Para crear un proyecto tenemos que lanzar el comando.

nest new todo-app

Se tiene que elegir el Package Manager en mi caso utilizo npm

Es todo.

Si quieres conocer la versión del cliente utiliza el comando

nest --version

Pagina Oficial – Enlace

¡Saludos!