Providers

Qué es un Provider en Nest

Un Provider en NestJS es un concepto fundamental que representa cualquier clase que puede ser inyectada como dependencia en otras partes de la aplicación. Los providers encapsulan la lógica de negocio y proporcionan servicios específicos que pueden ser reutilizados a lo largo de toda la aplicación.

En términos simples, un provider es una clase decorada con @Injectable() que puede ser inyectada en constructores de otras clases. Esta característica permite crear aplicaciones modulares y mantenibles, donde cada componente tiene responsabilidades bien definidas.

Características principales de los Providers

Los providers en NestJS tienen varias características que los hacen especiales:

• Inyección automática: NestJS se encarga de crear e inyectar automáticamente las instancias de los providers donde sean necesarios
• Singleton por defecto: Cada provider se crea una sola vez y se reutiliza en toda la aplicación
• Gestión del ciclo de vida: El framework maneja la creación y destrucción de los providers
• Tipado fuerte: Aprovechan el sistema de tipos de TypeScript para mayor seguridad

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

@Injectable()
export class CalculadoraService {
  sumar(a: number, b: number): number {
    return a + b;
  }

  multiplicar(a: number, b: number): number {
    return a * b;
  }
}

Tipos de Providers

NestJS reconoce diferentes tipos de providers según su propósito y funcionalidad:

• 1. Servicios: Contienen lógica de negocio y operaciones específicas del dominio

@Injectable()
export class UsuarioService {
  private usuarios = [];

  obtenerTodos() {
    return this.usuarios;
  }

  crear(usuario: any) {
    this.usuarios.push(usuario);
    return usuario;
  }
}

• 2. Repositorios: Manejan el acceso y manipulación de datos

@Injectable()
export class ProductoRepository {
  private productos = new Map();

  guardar(id: string, producto: any) {
    this.productos.set(id, producto);
  }

  buscarPorId(id: string) {
    return this.productos.get(id);
  }
}

• 3. Factories: Crean instancias de otros objetos o configuraciones

@Injectable()
export class ConfiguracionFactory {
  crearConfiguracion(entorno: string) {
    return {
      baseDatos: entorno === 'produccion' ? 'prod-db' : 'dev-db',
      puerto: entorno === 'produccion' ? 3000 : 3001
    };
  }
}

El decorador @Injectable()

El decorador @Injectable() es obligatorio para que una clase pueda funcionar como provider. Este decorador le dice a NestJS que la clase puede ser gestionada por el sistema de inyección de dependencias.

// ❌ Sin @Injectable() - No funcionará como provider
export class EmailService {
  enviarEmail(destinatario: string, mensaje: string) {
    console.log(`Enviando email a ${destinatario}: ${mensaje}`);
  }
}

// ✅ Con @Injectable() - Funciona correctamente como provider
@Injectable()
export class EmailService {
  enviarEmail(destinatario: string, mensaje: string) {
    console.log(`Enviando email a ${destinatario}: ${mensaje}`);
  }
}

Registro de Providers

Para que un provider esté disponible en la aplicación, debe ser registrado en un módulo. Esto se hace en el array providers del decorador @Module():

import { Module } from '@nestjs/common';
import { UsuarioService } from './usuario.service';
import { EmailService } from './email.service';

@Module({
  providers: [
    UsuarioService,
    EmailService
  ],
  // Otros elementos del módulo...
})
export class UsuarioModule {}

Ámbito de los Providers

Los providers en NestJS tienen diferentes ámbitos que determinan cómo se crean y comparten las instancias:

• Singleton (por defecto): Una sola instancia compartida en toda la aplicación
• Request: Una nueva instancia para cada petición HTTP
• Transient: Una nueva instancia cada vez que se inyecta

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

// Provider singleton (comportamiento por defecto)
@Injectable()
export class ContadorService {
  private contador = 0;
  
  incrementar() {
    return ++this.contador;
  }
}

// Provider con ámbito de petición
@Injectable({ scope: Scope.REQUEST })
export class SesionService {
  private datosTemporales = {};
  
  guardarDato(clave: string, valor: any) {
    this.datosTemporales[clave] = valor;
  }
}

La comprensión de los providers es esencial para aprovechar al máximo el sistema de inyección de dependencias de NestJS, ya que forman la base sobre la cual se construye toda la arquitectura modular del framework.