Enhance AxiosModule to allow registering Axios interceptors at module construction

Author: keawade

src/axios.module.ts

@@ -1,23 +1,65 @@
-import { Module } from "@nestjs/common";
-import Axios, { AxiosRequestConfig } from "axios";
+import { ConfigurableModuleBuilder, Module } from "@nestjs/common";
+import {
+  create,
+  type AxiosRequestConfig,
+  type AxiosResponse,
+  type AxiosInterceptorOptions,
+  type InternalAxiosRequestConfig,
+} from "axios";
 
 import { AxiosService } from "./axios.service";
 import { AXIOS_PROMISE_INSTANCE_TOKEN } from "./axios.constants";
 
+type AxiosModuleOptions = {
+  config?: AxiosRequestConfig;
+  interceptors?: {
+    response?: {
+      onFulfilled?: (value: AxiosResponse) => AxiosResponse | Promise<AxiosResponse>;
+      onRejected?: (error: any) => any;
+      options?: AxiosInterceptorOptions;
+    };
+    request?: {
+      onFulfilled?: (
+        value: InternalAxiosRequestConfig,
+      ) => InternalAxiosRequestConfig | Promise<InternalAxiosRequestConfig>;
+      onRejected?: (error: any) => any;
+      options?: AxiosInterceptorOptions;
+    };
+  };
+};
+
+const { ConfigurableModuleClass, OPTIONS_TYPE, MODULE_OPTIONS_TOKEN } =
+  new ConfigurableModuleBuilder<AxiosModuleOptions>().build();
+
 @Module({
-  providers: [AxiosService],
+  providers: [
+    AxiosService,
+    {
+      provide: AXIOS_PROMISE_INSTANCE_TOKEN,
+      inject: [MODULE_OPTIONS_TOKEN],
+      useFactory: (options: typeof OPTIONS_TYPE = {}) => {
+        const axiosInstance = create(options.config ?? {});
+
+        if (options.interceptors?.request) {
+          axiosInstance.interceptors.request.use(
+            options.interceptors.request.onFulfilled,
+            options.interceptors.request.onRejected,
+            options.interceptors.request.options,
+          );
+        }
+
+        if (options.interceptors?.response) {
+          axiosInstance.interceptors.response.use(
+            options.interceptors.response.onFulfilled,
+            options.interceptors.response.onRejected,
+            options.interceptors.response.options,
+          );
+        }
+
+        return axiosInstance;
+      },
+    },
+  ],
   exports: [AxiosService],
 })
-export class AxiosModule {
-  static register(config: AxiosRequestConfig = {}) {
-    return {
-      module: AxiosModule,
-      providers: [
-        {
-          provide: AXIOS_PROMISE_INSTANCE_TOKEN,
-          useValue: Axios.create(config),
-        },
-      ],
-    };
-  }
-}
+export class AxiosModule extends ConfigurableModuleClass {}

test/axios.module.test.ts

@@ -3,17 +3,111 @@ import { Test } from "@nestjs/testing";
 import { AxiosModule, AxiosService } from "../src";
 
 describe(AxiosModule, () => {
-  let axiosService: AxiosService;
-
-  beforeEach(async () => {
+  it("axios module export service", async () => {
     const moduleRef = await Test.createTestingModule({
       imports: [AxiosModule.register({})],
     }).compile();
 
-    axiosService = moduleRef.get<AxiosService>(AxiosService);
+    const axiosService = moduleRef.get<AxiosService>(AxiosService);
+
+    expect(axiosService).toBeDefined();
   });
 
-  it("axios module export service", () => {
+  it("should allow registering asynchronously", async () => {
+    const moduleRef = await Test.createTestingModule({
+      imports: [
+        AxiosModule.registerAsync({
+          useFactory: () => {
+            return {
+              config: {},
+            };
+          },
+        }),
+      ],
+    }).compile();
+
+    const axiosService = moduleRef.get<AxiosService>(AxiosService);
+
     expect(axiosService).toBeDefined();
   });
+
+  it("should register interceptors", async () => {
+    const responseOnFulfilled = jest.fn();
+    const requestOnFulfilled = jest.fn();
+
+    const moduleRef = await Test.createTestingModule({
+      imports: [
+        AxiosModule.register({
+          interceptors: {
+            response: {
+              onFulfilled: (response) => {
+                responseOnFulfilled("response");
+
+                return response;
+              },
+            },
+
+            request: {
+              onFulfilled: (requestConfig) => {
+                requestOnFulfilled("request");
+
+                return requestConfig;
+              },
+            },
+          },
+        }),
+      ],
+    }).compile();
+
+    const axiosService = moduleRef.get<AxiosService>(AxiosService);
+
+    await axiosService.get("https://github.com");
+
+    expect(responseOnFulfilled).toHaveBeenCalledTimes(1);
+    expect(responseOnFulfilled).toHaveBeenCalledWith("response");
+
+    expect(requestOnFulfilled).toHaveBeenCalledTimes(1);
+    expect(requestOnFulfilled).toHaveBeenCalledWith("request");
+  });
+
+  it("should async register interceptors", async () => {
+    const responseOnFulfilled = jest.fn();
+    const requestOnFulfilled = jest.fn();
+
+    const moduleRef = await Test.createTestingModule({
+      imports: [
+        AxiosModule.registerAsync({
+          useFactory: () => ({
+            interceptors: {
+              response: {
+                onFulfilled: (response) => {
+                  responseOnFulfilled("response");
+
+                  return response;
+                },
+              },
+
+              request: {
+                onFulfilled: (requestConfig) => {
+                  requestOnFulfilled("request");
+
+                  return requestConfig;
+                },
+              },
+            },
+          }),
+        }),
+      ],
+    }).compile();
+
+    const axiosService = moduleRef.get<AxiosService>(AxiosService);
+
+    await axiosService.get("https://github.com");
+
+    expect(responseOnFulfilled).toHaveBeenCalledTimes(1);
+    expect(responseOnFulfilled).toHaveBeenCalledWith("response");
+
+    expect(requestOnFulfilled).toHaveBeenCalledTimes(1);
+    expect(requestOnFulfilled).toHaveBeenCalledWith("request");
+  });
 });