HTTP module

Axios là một package HTTP client giàu tính năng và được dùng rất rộng rãi. Nest wrap (bao) Axios lại và expose nó qua HttpModule có sẵn. HttpModule export class HttpService, class này expose các method dựa trên Axios để thực hiện HTTP request. Thư viện này cũng chuyển đổi các HTTP response nhận được thành Observables.

Cài đặt (Installation)

Để bắt đầu sử dụng, trước tiên chúng ta cài các dependency cần thiết.

$ npm i --save @nestjs/axios axios

Bắt đầu (Getting started)

Sau khi cài đặt xong, để dùng HttpService, trước tiên import HttpModule.

@Module({
  imports: [HttpModule],
  providers: [CatsService],
})
export class CatsModule {}

Tiếp theo, inject HttpService bằng constructor injection thông thường.

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

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

@Injectable()
@Dependencies(HttpService)
export class CatsService {
  constructor(httpService) {
    this.httpService = httpService;
  }

  findAll() {
    return this.httpService.get('http://localhost:3000/cats');
  }
}

Tất cả method của HttpService đều trả về một AxiosResponse được bọc (wrap) trong một object Observable.

Cấu hình (Configuration)

Axios có thể được cấu hình với nhiều option khác nhau để tùy chỉnh hành vi của HttpService. Đọc thêm về các option này tại đây. Để cấu hình Axios instance bên dưới, truyền một object option (tùy chọn) vào method register() của HttpModule khi import nó. Object option này sẽ được truyền trực tiếp vào constructor của Axios bên dưới.

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

Cấu hình bất đồng bộ (Async configuration)

Khi bạn cần truyền module option một cách bất đồng bộ (asynchronously) thay vì tĩnh (statically), dùng method registerAsync(). Giống như hầu hết dynamic module khác, Nest cung cấp một số kỹ thuật để xử lý cấu hình bất đồng bộ.

Một kỹ thuật là dùng factory function:

HttpModule.registerAsync({
  useFactory: () => ({
    timeout: 5000,
    maxRedirects: 5,
  }),
});

Giống như các factory provider khác, factory function của chúng ta có thể là async và có thể inject dependency thông qua inject.

HttpModule.registerAsync({
  imports: [ConfigModule],
  useFactory: async (configService: ConfigService) => ({
    timeout: configService.get('HTTP_TIMEOUT'),
    maxRedirects: configService.get('HTTP_MAX_REDIRECTS'),
  }),
  inject: [ConfigService],
});

Ngoài ra, bạn có thể cấu hình HttpModule bằng một class thay vì factory, như bên dưới.

HttpModule.registerAsync({
  useClass: HttpConfigService,
});

Cấu trúc trên khởi tạo HttpConfigService bên trong HttpModule, dùng nó để tạo ra một object option. Chú ý rằng trong ví dụ này, HttpConfigService phải implement interface HttpModuleOptionsFactory, như bên dưới. HttpModule sẽ gọi method createHttpOptions() trên instance đã được khởi tạo của class được truyền vào.

@Injectable()
class HttpConfigService implements HttpModuleOptionsFactory {
  createHttpOptions(): HttpModuleOptions {
    return {
      timeout: 5000,
      maxRedirects: 5,
    };
  }
}

Nếu bạn muốn tái sử dụng một options provider đã có sẵn thay vì tạo một bản riêng bên trong HttpModule, dùng cú pháp useExisting.

HttpModule.registerAsync({
  imports: [ConfigModule],
  useExisting: HttpConfigService,
});

Bạn cũng có thể truyền cái gọi là extraProviders vào method registerAsync(). Các provider này sẽ được merge (gộp) với các provider của module.

HttpModule.registerAsync({
  imports: [ConfigModule],
  useClass: HttpConfigService,
  extraProviders: [MyAdditionalProvider],
});

Việc này hữu ích khi bạn muốn cung cấp thêm dependency cho factory function hoặc cho constructor của class.

Dùng Axios trực tiếp (Using Axios directly)

Nếu bạn thấy các option của HttpModule.register không đủ cho nhu cầu, hoặc chỉ đơn giản là muốn truy cập trực tiếp Axios instance được tạo bởi @nestjs/axios, bạn có thể truy cập nó qua HttpService#axiosRef như sau:

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

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

Ví dụ đầy đủ (Full example)

Vì giá trị trả về của các method HttpService là một Observable, chúng ta có thể dùng rxjs - firstValueFrom hoặc lastValueFrom để lấy dữ liệu của request dưới dạng một promise.

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;
  }
}