Nest: Servicios e inyección de dependencias

NestJS es un framework progresivo para construir aplicaciones eficientes y escalables del lado del servidor. Uno de sus pilares fundamentales es el uso de servicios e inyección de dependencias, lo que facilita la modularidad y mantenibilidad del código.

Servicios en NestJS

En NestJS, los servicios son clases que contienen la lógica de negocio. Se anotan con el decorador @Injectable(), lo que permite que puedan ser inyectados en otros componentes como controladores o módulos.

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

@Injectable()
export class MiServicio {
  obtenerDatos(): string {
    return 'Datos del servicio';
  }
}

En este ejemplo, MiServicio es un servicio que proporciona un método obtenerDatos.

Inyección de dependencias

La inyección de dependencias es una técnica de diseño que permite que una clase solicite sus dependencias desde un contenedor en lugar de crearlas por sí misma. En NestJS, esto se gestiona a través del contenedor de inyección de dependencias de Nest.

Inyección de un servicio en un controlador

Para inyectar MiServicio en un controlador, se utiliza el constructor de la clase y se anota con el decorador @Injectable().

import { Controller, Get } from '@nestjs/common';
import { MiServicio } from './mi-servicio.service';

@Controller('mi-controlador')
export class MiControlador {
  constructor(private readonly miServicio: MiServicio) {}

  @Get()
  obtenerDatos(): string {
    return this.miServicio.obtenerDatos();
  }
}

Aquí, MiControlador inyecta MiServicio a través de su constructor y utiliza el método obtenerDatos para manejar una solicitud GET.

Alcance de los servicios

NestJS permite definir el alcance de los servicios, lo que determina cómo se instancian. Existen tres tipos de alcance: singleton, request y transient.

• Singleton (por defecto): El servicio se instancia una vez y se comparte en toda la aplicación.
• Request: Se crea una nueva instancia para cada solicitud entrante.
• Transient: Cada instancia inyectada es única para cada inyección.

Para definir el alcance, se utiliza el decorador @Injectable() con la propiedad scope.

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

@Injectable({ scope: Scope.REQUEST })
export class MiServicioRequest {
  // Lógica del servicio
}

Módulos y proveedores

Los módulos en NestJS organizan los componentes de la aplicación. Un módulo puede exportar servicios para que otros módulos los utilicen. Los servicios deben estar listados en el array providers del módulo.

import { Module } from '@nestjs/common';
import { MiServicio } from './mi-servicio.service';
import { MiControlador } from './mi-controlador.controller';

@Module({
  controllers: [MiControlador],
  providers: [MiServicio],
  exports: [MiServicio],
})
export class MiModulo {}

En este ejemplo, MiModulo declara y exporta MiServicio, permitiendo que otros módulos lo importen y utilicen.

Inyección de dependencias avanzada

NestJS soporta la inyección de dependencias avanzada, como la inyección opcional y la inyección basada en tokens.

Inyección opcional

Se puede marcar una dependencia como opcional utilizando el decorador @Optional().

import { Inject, Optional } from '@nestjs/common';

constructor(@Optional() @Inject('OPCIONAL_SERVICIO') private readonly opcionalServicio?: MiServicio) {}

Inyección basada en tokens

Para inyectar dependencias usando tokens, se utilizan objetos de tipo InjectionToken.

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

export const MI_TOKEN = new InjectionToken<string>('MI_TOKEN');

@Module({
  providers: [{ provide: MI_TOKEN, useValue: 'valor' }],
})
export class MiModulo {}