feat: shoud possible to throw error on interceptors

src/request.ts

@@ -91,6 +91,7 @@ export class NordusRequest {
     nordusConfigApi: NordusConfigApi,
     abort: AbortTimeout,
   ) {
+    let error, request;
     try {
       const urlRequest = this.generateURL(url, nordusConfigApi);
       const body = this.getBody(nordusConfigApi);
@@ -103,15 +104,16 @@ export class NordusRequest {
         ...nordusConfigApi,
       };
 
-      const request = new Request(urlRequest, init);
+      request = new Request(urlRequest, init);
 
       this.setHeaders(nordusConfigApi, request);
       this.setRequestType(request, nordusConfigApi);
-      await this.executeLoopAsync(this.interceptorRequest, null, request);
-      return request;
-    } catch (error: any) {
-      await this.executeLoopAsync(this.interceptorRequest, error, null);
-      throw error;
+    } catch (err: any) {
+      error = err;
+    } finally {
+      await this.executeLoopAsync(this.interceptorRequest, error, request);
+      if (error) throw error;
+      return request!;
     }
   }
 
@@ -121,21 +123,23 @@ export class NordusRequest {
     abort: AbortTimeout,
   ) {
     const timeoutId = abort.start();
+    let error, response;
     try {
-      const response = (await fetch(request)) as NordusResponse<T>;
+      response = (await fetch(request)) as NordusResponse<T>;
       clearTimeout(timeoutId);
       if (!response.ok) throw new Error(response.statusText);
 
       response.data = await this.getResponseFromType<T>(
         response,
         nordusConfigApi,
       );
-      await this.executeLoopAsync(this.interceptorsResponse, null, response);
-      return response;
-    } catch (error: any) {
+    } catch (err: any) {
+      error = err;
       clearTimeout(timeoutId);
-      await this.executeLoopAsync(this.interceptorsResponse, error, null);
-      throw error;
+    } finally {
+      await this.executeLoopAsync(this.interceptorsResponse, error, response);
+      if (error) throw error;
+      return response!;
     }
   }
 

tests/helpers/utils.ts

@@ -0,0 +1,3 @@
+export function delay(ms: number) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

tests/interceptors.spec.ts

@@ -1,6 +1,7 @@
-import { create, post } from "../src";
+import { create, get, post } from "../src";
 import { FetchMock } from "jest-fetch-mock";
 import { InterceptorRequest, InterceptorResponse } from "../src/request";
+import { delay } from "./helpers/utils";
 
 describe("interceptors", () => {
   const fetchMock = fetch as FetchMock;
@@ -385,4 +386,106 @@ describe("interceptors", () => {
     await instance.get("/todos/1");
     expect(textInterceptor).toEqual("");
   });
+
+  it("shoud possible to change headers on async interceptors on create instance", async () => {
+    fetchMock.mockResponseOnce(JSON.stringify({ test: "test" }));
+    const instance = create({
+      baseURL: "http://localhost:5000",
+      interceptors: {
+        request: async (err, request) => {
+          await delay(1);
+          request.headers.set("access_token", "Bearer 123");
+        },
+        response: async (err, response) => {
+          await delay(1);
+          return response;
+        },
+      },
+    });
+    await instance.get("/todos/1");
+    const lastCall = fetchMock?.mock?.lastCall?.at(0) as Request;
+    expect(lastCall?.headers.get("access_token")).toEqual("Bearer 123");
+  });
+
+  it("shoud possible to change headers on get request with interceptors", async () => {
+    fetchMock.mockResponseOnce(JSON.stringify({ test: "test" }));
+    await get("http://localhost:5000/todos/1", {
+      interceptors: {
+        request: async (err, request) => {
+          await delay(1);
+          request.headers.set("access_token", "Bearer 123");
+        },
+        response: async (err, response) => {
+          await delay(1);
+          return response;
+        },
+      },
+    });
+    const lastCall = fetchMock?.mock?.lastCall?.at(0) as Request;
+    expect(lastCall?.headers.get("access_token")).toEqual("Bearer 123");
+  });
+
+  it("shoud possible to throw error on request", async () => {
+    fetchMock.mockResponseOnce(JSON.stringify({ test: "test" }));
+
+    let textInterceptorRequest = "";
+    const firstInterceptorRequest: InterceptorRequest = () => {
+      textInterceptorRequest += "1";
+      throw new Error("Error on interceptor");
+    };
+    const secondInterceptorRequest: InterceptorRequest = () => {
+      textInterceptorRequest += "2";
+    };
+
+    let textInterceptorResponse = "";
+    const firstInterceptorResponse: InterceptorResponse = () => {
+      textInterceptorResponse += "1";
+    };
+    try {
+      await get("http://localhost:5000/todos/1", {
+        interceptors: {
+          request: [firstInterceptorRequest, secondInterceptorRequest],
+          response: [firstInterceptorResponse],
+        },
+      });
+    } catch (error) {
+      expect(error.message).toEqual("Error on interceptor");
+    }
+    expect(textInterceptorRequest).toEqual("1");
+    expect(textInterceptorResponse).toEqual("");
+  });
+
+  it("shoud possible to throw error on response", async () => {
+    fetchMock.mockResponseOnce(JSON.stringify({ test: "test" }));
+
+    let textInterceptorRequest = "";
+    const firstInterceptorRequest: InterceptorRequest = () => {
+      textInterceptorRequest += "1";
+    };
+    const secondInterceptorRequest: InterceptorRequest = () => {
+      textInterceptorRequest += "2";
+    };
+
+    let textInterceptorResponse = "";
+    const firstInterceptorResponse: InterceptorResponse = () => {
+      textInterceptorResponse += "1";
+      throw new Error("Error on interceptor");
+    };
+    const secondInterceptorResponse: InterceptorResponse = () => {
+      textInterceptorResponse += "2";
+    };
+
+    try {
+      await get("http://localhost:5000/todos/1", {
+        interceptors: {
+          request: [firstInterceptorRequest, secondInterceptorRequest],
+          response: [firstInterceptorResponse, secondInterceptorResponse],
+        },
+      });
+    } catch (error) {
+      expect(error.message).toEqual("Error on interceptor");
+    }
+    expect(textInterceptorRequest).toEqual("12");
+    expect(textInterceptorResponse).toEqual("1");
+  });
 });