Servicios en NestJS

 

Conceptos Avanzados en NestJS

Voy a explicarte estos importantes conceptos de NestJS:

1. Servicios en NestJS

Los servicios son clases marcadas con el decorador @Injectable() que contienen la lógica de negocio de tu aplicación.

Características principales:

  • Son singletons por defecto (una sola instancia compartida)

  • Se encargan de la lógica de negocio (separada de los controladores)

  • Pueden ser inyectados en otros componentes (controladores, otros servicios)

  • Promueven el principio de responsabilidad única

Ejemplo básico:

typescript
Copy
Download
import { Injectable } from '@nestjs/common';

@Injectable()
export class CatsService {
  private readonly cats: Cat[] = [];

  create(cat: Cat) {
    this.cats.push(cat);
  }

  findAll(): Cat[] {
    return this.cats;
  }
}

2. Archivo con todos los métodos (CRUD Service)

Es común crear servicios que implementen todas las operaciones CRUD para una entidad:

typescript
Copy
Download
import { Injectable } from '@nestjs/common';
import { Cat } from './cat.entity';

@Injectable()
export class CatsService {
  private cats: Cat[] = [];

  // Create
  create(cat: Cat): Cat {
    this.cats.push(cat);
    return cat;
  }

  // Read
  findAll(): Cat[] {
    return this.cats;
  }

  findOne(id: number): Cat {
    return this.cats.find(cat => cat.id === id);
  }

  // Update
  update(id: number, updatedCat: Cat): Cat {
    const index = this.cats.findIndex(cat => cat.id === id);
    this.cats[index] = updatedCat;
    return updatedCat;
  }

  // Delete
  remove(id: number): void {
    this.cats = this.cats.filter(cat => cat.id !== id);
  }
}

3. Entidades

Las entidades representan tablas en tu base de datos (en el contexto de TypeORM). Son clases decoradas que definen la estructura de tus datos.

Ejemplo con TypeORM:

typescript
Copy
Download
import { Entity, PrimaryGeneratedColumn, Column } from 'typeorm';

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

  @Column()
  name: string;

  @Column()
  age: number;

  @Column()
  breed: string;
}

4. Servicios y Repository Pattern

El Repository Pattern es un patrón de diseño que:

  • Abstrae el acceso a datos

  • Centraliza las operaciones de base de datos

  • Facilita el testing y mantenimiento

Implementación con NestJS y TypeORM:

typescript
Copy
Download
import { Injectable } from '@nestjs/common';
import { InjectRepository } from '@nestjs/typeorm';
import { Repository } from 'typeorm';
import { Cat } from './cat.entity';

@Injectable()
export class CatsService {
  constructor(
    @InjectRepository(Cat)
    private catsRepository: Repository<Cat>,
  ) {}

  async findAll(): Promise<Cat[]> {
    return this.catsRepository.find();
  }

  async findOne(id: number): Promise<Cat> {
    return this.catsRepository.findOne({ where: { id } });
  }

  async create(cat: Cat): Promise<Cat> {
    return this.catsRepository.save(cat);
  }

  async update(id: number, cat: Cat): Promise<void> {
    await this.catsRepository.update(id, cat);
  }

  async remove(id: number): Promise<void> {
    await this.catsRepository.delete(id);
  }
}

5. TypeORM

TypeORM es un ORM (Object-Relational Mapping) que:

  • Permite trabajar con bases de datos usando objetos

  • Soporta múltiples bases de datos (PostgreSQL, MySQL, SQLite, etc.)

  • Integra perfectamente con NestJS

Configuración básica en NestJS (app.module.ts):

typescript
Copy
Download
import { TypeOrmModule } from '@nestjs/typeorm';

@Module({
  imports: [
    TypeOrmModule.forRoot({
      type: 'postgres',
      host: 'localhost',
      port: 5432,
      username: 'postgres',
      password: 'password',
      database: 'catsdb',
      entities: [Cat],
      synchronize: true, // ¡Solo para desarrollo!
    }),
    TypeOrmModule.forFeature([Cat]), // Para el repositorio
  ],
  // ...
})
export class AppModule {}

Relaciones en TypeORM:

typescript
Copy
Download
// Entidad Owner
@Entity()
export class Owner {
  @PrimaryGeneratedColumn()
  id: number;

  @Column()
  name: string;

  @OneToMany(() => Cat, cat => cat.owner)
  cats: Cat[];
}

// Entidad Cat con relación
@Entity()
export class Cat {
  // ... otros campos

  @ManyToOne(() => Owner, owner => owner.cats)
  owner: Owner;
}

Esta arquitectura (Servicios + Repositorios + Entidades) es fundamental para construir aplicaciones NestJS escalables y mantenibles, separando claramente las responsabilidades entre las diferentes capas de la aplicación.

Comentarios

Publicar un comentario

Entradas más populares de este blog

48. ValidationPipe - Class Validator y Class Transformer

  Validación de Datos en NestJS con ValidationPipe, Class-Validator y Class-Transformer Cuando desarrollamos APIs, una de las tareas más comunes -y a veces tediosas- es validar que los datos que recibimos en las peticiones cumplan con ciertos estándares. ¿No sería genial tener una forma sencilla y automatizada de hacer esto? En NestJS, podemos lograrlo con el  ValidationPipe  junto con las librerías  class-validator  y  class-transformer . Antes: Validación Manual Originalmente, nuestro controlador de autos ( cars.controller.ts ) aceptaba cualquier dato sin validación: typescript Copy Download import { Controller , Get , Param , Post , Body , Patch , Delete , ParseIntPipe } from '@nestjs/common' ; import { CarsService } from './cars.service' ; import { CreateCarDto } from './dto/create-car.dto' ; @ Controller ( 'cars' ) export class CarsController { constructor ( private readonly carsService : CarsService ) { } @ Get...
Leer más

32-Modulos

  directorios que se están usando en el ejemplo : Copy Download src/ │ ├── cars/ │ ├── cars.controller.ts # Controlador (maneja las rutas HTTP) │ ├── cars.module.ts # Módulo (registra controlador y servicio) │ └── cars.service.ts # Servicio (lógica de negocio) │ ├── app.module.ts # Módulo principal de la aplicación └── main.ts # Punto de entrada (configuración de NestJS) Explicación breve : cars/ : Contiene los archivos específicos del recurso  Cars  (controlador, módulo y servicio). app.module.ts : Importa y organiza los módulos de la aplicación (en este caso,  CarsModule ). main.ts : Inicia la aplicación y configura el servidor. Esta estructura sigue las  buenas prácticas de NestJS , separando responsabilidades en capas claras. Módulos en NestJS: La Base de tu Aplicación Introducción Cuando comenzamos a explorar NestJS, es normal encontrarnos con una estructura inicial llena de archivos que no siempre entendemos....
Leer más

49. Pipes Globales - A nivel de Aplicación

  Pipes Globales en NestJS: Validación a Nivel de Aplicación En NestJS, los Pipes son una herramienta poderosa para transformar y validar datos. En este post, exploraremos cómo implementar Pipes a nivel global en nuestra aplicación, lo que nos permite centralizar la validación y mantener un código más limpio y consistente. Estructura del Proyecto Antes de comenzar, veamos la estructura de nuestro proyecto: Copy Download src/ │ ├── cars/ │ ├── dto/ │ │ ├── create-car.dto.ts │ │ └── update-car.dto.ts │ ├── interfaces/ │ │ └── car.interface.ts │ ├── cars.controller.ts │ ├── cars.module.ts │ ├── cars.service.ts │ └── constants/ │ └── car.constants.ts │ ├── common/ │ ├── pipes/ │ │ └── validation.pipe.ts │ └── filters/ │ └── http-exception.filter.ts │ ├── app.module.ts ├── app.controller.ts ├── app.service.ts └── main.ts Antes: Validación por Controlador Inicialmente, teníamos que aplicar el  ValidationPipe  en cada método del contro...
Leer más