@mittwald/api-client-commons 4.168.0 → 4.224.1

package/dist/esm/core/ApiClientBase.js

@@ -1,11 +1,19 @@
-import axios, { Axios } from "axios";
+import axios from "axios";
 import Request from "./Request.js";
 export class ApiClientBase {
     axios;
     defaultRequestOptions = {};
-    constructor(axiosConfig = axios) {
-        this.axios =
-            axiosConfig instanceof Axios ? axiosConfig : axios.create(axiosConfig);
+    constructor(axiosOrConfig = axios) {
+        if ("request" in axiosOrConfig &&
+            typeof axiosOrConfig.request === "function") {
+            this.axios = axiosOrConfig;
+        }
+        else if (typeof axiosOrConfig === "object") {
+            this.axios = axios.create(axiosOrConfig);
+        }
+        else {
+            throw new Error("missing axios instance");
+        }
     }
     buildRequestOptions(fromRequest) {
         return {

package/dist/esm/core/ApiClientBase.test.js

@@ -1,37 +1,139 @@
-import { Axios } from "axios";
-import { beforeEach, jest } from "@jest/globals";
+import axios from "axios";
+import { expect, jest } from "@jest/globals";
 import ApiClientBase from "./ApiClientBase.js";
-const requestFn = jest.fn();
-const mockedAxios = Object.assign(Object.create(Axios.prototype), {
-    request: requestFn,
-});
+import nock from "nock";
+let apiHistory = [];
 class TestClient extends ApiClientBase {
-    testRequest = this.requestFunctionFactory({
-        path: "/test",
+    testRequestWillSucceed = this.requestFunctionFactory({
+        path: "/200",
         method: "GET",
         operationId: "test",
     });
+    testRequestWillFail = this.requestFunctionFactory({
+        path: "/500",
+        method: "GET",
+        operationId: "fail",
+    });
+    testNetworkError = this.requestFunctionFactory({
+        path: "/networkErrorUrl",
+        method: "GET",
+        operationId: "networkError",
+    });
 }
-const testClient = new TestClient(mockedAxios);
+axios.defaults.baseURL = "http://www.example.com";
+const testClient = new TestClient(axios);
+let testApi;
 beforeEach(() => {
     jest.resetAllMocks();
+    apiHistory = [];
+    testApi = nock("http://www.example.com")
+        .get("/200")
+        .reply(200, { success: 1 })
+        .get("/networkErrorUrl")
+        .replyWithError(Object.assign(new Error("Network Error"), { code: "ERR_NETWORK" }))
+        .get("/500")
+        .reply(500, { fail: 1 });
+    testApi.on("request", (req, interceptor, body) => {
+        apiHistory.push({
+            method: req.method,
+            path: req.path,
+            body: body,
+            headers: req.headers,
+        });
+    });
 });
 test("onBeforeRequest is called before actual request", async () => {
     const onBeforeRequest = jest.fn(() => {
-        expect(requestFn).not.toHaveBeenCalled();
+        expect(apiHistory).toHaveLength(0);
     });
-    await testClient.testRequest(undefined, {
+    await testClient.testRequestWillSucceed(undefined, {
         onBeforeRequest,
     });
-    expect(onBeforeRequest).toHaveBeenCalledTimes(1);
-    expect(requestFn).toHaveBeenCalledTimes(1);
+    expect(apiHistory).toHaveLength(1);
 });
 test("onBeforeRequest configured in default options is called before actual request", async () => {
     const onBeforeRequest = jest.fn(() => {
-        expect(requestFn).not.toHaveBeenCalled();
+        expect(apiHistory).toHaveLength(0);
     });
     testClient.defaultRequestOptions.onBeforeRequest = onBeforeRequest;
-    await testClient.testRequest(undefined);
+    await testClient.testRequestWillSucceed();
     expect(onBeforeRequest).toHaveBeenCalledTimes(1);
-    expect(requestFn).toHaveBeenCalledTimes(1);
+    expect(apiHistory).toHaveLength(1);
+});
+test("test client will work with axiosInstance", async () => {
+    const axiosInstance = axios.create({
+        headers: {
+            TEST_FROM_INSTANCE: 1,
+        },
+    });
+    const testClient = new TestClient(axiosInstance);
+    await testClient.testRequestWillSucceed();
+    expect(apiHistory).toHaveLength(1);
+    expect(apiHistory.at(0)).toHaveProperty("headers.test_from_instance", "1");
+});
+test("test client will work with config", async () => {
+    const testClient = new TestClient({
+        headers: {
+            TEST_FROM_CONFIG: 1,
+        },
+    });
+    await testClient.testRequestWillSucceed();
+    expect(apiHistory).toHaveLength(1);
+    expect(apiHistory.at(0)).toHaveProperty("headers.test_from_config", "1");
+});
+test("test client will work with axios default", async () => {
+    axios.defaults.headers = {
+        TEST_FROM_DEFAULT: 1,
+    };
+    const testClient = new TestClient(axios);
+    await testClient.testRequestWillSucceed();
+    expect(apiHistory).toHaveLength(1);
+    expect(apiHistory.at(0)).toHaveProperty("headers.test_from_default", "1");
+});
+test("test client will work with axios default param", async () => {
+    axios.defaults.headers = {
+        TEST_FROM_DEFAULT_PARAM: 1,
+    };
+    const testClient = new TestClient();
+    await testClient.testRequestWillSucceed();
+    expect(apiHistory).toHaveLength(1);
+    expect(apiHistory.at(0)).toHaveProperty("headers.test_from_default_param", "1");
+});
+test("test request will resolved with receive data", async () => {
+    const response = testClient.testRequestWillSucceed();
+    await expect(response).resolves.toHaveProperty("data.success", 1);
+});
+test("test request will be resolved even when status check fails", async () => {
+    const success = jest.fn();
+    const fail = jest.fn();
+    axios.interceptors.response.use((response) => {
+        success(response.config.url);
+        return response;
+    }, (error) => {
+        fail(error.config.url);
+        throw error;
+    });
+    const response = testClient.testRequestWillFail();
+    // check resolves
+    await expect(response).resolves.toHaveProperty("data.fail", 1);
+    // check interceptor call
+    expect(success).toBeCalledTimes(0);
+    expect(fail).toBeCalledWith("500");
+});
+test("test request will rejects on network error", async () => {
+    const success = jest.fn();
+    const fail = jest.fn();
+    axios.interceptors.response.use((response) => {
+        success(response.config.url);
+        return response;
+    }, (error) => {
+        fail(error.config.url);
+        throw error;
+    });
+    const response = testClient.testNetworkError();
+    // check rejects
+    await expect(response).rejects.toThrowError("Network Error");
+    // check interceptor call
+    expect(success).toBeCalledTimes(0);
+    expect(fail).toBeCalledWith("networkErrorUrl");
 });

package/dist/esm/core/Request.js

@@ -1,4 +1,5 @@
 import OpenAPIPath from "./OpenAPIPath.js";
+import { AxiosError, } from "axios";
 export class Request {
     operationDescriptor;
     requestObject;
@@ -8,8 +9,18 @@ export class Request {
         this.requestObject = requestObject;
         this.requestConfig = this.buildAxiosConfig();
     }
-    execute(axios) {
-        return axios.request(this.requestConfig);
+    async execute(axios) {
+        try {
+            const response = await axios.request(this.requestConfig);
+            return response;
+        }
+        catch (e) {
+            const error = AxiosError.from(e);
+            if (error.isAxiosError && error.response) {
+                return error.response;
+            }
+            throw e;
+        }
     }
     buildAxiosConfig() {
         const { method, path } = this.operationDescriptor;
@@ -36,7 +47,6 @@ export class Request {
             // Must be a plain object or an URLSearchParams object
             params,
             data,
-            validateStatus: () => true,
         };
     }
     makeAxiosHeaders(headers) {

package/dist/types/core/ApiClientBase.d.ts

@@ -4,7 +4,7 @@ import { OpenAPIOperation } from "../types/index.js";
 export declare abstract class ApiClientBase {
     readonly axios: AxiosInstance;
     readonly defaultRequestOptions: RequestOptions;
-    constructor(axiosConfig?: AxiosInstance | CreateAxiosDefaults);
+    constructor(axiosOrConfig?: AxiosInstance | CreateAxiosDefaults);
     private buildRequestOptions;
     protected requestFunctionFactory<TOp extends OpenAPIOperation>(operation: TOp): RequestFunction<TOp>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mittwald/api-client-commons",
-  "version": "4.168.0",
+  "version": "4.224.1",
   "author": "Mittwald CM Service GmbH & Co. KG <opensource@mittwald.de>",
   "type": "module",
   "description": "Common types and utilities for mittwald API clients",
@@ -41,7 +41,7 @@
   },
   "dependencies": {
     "@types/parse-path": "^7.0.3",
-    "axios": "^1.8.2",
+    "axios": "^1.12.2",
     "parse-path": "^7.0.0",
     "path-to-regexp": "^8.2.0",
     "type-fest": "^4.30.0"
@@ -52,11 +52,13 @@
     "@types/jest": "^29.5.14",
     "@typescript-eslint/eslint-plugin": "^7.18.0",
     "@typescript-eslint/parser": "^7.18.0",
+    "axios": "^1.12.2",
     "eslint": "^8.57.1",
     "eslint-config-prettier": "^9.1.0",
     "eslint-plugin-json": "^3.1.0",
     "eslint-plugin-prettier": "^5.2.1",
     "jest": "^29.7.0",
+    "nock": "^14.0.10",
     "prettier": "^3.4.2",
     "prettier-plugin-jsdoc": "^1.3.0",
     "prettier-plugin-pkgsort": "^0.2.1",
@@ -78,5 +80,5 @@
       "optional": true
     }
   },
-  "gitHead": "5b960bff6080e3f17c8d10feffa6710d72d67280"
+  "gitHead": "03179131bc51d51e73f0a35c2be089db76c601a5"
 }