useFactory

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

1. Declarar el modulo HttpModule dentro del modulo que usar el servicio

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

1. 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}`;
  }
}

El HttpModule de “@nestjs/common” ya no sera soportado en las siguientes versiones, tiene que utilizar “@nestjs/axios” y funciona exactamente igual.

The HttpModule exported from the @nestjs/common package has been deprecated and will be removed in the next major release. Instead, please use the @nestjs/axios package

Yo estoy usando la v8 de nest y estan deprecadas las que se estan utilizando ahora es utilizar firstValueFrom o lastValueFrom 😃

    {
      provide: 'TASKS',
      useFactory: async (http: HttpService) => {
        const tasks = await http.get(
          'https://jsonplaceholder.typicode.com/todos',
        );

        const data = await (await firstValueFrom(tasks)).data;

        return data;
      },
      inject: [HttpService],
    }

El método httpService también se puede usar con observables para aprovechar las ventajas de RxJs.
https://docs.nestjs.com/techniques/http-module#http-module

Se recomienda no usar Use Factory para llamar a APIs porque dependerias de esta esperando a que responda AWAIT. Solo se llamo a API por cuestiones de aprendizaje. Se puede hacer el llamado por medio del HTTP Module. Si usar Use Factory para BD como Mongo DB

Ahora me parece que se usa algo diferente por algunas cosas que están deprecated. Siguiendo los warnings del editor me quedé con algo así, espero les sirva 😄

Por cierto, hay que instalar esta otra librería:

yarn add @nestjs/axios

import { HttpModule, HttpService } from '@nestjs/axios';
import { Module } from '@nestjs/common';
import { firstValueFrom } from 'rxjs';

@Module({
  imports: [HttpModule],
  providers: [{
    provide: 'TASKS',
    useFactory: async (http: HttpService) => {
      const response = http.get('https://jsonplaceholder.typicode.com/todos');
      const tasks = await firstValueFrom(response);
      return tasks.data;
    },
    inject: [HttpService],
  }],
})

Para que el código funcione como el profesor nos muestra, el método ‘toPromise()’ está obsoleto, por lo que hay que instalar la dependencia rxjs

npm i rxjs

luego, el response de tipo “Observable” instanciado en la variable “tasks” se transforma en una promesa con el método “firstValueFrom()”, y pueden resolver la promesa como mejor les plazca, para continuar rápidamente instancié un Promise.resolve() así

import { Module } from '@nestjs/common';
import { HttpModule, HttpService } from '@nestjs/axios';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { ProductsModule } from './products/products.module';
import { UserModule } from './user/user.module';
import { firstValueFrom } from 'rxjs';

@Module({
  imports: [
    ProductsModule,
    UserModule,
    HttpModule.registerAsync({
      useFactory: () => ({
        timeout: 1000,
        maxRedirects: 5,
      }),
    }),
  ],
  controllers: [AppController],
  providers: [
    AppService,
    {
      provide: 'TASKS',
      inject: [HttpService],
      useFactory: async (http: HttpService) => {
        const tasks = await http.get(
          'https://jsonplaceholder.typicode.com/todos',
        );
        const value = Promise.resolve(firstValueFrom(tasks));
        return value;
      },
    },
  ],
})
export class AppModule {}

Espero de algo sirva!

Soy el único al que le pone nervioso que el profe no use auto format, de verdad es tan fácil.

Por si le interesa a alguno

Actualmente es depreciado el HttpModule o HttpService’.
Para solucionarlo hay que instalar la siguiente dependecia:

npm i --save @nestjs/axios

Importando

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

A 21 de Octubre HttpModule está depreciado si lo importas desde @nestjs/common, las recomendaciones indican importarlo mediante @nestjs/axios

Cuando trabajo directamente con express creo algunos micro-servicios, estos se comunican por medio de apis de ese micro-servicio. ¿Cómo traslado ese concepto a Nest?..

Request a otra API. Nuestro servicio hace un request a otro servicio por ejemplo la data de una otra API

Use Factory es una fabrica de provider para resolver algo asincrona y recibiendo una injeccion

Crack!