Handle errors during requests more intentionally

Author: erbridge

lib/ReplicateClient.js

@@ -1,6 +1,10 @@
-import fetch from "node-fetch";
+import fetch, { FetchError } from "node-fetch";
 import pkg from "../package.json" assert { type: "json" };
-import { ReplicateError } from "./errors.js";
+import {
+  ReplicateError,
+  ReplicateRequestError,
+  ReplicateResponseError,
+} from "./errors.js";
 import Prediction from "./Prediction.js";
 import { sleep } from "./utils.js";
 
@@ -70,30 +74,43 @@ export default class ReplicateClient {
   async request(action, body) {
     const { method, path } = this.#parseAction(action);
 
+    const url = new URL(path, this.baseURL).href;
+    const requestInit = {
+      method,
+      headers: this.#headers(),
+      body: JSON.stringify(body),
+    };
+
     let resp;
     try {
-      resp = await fetch(new URL(path, this.baseURL).href, {
-        method,
-        headers: this.#headers(),
-        body: JSON.stringify(body),
-      });
+      resp = await fetch(url, requestInit);
     } catch (err) {
-      // TODO: Better error handling.
-      throw err;
+      if (!err instanceof FetchError) {
+        throw err;
+      }
+
+      throw new ReplicateRequestError(url, requestInit);
     }
 
+    const respText = await resp.text();
+
     if (!resp.ok) {
-      // TODO: Better error handling.
-      console.error(await resp.text());
-      throw new ReplicateError(resp.statusText);
+      let errorMessage;
+      try {
+        const respJSON = JSON.parse(respText);
+        errorMessage = respJSON.details;
+      } catch (err) {
+        if (!err instanceof SyntaxError) {
+          throw err;
+        }
+
+        errorMessage = respText;
+      }
+
+      throw new ReplicateResponseError(errorMessage, resp, action);
     }
 
-    try {
-      return await resp.json();
-    } catch (err) {
-      // TODO: Better error handling.
-      throw err;
-    }
+    return JSON.parse(respText);
   }
 
   #headers() {

lib/ReplicateClient.test.js

@@ -1,7 +1,20 @@
 import { jest } from "@jest/globals";
-import { ReplicateError } from "./errors.js";
+import { FetchError, Response } from "node-fetch";
+
+jest.unstable_mockModule("node-fetch", () => ({
+  default: jest.fn(),
+  FetchError,
+}));
+
+import {
+  ReplicateError,
+  ReplicateRequestError,
+  ReplicateResponseError,
+} from "./errors.js";
 import { PredictionStatus } from "./Prediction.js";
-import ReplicateClient from "./ReplicateClient.js";
+
+const { default: fetch } = await import("node-fetch");
+const { default: ReplicateClient } = await import("./ReplicateClient.js");
 
 let client;
 
@@ -161,3 +174,39 @@ describe("getPrediction()", () => {
     expect(client.request).toHaveBeenCalledWith("GET /v1/predictions/test-id");
   });
 });
+
+describe("request()", () => {
+  it("throws ReplicateRequestError on failed fetch", async () => {
+    fetch.mockImplementation(async () => {
+      throw new FetchError("Something went wrong");
+    });
+
+    await expect(
+      async () => await client.request("GET /v1/predictions/test-id")
+    ).rejects.toThrowError(ReplicateRequestError);
+    await expect(
+      async () => await client.request("GET /v1/predictions/test-id")
+    ).rejects.toThrowError(
+      "Failed to make request: method=GET, url=https://api.replicate.com/v1/predictions/test-id, body=undefined"
+    );
+  });
+
+  it("throws ReplicateResponseError on error status", async () => {
+    fetch.mockImplementation(
+      async () =>
+        new Response('{"status":403,"details":"Something went wrong"}', {
+          status: 403,
+          statusText: "Unauthorized",
+        })
+    );
+
+    await expect(
+      async () => await client.request("GET /v1/predictions/test-id")
+    ).rejects.toThrowError(ReplicateResponseError);
+    await expect(
+      async () => await client.request("GET /v1/predictions/test-id")
+    ).rejects.toThrowError(
+      "403 Unauthorized for GET /v1/predictions/test-id: Something went wrong"
+    );
+  });
+});

lib/errors.js

@@ -1 +1,29 @@
 export class ReplicateError extends Error {}
+
+export class ReplicateRequestError extends ReplicateError {
+  method;
+  body;
+
+  constructor(url, requestInit) {
+    super(
+      `Failed to make request: method=${requestInit.method}, url=${url}, body=${requestInit.body}`
+    );
+
+    this.method = requestInit.method;
+    this.body = requestInit.body;
+  }
+}
+
+export class ReplicateResponseError extends ReplicateError {
+  status;
+
+  constructor(message, response, action) {
+    super(
+      `${response.status} ${response.statusText}${
+        action ? ` for ${action}` : ""
+      }: ${message}`
+    );
+
+    this.status = response.status;
+  }
+}