Nest.js Axios Promise

A thin wrapper around Axios for Nest.js using Promises, because the @nestjs/axios package returns an observable. See #why

Install

1pnpm add nestjs-axios-promise

Usage

1import { AxiosService } from "./axios.service";
2
3@Module({
4  imports: [AxiosModule.register()],
5  providers: [MyCustomService],
6})
7export class AppModule {}

1@Injectable()
2export class MyCustomService {
3  constructor(private readonly http: AxiosService) {}
4
5  async doWork() {
6    const response = await this.http.get("/");
7    console.log(response);
8  }
9}

Custom Axios config

1@Module({
2  imports: [
3    AxiosModule.register({
4      config: {
5        baseURL: "https://example.com",
6        headers: {
7          "X-My-Header": "Is a value!",
8        },
9      },
10    }),
11  ],
12})
13export class AppModule {}

Register Axios interceptors

Axios interceptors can be configured on Axios clients to intercept requests or responses before they are handled by then or catch.

1import { create } from "axios";
2
3const client = create();
4
5client.interceptors.request.use(
6  (request) => {
7    return request;
8  },
9  (err) => {
10    return err;
11  },
12  {},
13);
14
15client.interceptors.response.use(
16  (response) => {
17    return response;
18  },
19  (err) => {
20    return err;
21  },
22  {},
23);

However, because NestJS abstracts away the construction of services, including this library's Axios wrapper which makes registering Axios interceptors difficult via the usual approach.

To resolve this, this module provides an additional way to configure interceptors via the module registration configuration:

1@Module({
2  imports: [
3    AxiosModule.register({
4      interceptors: {
5        request: {
6          onFulfilled: (requestConfig) => {
7            return requestConfig;
8          },
9          onRejected: (err) => {
10            return err;
11          },
12          options: {},
13        },
14
15        response: {
16          onFulfilled: (response) => {
17            return response;
18          },
19          onRejected: (err) => {
20            return err;
21          },
22          options: {},
23        },
24      },
25    }),
26  ],
27})
28export class AppModule {}

Interceptors can still be modified later via the Axios reference on the service:

1import { HttpService } from "nestjs-axios-promise";
2
3@Injectable()
4export class CatsService {
5  public constructor(private readonly httpService: HttpService) {}
6
7  public doThing() {
8    this.httpService.axios.interceptors.request.use((requestConfig) => {
9      return requestConfig;
10    });
11    this.httpService.axios.interceptors.request.eject();
12  }
13}

Why

Because I find our way using a promise

1import { AxiosService } from "nestjs-axios-promise";
2
3@Injectable()
4export class CatsService {
5  private readonly logger = new Logger(CatsService.name);
6
7  constructor(private readonly httpService: AxiosService) {}
8
9  findAll(): Promise<Cat[]> {
10    const { data } = await this.httpService
11      .get<Cat[]>("http://localhost:3000/cats")
12      .catch((error: AxiosError) => {
13        this.logger.error(error.response.data);
14        throw "An error happened!";
15      });
16    return data;
17  }
18}

MUCH more preferable to the NestJS way of using an observable. They're casting their observable to a promise anyways... :facepalm:

1import { catchError, firstValueFrom } from "rxjs";
2import { HttpService } from "@nestjs/axios";
3
4@Injectable()
5export class CatsService {
6  private readonly logger = new Logger(CatsService.name);
7  constructor(private readonly httpService: HttpService) {}
8
9  findAll(): Promise<Cat[]> {
10    const { data } = await firstValueFrom(
11      this.httpService.get<Cat[]>("http://localhost:3000/cats").pipe(
12        catchError((error: AxiosError) => {
13          this.logger.error(error.response.data);
14          throw "An error happened!";
15        }),
16      ),
17    );
18    return data;
19  }
20}