Merge pull request #1 from keawade/up-front-interceptor-config

Feature: Enable defining Axios interceptors during module registration

Author: jasonraimondi

README.md

@@ -38,22 +38,113 @@ export class MyCustomService {
 }
 ```
 
-### Custom Config
+### Custom Axios config
 
 ```typescript
 @Module({
   imports: [
     AxiosModule.register({
-      baseURL: "https://example.com",
-      headers: {
-        "X-My-Header": "Is a value!",
+      config: {
+        baseURL: "https://example.com",
+        headers: {
+          "X-My-Header": "Is a value!",
+        },
       },
     }),
   ],
 })
 export class AppModule {}
 ```
 
+#### Register Axios interceptors
+
+[Axios interceptors](https://axios-http.com/docs/interceptors) can be
+configured on Axios clients to intercept requests or responses before they are
+handled by `then` or `catch`.
+
+```typescript
+import { create } from "axios";
+
+const client = create();
+
+client.interceptors.request.use(
+  (request) => {
+    return request;
+  },
+  (err) => {
+    return err;
+  },
+  {},
+);
+
+client.interceptors.response.use(
+  (response) => {
+    return response;
+  },
+  (err) => {
+    return err;
+  },
+  {},
+);
+```
+
+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:
+
+```typescript
+@Module({
+  imports: [
+    AxiosModule.register({
+      interceptors: {
+        request: {
+          onFulfilled: (requestConfig) => {
+            return requestConfig;
+          },
+          onRejected: (err) => {
+            return err;
+          },
+          options: {},
+        },
+
+        response: {
+          onFulfilled: (response) => {
+            return response;
+          },
+          onRejected: (err) => {
+            return err;
+          },
+          options: {},
+        },
+      },
+    }),
+  ],
+})
+export class AppModule {}
+```
+
+Interceptors can still be modified later via the Axios reference on the
+service:
+
+```typescript
+import { HttpService } from "nestjs-axios-promise";
+
+@Injectable()
+export class CatsService {
+  public constructor(private readonly httpService: HttpService) {}
+
+  public doThing() {
+    this.httpService.axios.interceptors.request.use((requestConfig) => {
+      return requestConfig;
+    });
+    this.httpService.axios.interceptors.request.eject();
+  }
+}
+```
+
 ### Why
 
 Because I find our way using a promise
@@ -79,7 +170,8 @@ export class CatsService {
 }
 ```
 
-MUCH more preferrable to the nestjs way of using an observable. They're casting their observable to a promise anyways... :facepalm:
+MUCH more preferable to the NestJS way of using an observable. They're casting
+their observable to a promise anyways... :facepalm:
 
 ```ts
 import { catchError, firstValueFrom } from "rxjs";

package.json

@@ -46,5 +46,6 @@
     "main": "dist/index.js",
     "private": false,
     "license": "MIT"
-  }
+  },
+  "packageManager": "pnpm@9.12.3+sha512.cce0f9de9c5a7c95bef944169cc5dfe8741abfb145078c0d508b868056848a87c81e626246cb60967cbd7fd29a6c062ef73ff840d96b3c86c40ac92cf4a813ee"
 }

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");
+  });
 });