useFactory

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:009:10

useFactory

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

Clase 7 de 17

Clase 7 / 17

Recursos

NestJS permite inyecciones de servicios o datos que necesiten de alguna petición HTTP o algún proceso asíncrono.

Inyecciones Asíncronas

El tipo de inyección useFactory permite que realices un proceso asíncrono para inyectar un servicio o datos provenientes de una API.

A partir de NestJS v8, el servicio HttpService importado desde @nestjs/common fue deprecado. Instala la dependencia @nestjs/axios e impórtalo desde ahí. No deberás realizar ningún otro cambio en tu código. También debes asegurarte de importar el módulo HttpModule desde la misma dependencia.

import { HttpService } from '@nestjs/axios';

@Module({
  providers: [
    {
      provide: 'DATA',
      useFactory: async (http: HttpService) => {
        return await http.get('<URL_REQUEST>').toPromise()
      },
      inject: [HttpService]
    }
  ],
})
export class AppModule {}

La propiedad inject permite que inyectes (valga la redundancia) dentro de esta función asíncrona del useFactory otros servicios que este pueda necesitar. En el ejemplo anterior, se está haciendo una llamada a un request para obtener datos.

Importa estos datos en el controlador que lo necesite de la siguiente manera.

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

@Controller()
export class AppController {

  constructor(@Inject('DATA') private data: any[]) {}
}

Así podrás hacer uso de estos datos que fueron cargados de forma asíncrona.

Ten en cuenta que, al realizar una solicitud asíncrona, el controlador dependerá de la finalización de este proceso para estar disponible, pudiendo retrasar el inicio de tu aplicación. Esta funcionalidad suele utilizarse para conexiones de base de datos o procesos asíncronos similares.

Cuadro de código para inyección de servicios useFactory

// src/app.module.ts
import { Module, HttpModule, HttpService } from '@nestjs/common';  // 👈 imports

@Module({
  imports: [HttpModule, UsersModule, ProductsModule],
  controllers: [AppController],
  providers: [
    imports: [HttpModule, UsersModule, ProductsModule], // 👈 add HttpModule
    ...,
    {
      provide: 'TASKS',
      useFactory: async (http: HttpService) => { // 👈 implement useFactory
        const tasks = await http
          .get('https://jsonplaceholder.typicode.com/todos')
          .toPromise();
        return tasks.data;
      },
      inject: [HttpService],
    },
  ],
})
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('TASKS') private tasks: any[], // 👈 inject TASKS
  ) {}
  getHello(): string {
    console.log(this.tasks); // 👈 print TASKS
    return `Hello World! ${this.apiKey}`;
  }
}

Contribución creada por: Kevin Fiorentino.

Ángel David Roque Ayala

Hace 5 años

Resumen

httpService

httpService nos permite hacer peticiones HTTP (get, post, put, delete, ...). Esta libreria se basa en Axios (axios es una libreria de javascript para hacer peticiones http).

Uso de http

Para usar httpService debemos hacer 2 cosas

Declarar el modulo HttpModule dentro del modulo que usar el servicio

import { HttpModule } from '@nestjs/common';  // 👈 imports
...
@Module({
	imports: [HttpModule, ...], // 👈 
})

Inyectar el servicio en los providers del modulo que usara el servicio

import { HttpService } from '@nestjs/common';  // 👈 imports
...
@Injectable()
export class NameClass{
  constructor(private httpService: HttpService) {} // 👈 inyeccion
	...
}

// Listo, ahora podremos usar el modulo
 nameOfFunction(): Observable<AxiosResponse<EntitiName[]>> {
    return this.httpService.get('url');
 }

Introducción

Use factory permite crear valores dinámicamente. El valor real del provider ( sean valores, objetos, clases) será proporcionado por lo que se devuelva en una función fabricadora, aun si el valor se obtenga de forma asíncrona. La función fabricadora puede recibir parámetros.

Creacion del provider

// src/app.module.ts
import { Module, HttpModule, HttpService } from '@nestjs/common';  // 👈 imports

@Module({
  imports: [HttpModule, UsersModule, ProductsModule],
  controllers: [AppController],
  providers: [
    imports: [HttpModule, UsersModule, ProductsModule], // 👈 Se vuelven a importar los modul
    ...,
    {
      provide: 'TASKS',
      useFactory: async (http: HttpService) => { // 👈 implement useFactory
        const tasks = await http
          .get('https://jsonplaceholder.typicode.com/todos')
          .toPromise();
        return tasks.data;
      },
      inject: [HttpService], // Se inyecta los servicios que usara la funcion fabricadora
    },
  ],
})
export class AppModule {}

Uso del provider

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

@Injectable()
export class AppService {
  constructor(
    @Inject('API_KEY') private apiKey: string,
    @Inject('TASKS') private tasks: any[], // 👈 inject TASKS
  ) {}
  getHello(): string {
    console.log(this.tasks); // 👈 print TASKS
    return `Hello World! ${this.apiKey}`;
  }
}

Comentarios (31)31 comentarios

Marlos Rodriguez

Edward Trigos Lopez

Sergio Willed

Hace 4 años

René Sanchez

Adriana Fernanda Moya Forero

Profesor

Kevin Zavala

Antonio de Jesús Tabares Torres

Enmanuel Josue Sarmiento Benitez

Josué Ramírez Ramírez

Antonio de Jesús Domínguez García

Kenny Jared Molina Murillo

Jesus Alberto Diaz Acosta

Iván Viveros

Edwin Torres

Iván Ozono

Mónica Paola Parra López

Felix Bossio

Gaspar Dolcemascolo

Diego Jurado

Hace 3 años

Anderson Peñaloza

Francisco José Reyes José Reyes

Diego Artiles

Nicolás Giménez

MATEO FLOREZ ARROYO

Miguel Angel Reyes Moreno

Juan Camilo Noreña López

Brayhan Andres Jaramillo Castaño

Luis Berenguer

Juan Daniel Zuluaga Serna

Francisco Quintui

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

useFactory

Progreso del curso

Módulos de NestJS

Configuración de entornos

Documentación

Deploy

Próximos pasos

Recursos

Recursos