Tipos de Providers en NestJS: Use Class y Use Value

Curso de NestJS: Programación Modular, Documentación con Swagger y Deploy

Contenido del curso

Módulos de NestJS

Configuración de entornos

Documentación

Deploy

Próximos pasos

17
Inyección de Dependencias en APIs con Heroku
01:04 min

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:007:56

Tipos de Providers en NestJS: Use Class y Use Value

Curso de NestJS: Programación Modular, Documentación con Swagger y Deploy

Clase 6 de 17

Clase 6 / 17

Recursos

NestJS posee diferentes formas de inyectar servicios en un módulo según la necesidad. Exploremos algunas de ellas, sus diferencias y cuándo utilizarlas.

Cómo hacer la inyección con "useClass"

Cuando realizas un import de un servicio en un módulo:

import { AppService } from './app.service';

@Module({
  providers: [AppService],
})
export class AppModule {}

Internamente, NestJS realiza lo siguiente:

import { AppService } from './app.service';

@Module({
  providers: [
    {
      provide: AppService,
      useClass: AppService
    }
  ]
})
export class AppModule {}

Ambas sintaxis son equivalentes, useClass es el tipo de inyección por defecto. Básicamente, indica que un servicio debe utilizar X clase para funcionar. Si el día de mañana, por algún motivo en tu aplicación, el servicio AppService queda obsoleto y tienes que reemplazarlo por uno nuevo, puedes realizar lo siguiente:

import { AppService2 } from './app.service';

@Module({
  providers: [
    {
      provide: AppService,
      useClass: AppService2
    }
  ]
})
export class AppModule {}

De este modo, no tienes necesidad de cambiar el nombre AppService en todos los controladores donde se utiliza, este será reemplazado por la nueva versión del servicio.

Cómo hacer la inyección con "useValue"

Además de clases, puedes inyectar valores como un string o un número. useValue suele utilizarse para inyectar globalmente en tu aplicación la llave secreta de una API o alguna otra variable de entorno que tu app necesita.

Para esto, simplemente inyecta el valor de una constante en el providers.

const API_KEY = '1324567890';

@Module({
  providers: [
    {
      provide: 'API_KEY',
      useValue: API_KEY
    }
  ],
})
export class AppModule {}

Importa este valor en los controladores u otros servicios donde se necesite de la siguiente manera:

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

@Controller()
export class AppController {

  constructor(@Inject('API_KEY') private apiKey: string) {}
}

Ahora tienes a disposición el valor de este dato en tu controlador para utilizarlo en lo que necesites.

Cuadro de códigos para inyección de servicios

// src/app.module.ts
...

const API_KEY = '12345634';
const API_KEY_PROD = 'PROD1212121SA';

@Module({
  imports: [UsersModule, ProductsModule],
  controllers: [AppController],
  providers: [
    AppService,
    {
      provide: 'API_KEY',
      useValue: process.env.NODE_ENV === 'prod' ? API_KEY_PROD : API_KEY,
    },
  ],
})
export class AppModule {}

// src/app.service.ts
import { Injectable, Inject } from '@nestjs/common';

@Injectable()
export class AppService {
  constructor(@Inject('API_KEY') private apiKey: string) {} // 👈 Inject API_KEY
  getHello(): string {
    return `Hello World! ${this.apiKey}`;
  }
}

// src/app.controller.ts

@Controller()
export class AppController {

  @Get()
  getHello(): string { // 👈 new enpoint
    return this.appService.getHello();
  }

}

Contribución creada por: Kevin Fiorentino.

Ángel David Roque Ayala

Hace 5 años

Resumen

Introducción

Cuando queremos que la instancia de una clase se comparta por todo un modulo debemos hacer 2 cosas.

Le colocamos el decorador @Inyectable a la clase

@Injectable() // <-- El decorador
export class ProductsService {
	// ...
}

Y lo declaramos dentro del modulo correspondiente usando la sintaxis resumida

@Module({
  ...
  providers: [..., ProductsService], // Aqui por ejemplo
  ...
})

useClass

Internamente, nest js rescribe esta sintaxis de la siguiente forma:

@Module({
  ...
  providers: [..., 
		{
			provide: ProducsService, // Nombre con el que haremos referencia a ella
			useClass: ProducsService // Nombre de la clase que se usara
		}
	], // Aqui por ejemplo
  ...
})

useValues

Además de poder inyectar clases también podemos inyectar valores. Esto es util para compartir valores que globales de la aplicación y evita que estos se guarden en memoria cada vez que se requieran.

const API_KEY = '12345634';
const API_KEY_PROD = 'PROD1212121SA';

@Module({
  imports: [...],
  controllers: [..],
  providers: [
    AppService,
    {
      provide: 'API_KEY', // Nombre con el que se hara referencia
      useValue: process.env.NODE_ENV === 'prod' ? API_KEY_PROD : API_KEY, // El valor
    },
  ],
})
export class AppModule {}

Para usar el valor solo debemos inyectarlo.

// src/app.service.ts
import { Injectable, Inject } from '@nestjs/common';

@Injectable()
export class AppService {
  constructor(@Inject('API_KEY') private apiKey: string) {} // 👈 Inject API_KEY
  getHello(): string {
    return `Hello World! ${this.apiKey}`;
  }
}

Walter Lensinas

Hace 5 años

Buen apunte!! Agrego que al momento de ejecutar la app hay que ponele la variable de entorno.

NODE_ENV=prod npm run start:dev

Ángel David Roque Ayala

Hace 5 años

@wlensinas Excelente complemento

Comentarios (20)20 comentarios

Diego Artiles

Fernando Dorantes

Rodrigo Hernández Leyva

Hace 4 años

Alejandro Sebastian Dubon Estrada

Nicolas Molina

Profesor

Cristian Iñiguez

Joseph Quevedo

Anderson Peñaloza

Ian Vassallo

Hace 3 años

Jonnathan Ramiro Juma Jara

Eduardo Rodriguez Cisneros

Oscar Eduardo Muñoz Bernales

David Martin Almeyda Sucso

Fabricio Vargas

Ismael Bedmar Cejas

Hace 3 meses

Hans Arias

Hace 2 años

Josué Eliezer Gómez Soto

Sergio Willed

Diego Jesus Zaragoza

Danny De Jesus Lopez Soles

Iván Ozono

Juan David Merchán Torres

Módulos de NestJS

Programación Modular y Deployment en Nest GS

Encapsulación de Lógica en Módulos con NestJS

Programación Modular en NestJS: Controladores y Entidades

Interacción entre Módulos en NestJS: Servicios y Controladores

Inyección de Dependencias en Arquitectura de Software

Tipos de Providers en NestJS: Use Class y Use Value

useFactory

Uso de Módulos Globales en NestJS para Inyecciones Compartidas

Configuración de entornos

Configuración y uso de variables de entorno en NestJS

Configuración de Ambientes con Archivos .env en Node.js

Tipado seguro en TypeScript para configuración de aplicaciones

Validación de Variables de Entorno con Joi en Node.js

Documentación

Documentación automática de APIs con NestJS y Swagger

Documentación de API con NestJS y Swagger

Deploy

Deployment de Aplicaciones Node.js en Heroku

Deployment de Aplicaciones en Heroku: Configuración y Solución de Errores

Próximos pasos

Inyección de Dependencias en APIs con Heroku

Tipos de Providers en NestJS: Use Class y Use Value

Progreso del curso

Módulos de NestJS

Configuración de entornos

Documentación

Deploy

Próximos pasos

Recursos

Recursos