Módulo HTTP axios

Módulo HTTP axios en Nest

El módulo HTTP de NestJS proporciona una integración nativa con axios para realizar peticiones HTTP a servicios externos. Este módulo encapsula la funcionalidad de axios dentro del ecosistema de NestJS, permitiendo aprovechar las ventajas de la inyección de dependencias y la gestión de configuración del framework.

Instalación y configuración básica

Para utilizar el módulo HTTP, primero debemos instalarlo junto con axios:

npm install @nestjs/axios axios

Una vez instalado, necesitamos importar el HttpModule en nuestro módulo. La configuración más básica se realiza de la siguiente manera:

import { Module } from '@nestjs/common';
import { HttpModule } from '@nestjs/axios';
import { ApiService } from './api.service';

@Module({
  imports: [HttpModule],
  providers: [ApiService],
  exports: [ApiService],
})
export class ApiModule {}

Inyección del HttpService

El HttpService es el servicio principal que nos permite realizar peticiones HTTP. Se inyecta como cualquier otro servicio en NestJS:

import { Injectable } from '@nestjs/common';
import { HttpService } from '@nestjs/axios';
import { Observable } from 'rxjs';
import { AxiosResponse } from 'axios';

@Injectable()
export class ApiService {
  constructor(private readonly httpService: HttpService) {}

  getData(): Observable<AxiosResponse<any>> {
    return this.httpService.get('https://jsonplaceholder.typicode.com/posts');
  }
}

Es importante notar que el HttpService devuelve observables de RxJS, no promesas directamente. Esto permite un manejo más avanzado de las respuestas asíncronas.

Configuración avanzada del módulo

El HttpModule permite configuraciones más específicas mediante el método register():

import { Module } from '@nestjs/common';
import { HttpModule } from '@nestjs/axios';

@Module({
  imports: [
    HttpModule.register({
      timeout: 5000,
      maxRedirects: 5,
      baseURL: 'https://api.ejemplo.com',
      headers: {
        'Content-Type': 'application/json',
        'Authorization': 'Bearer token-ejemplo',
      },
    }),
  ],
  providers: [ApiService],
})
export class ApiModule {}

Esta configuración establece un timeout global, una URL base y headers por defecto que se aplicarán a todas las peticiones realizadas desde este módulo.

Manejo de respuestas con operadores RxJS

Dado que el HttpService devuelve observables, podemos utilizar operadores de RxJS para transformar y manejar las respuestas:

import { Injectable } from '@nestjs/common';
import { HttpService } from '@nestjs/axios';
import { map, catchError } from 'rxjs/operators';
import { Observable, throwError } from 'rxjs';

@Injectable()
export class ApiService {
  constructor(private readonly httpService: HttpService) {}

  getUsers(): Observable<any[]> {
    return this.httpService
      .get('https://jsonplaceholder.typicode.com/users')
      .pipe(
        map(response => response.data),
        catchError(error => {
          console.error('Error al obtener usuarios:', error);
          return throwError(() => new Error('Error en la petición'));
        }),
      );
  }
}

El operador map() nos permite extraer únicamente los datos de la respuesta, mientras que catchError() maneja los errores de forma elegante.

Conversión a promesas

Si preferimos trabajar con promesas en lugar de observables, podemos convertir fácilmente las respuestas:

import { Injectable } from '@nestjs/common';
import { HttpService } from '@nestjs/axios';
import { firstValueFrom } from 'rxjs';

@Injectable()
export class ApiService {
  constructor(private readonly httpService: HttpService) {}

  async getUserById(id: number): Promise<any> {
    try {
      const response = await firstValueFrom(
        this.httpService.get(`https://jsonplaceholder.typicode.com/users/${id}`)
      );
      return response.data;
    } catch (error) {
      throw new Error(`Error al obtener usuario ${id}: ${error.message}`);
    }
  }
}

La función firstValueFrom() convierte el observable en una promesa que se resuelve con el primer valor emitido.

Peticiones POST con datos

Para realizar peticiones POST con datos, el proceso es similar pero incluyendo el cuerpo de la petición:

@Injectable()
export class ApiService {
  constructor(private readonly httpService: HttpService) {}

  async createUser(userData: any): Promise<any> {
    try {
      const response = await firstValueFrom(
        this.httpService.post(
          'https://jsonplaceholder.typicode.com/users',
          userData,
          {
            headers: {
              'Content-Type': 'application/json',
            },
          }
        )
      );
      return response.data;
    } catch (error) {
      throw new Error(`Error al crear usuario: ${error.message}`);
    }
  }
}

Configuración dinámica con ConfigService

Para aplicaciones más robustas, es recomendable utilizar el ConfigService para manejar la configuración de forma dinámica:

import { Module } from '@nestjs/common';
import { HttpModule } from '@nestjs/axios';
import { ConfigModule, ConfigService } from '@nestjs/config';

@Module({
  imports: [
    HttpModule.registerAsync({
      imports: [ConfigModule],
      useFactory: async (configService: ConfigService) => ({
        timeout: configService.get('HTTP_TIMEOUT', 5000),
        baseURL: configService.get('API_BASE_URL'),
        headers: {
          'Authorization': `Bearer ${configService.get('API_TOKEN')}`,
        },
      }),
      inject: [ConfigService],
    }),
  ],
  providers: [ApiService],
})
export class ApiModule {}

Esta configuración permite cargar valores desde variables de entorno o archivos de configuración, haciendo la aplicación más flexible y segura.