@moneylion/engine-api 1.3.6 → 1.3.7

package/dist/client.d.ts

@@ -13,12 +13,16 @@ export declare class Client {
     private auth_token;
     private fetch_impl;
     private timeout_ms;
+    private additional_headers;
     /**
      * Construct a new client instance.
      * @param host - The API host URL. Example: https://www.example.com. Should not include a trailing slash.
      * @param auth_token - The auth token used for authenticating with the API.
+     * @param timeout_ms - Request timeout in milliseconds. Defaults to 15 seconds.
+     * @param fetch_impl - Fetch implementation to use. Defaults to global fetch.
+     * @param additional_headers - Additional headers to include in all requests.
      */
-    constructor(host: string | undefined, auth_token: string, timeout_ms?: number, fetch_impl?: typeof fetch);
+    constructor(host: string | undefined, auth_token: string, timeout_ms?: number, fetch_impl?: typeof fetch, additional_headers?: Record<string, string>);
     /**
      * Make a GET request.
      *
@@ -59,6 +63,11 @@ export declare class Client {
      * @returns A deserialized Javascript object wrapped in a Promise.
      */
     request(endpoint: string, method: HttpMethod, body?: string): Promise<object>;
+    /**
+     * Safely attempts to read the response body as text.
+     * Returns an error message if reading fails.
+     */
+    private safelyReadResponseBody;
 }
 /** The generic error class used to represent error status codes such as 400 Bad Request.
  */
@@ -72,15 +81,19 @@ export declare class ApiError extends Error {
     /** The HTTP method that was used for the request.
      */
     method: HttpMethod;
-    /** The serialized body.
+    /** The serialized request body.
      */
     body?: string;
-    constructor({ failureStatus, failureReason, url, method, body }: {
+    /** The response body as text.
+     */
+    responseBody: string;
+    constructor({ failureStatus, failureReason, url, method, body, responseBody, }: {
         failureStatus?: number;
         failureReason: string;
         url: string;
         method: HttpMethod;
         body?: string;
+        responseBody?: string;
     });
 }
 /**

package/dist/client.js

@@ -20,12 +20,16 @@ export class Client {
      * Construct a new client instance.
      * @param host - The API host URL. Example: https://www.example.com. Should not include a trailing slash.
      * @param auth_token - The auth token used for authenticating with the API.
+     * @param timeout_ms - Request timeout in milliseconds. Defaults to 15 seconds.
+     * @param fetch_impl - Fetch implementation to use. Defaults to global fetch.
+     * @param additional_headers - Additional headers to include in all requests.
      */
-    constructor(host = "https://api.evenfinancial.com", auth_token, timeout_ms = 15 * 1000, fetch_impl = fetch) {
+    constructor(host = "https://api.evenfinancial.com", auth_token, timeout_ms = 15 * 1000, fetch_impl = fetch, additional_headers = {}) {
         this.host = host;
         this.auth_token = auth_token;
         this.fetch_impl = fetch_impl;
         this.timeout_ms = timeout_ms;
+        this.additional_headers = additional_headers;
     }
     /**
      * Make a GET request.
@@ -81,40 +85,40 @@ export class Client {
             const response = yield Promise.race([
                 this.fetch_impl(url, {
                     method: method,
-                    headers: {
-                        "Content-Type": "application/json",
-                        "Accept": "application/json",
-                        "Authorization": `Bearer ${this.auth_token}`,
-                    },
+                    headers: Object.assign({ "Content-Type": "application/json", "Accept": "application/json", "Authorization": `Bearer ${this.auth_token}` }, this.additional_headers),
                     body: body,
                 }),
-                timeout
+                timeout,
             ]);
             if (response === undefined) {
                 throw new TimeoutError({
                     failureReason: "Client Timeout",
                     url,
                     method,
-                    body
+                    body,
                 });
             }
             if (response.status >= 500) {
+                const responseBody = yield this.safelyReadResponseBody(response);
                 throw new ServerError({
                     failureStatus: response.status,
                     failureReason: response.statusText,
                     url,
                     method,
-                    body
+                    body,
+                    responseBody,
                 });
             }
             if (response.status >= 400) {
+                const responseBody = yield this.safelyReadResponseBody(response);
                 if (response.status === 401 || response.status === 403) {
                     throw new AuthenticationError({
                         failureStatus: response.status,
                         failureReason: response.statusText,
                         url,
                         method,
-                        body
+                        body,
+                        responseBody,
                     });
                 }
                 throw new ClientError({
@@ -122,7 +126,8 @@ export class Client {
                     failureReason: response.statusText,
                     url,
                     method,
-                    body
+                    body,
+                    responseBody,
                 });
             }
             /* node-fetch types json() as Promise<unknown> to ensure the consumer makes a decision about the
@@ -133,16 +138,32 @@ export class Client {
             return json;
         });
     }
+    /**
+     * Safely attempts to read the response body as text.
+     * Returns an error message if reading fails.
+     */
+    safelyReadResponseBody(response) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const text = yield response.text();
+                return text || "[Empty response body]";
+            }
+            catch (error) {
+                return `[Unable to read response body: ${error instanceof Error ? error.message : String(error)}]`;
+            }
+        });
+    }
 }
 /** The generic error class used to represent error status codes such as 400 Bad Request.
  */
 export class ApiError extends Error {
-    constructor({ failureStatus, failureReason, url, method, body }) {
+    constructor({ failureStatus, failureReason, url, method, body, responseBody = "", }) {
         super(failureReason);
         this.failureStatus = failureStatus;
         this.url = url;
         this.method = method;
         this.body = body;
+        this.responseBody = responseBody;
     }
 }
 /**

package/dist/client.test.js

@@ -1,8 +1,18 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
 import { describe, expect, test, beforeAll, afterEach, afterAll, } from "@jest/globals";
 import { Client, AuthenticationError, ClientError, ServerError, TimeoutError, } from "./client";
 import { setupServer } from "msw/node";
 import { http, HttpResponse } from "msw";
 const successBody = { response: "Okay" };
+const errorResponseBody = { error: "Something went wrong", code: "ERR_001" };
 const handlers = [
     http.get("https://example.com/auth_error", () => {
         return new HttpResponse(null, { status: 401 });
@@ -10,9 +20,15 @@ const handlers = [
     http.post("https://example.com/bad_request", () => {
         return new HttpResponse(null, { status: 400 });
     }),
+    http.post("https://example.com/bad_request_with_body", () => {
+        return HttpResponse.json(errorResponseBody, { status: 400 });
+    }),
     http.get("https://example.com/server_error", () => {
         return new HttpResponse(null, { status: 500 });
     }),
+    http.get("https://example.com/server_error_with_body", () => {
+        return HttpResponse.json(errorResponseBody, { status: 500 });
+    }),
     http.get("https://example.com/network_error", () => {
         return HttpResponse.error();
     }),
@@ -25,6 +41,13 @@ const handlers = [
     http.patch("https://example.com/success", () => {
         return HttpResponse.json(successBody);
     }),
+    http.get("https://example.com/check_headers", ({ request }) => {
+        const headers = Object.fromEntries(request.headers.entries());
+        return HttpResponse.json({ headers });
+    }),
+    http.get("https://example.com/empty_error_body", () => {
+        return new HttpResponse("", { status: 400 });
+    }),
 ];
 const server = setupServer(...handlers);
 describe("Client", () => {
@@ -83,4 +106,78 @@ describe("Client", () => {
         const response = client.request("timeout_error", "GET");
         return expect(response).rejects.toThrow(TimeoutError);
     });
+    test("Additional headers are included in requests", () => __awaiter(void 0, void 0, void 0, function* () {
+        const client = new Client(testEndpoint, "good_token", 15000, fetch, {
+            "x-custom-header": "test-value",
+            "x-another-header": "another-value",
+        });
+        const response = yield client.get("check_headers");
+        const headers = response.headers;
+        expect(headers).toMatchObject({
+            "x-another-header": "another-value",
+            "x-custom-header": "test-value",
+        });
+    }));
+    test("Response body is captured in ClientError", () => __awaiter(void 0, void 0, void 0, function* () {
+        const client = new Client(testEndpoint, "good_token");
+        try {
+            yield client.post("bad_request_with_body", { test: "body" });
+        }
+        catch (error) {
+            expect(error).toBeInstanceOf(ClientError);
+            if (error instanceof ClientError) {
+                expect(error.responseBody).toBe(JSON.stringify(errorResponseBody));
+                expect(error.failureStatus).toBe(400);
+            }
+        }
+    }));
+    test("Response body is captured in ServerError", () => __awaiter(void 0, void 0, void 0, function* () {
+        const client = new Client(testEndpoint, "good_token");
+        try {
+            yield client.get("server_error_with_body");
+        }
+        catch (error) {
+            expect(error).toBeInstanceOf(ServerError);
+            if (error instanceof ServerError) {
+                expect(error.responseBody).toBe(JSON.stringify(errorResponseBody));
+                expect(error.failureStatus).toBe(500);
+            }
+        }
+    }));
+    test("Empty response body returns placeholder message", () => __awaiter(void 0, void 0, void 0, function* () {
+        const client = new Client(testEndpoint, "good_token");
+        try {
+            yield client.get("empty_error_body");
+        }
+        catch (error) {
+            expect(error).toBeInstanceOf(ClientError);
+            if (error instanceof ClientError) {
+                expect(error.responseBody).toBe("[Empty response body]");
+                expect(error.failureStatus).toBe(400);
+            }
+        }
+    }));
+    test("Unreadable response body returns error message", () => __awaiter(void 0, void 0, void 0, function* () {
+        // Mock fetch that returns a response where .text() throws an error
+        const fetch_impl = () => __awaiter(void 0, void 0, void 0, function* () {
+            return {
+                status: 500,
+                statusText: "Internal Server Error",
+                text: () => __awaiter(void 0, void 0, void 0, function* () {
+                    throw new Error("Sample error");
+                }),
+            };
+        });
+        const client = new Client(testEndpoint, "good_token", 15000, fetch_impl);
+        try {
+            yield client.get("unreadable_error_body");
+        }
+        catch (error) {
+            expect(error).toBeInstanceOf(ServerError);
+            if (error instanceof ServerError) {
+                expect(error.responseBody).toBe("[Unable to read response body: Sample error]");
+                expect(error.failureStatus).toBe(500);
+            }
+        }
+    }));
 });

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@moneylion/engine-api",
-	"version": "1.3.6",
+	"version": "1.3.7",
 	"description": "Interface to engine.tech API",
 	"type": "module",
 	"main": "dist/index.js",