Passer au contenu
NestJS

Module HTTP

Axios est un package client HTTP riche en fonctionnalités et largement utilisé. Nest enveloppe Axios et l’expose via le module intégré HttpModule. Le HttpModule exporte la classe HttpService, qui expose des méthodes basées sur Axios pour effectuer des requêtes HTTP. La bibliothèque transforme également les réponses HTTP résultantes en Observables.

Installation

Pour commencer à l’utiliser, nous devons d’abord installer les dépendances requises.

Fenêtre de terminal
$ npm i --save @nestjs/axios axios

Prise en main

Une fois le processus d’installation terminé, pour utiliser le HttpService, commencez par importer le HttpModule.

Exemple d'importation du module HTTP
@Module({
  imports: [HttpModule],
  providers: [CatsService],
})
export class CatsModule {}

Ensuite, injectez le HttpService à l’aide de l’injection de constructeur normale.

Injection du service HTTP
@Injectable()
export class CatsService {
  constructor(private readonly httpService: HttpService) {}


  findAll(): Observable<AxiosResponse<Cat[]>> {
    return this.httpService.get('http://localhost:3000/cats');
  }
}

Tous les méthodes de HttpService retournent un AxiosResponse enveloppé dans un objet Observable.

Configuration

Axios peut être configuré avec une variété d’options pour personnaliser le comportement du HttpService. Pour en savoir plus, lisez ici. Pour configurer l’instance Axios sous-jacente, passez un objet d’options facultatif à la méthode register() de HttpModule lors de l’importation.

Configuration du module HTTP
@Module({
  imports: [
    HttpModule.register({
      timeout: 5000,
      maxRedirects: 5,
    }),
  ],
  providers: [CatsService],
})
export class CatsModule {}

Configuration asynchrone

Lorsque vous devez passer des options de module de manière asynchrone au lieu de statiquement, utilisez la méthode registerAsync(). Comme la plupart des modules dynamiques, Nest fournit plusieurs techniques pour gérer la configuration asynchrone.

Une technique est d’utiliser une fonction de fabrique :

Configuration asynchrone avec fonction de fabrique
HttpModule.registerAsync({
  useFactory: () => ({
    timeout: 5000,
    maxRedirects: 5,
  }),
});

Comme d’autres fournisseurs de fabrique, notre fonction de fabrique peut être asynchrone et peut injecter des dépendances via inject.

Injection de dépendances dans la configuration asynchrone
HttpModule.registerAsync({
  imports: [ConfigModule],
  useFactory: async (configService: ConfigService) => ({
    timeout: configService.get('HTTP_TIMEOUT'),
    maxRedirects: configService.get('HTTP_MAX_REDIRECTS'),
  }),
  inject: [ConfigService],
});

Alternativement, vous pouvez configurer le HttpModule en utilisant une classe plutôt qu’une fabrique.

Configuration via une classe
HttpModule.registerAsync({
  useClass: HttpConfigService,
});

La construction ci-dessus instancie HttpConfigService à l’intérieur de HttpModule, qu’il utilise pour créer un objet d’options.

Utilisation directe d’Axios

Si vous pensez que les options de HttpModule.register ne suffisent pas pour vous, ou si vous souhaitez simplement accéder à l’instance Axios sous-jacente créée par @nestjs/axios, vous pouvez y accéder via HttpService#axiosRef comme suit :

Utilisation directe d'Axios
@Injectable()
export class CatsService {
  constructor(private readonly httpService: HttpService) {}


  findAll(): Promise<AxiosResponse<Cat[]>> {
    return this.httpService.axiosRef.get('http://localhost:3000/cats');
    //                     ^ Interface AxiosInstance
  }
}

Exemple complet

Étant donné que la valeur de retour des méthodes HttpService est un Observable, nous pouvons utiliser rxjs - firstValueFrom ou lastValueFrom pour récupérer les données de la requête sous forme de promesse.

Exemple complet avec promesse
import { catchError, firstValueFrom } from 'rxjs';


@Injectable()
export class CatsService {
  private readonly logger = new Logger(CatsService.name);


  constructor(private readonly httpService: HttpService) {}


  async findAll(): Promise<Cat[]> {
    const { data } = await firstValueFrom(
      this.httpService.get<Cat[]>('http://localhost:3000/cats').pipe(
        catchError((error: AxiosError) => {
          this.logger.error(error.response.data);
          throw 'An error happened!';
        }),
      ),
    );
    return data;
  }
}