Add support for custom transformAndCheckStatus transform, and forcing json transforms

Author: aaronc-kablamo

packages/kerosene/src/fetch/transformAndCheckStatus.spec.ts

@@ -3,7 +3,9 @@ import ClientError from "./clientError";
 import HttpError from "./httpError";
 import ServerError from "./serverError";
 import _transform from "./transform";
-import transformAndCheckStatus from "./transformAndCheckStatus";
+import transformAndCheckStatus, {
+  type TransformOptions,
+} from "./transformAndCheckStatus";
 
 jest.mock("./transform");
 const transform = _transform as unknown as jest.MockInstance<
@@ -23,6 +25,32 @@ describe("transformAndCheckStatus", () => {
     );
   });
 
+  it("should resolve as null for 204 response", async () => {
+    const transformed = null;
+    const response = {
+      status: 204,
+    } as Partial<Response> as Response;
+    when(transform).calledWith(response).mockResolvedValue(transformed);
+    await expect(transformAndCheckStatus(response)).resolves.toEqual(
+      transformed,
+    );
+  });
+
+  it("should resolve a custom transformed response for 2xx if a transform is provided", async () => {
+    const transformed = { key: "value" };
+    const customTransform = { key: "transformedValue" };
+    const response = {
+      status: 200,
+    } as Partial<Response> as Response;
+    const options = {
+      responseTransform: () => Promise.resolve(customTransform),
+    } as const satisfies TransformOptions;
+    when(transform).calledWith(response).mockResolvedValue(transformed);
+    await expect(transformAndCheckStatus(response, options)).resolves.toEqual(
+      customTransform,
+    );
+  });
+
   it("should reject with a generic Error for a non-2xx response, but transform the response anyway", async () => {
     const transformed = { error: "An Error" };
     const response = {

packages/kerosene/src/fetch/transformAndCheckStatus.ts

@@ -3,14 +3,22 @@ import HttpError from "./httpError";
 import ServerError from "./serverError";
 import transform from "./transform";
 
+export type TransformOptions<T = unknown> = {
+  responseTransform?: (response: Response) => Promise<T>;
+};
+
 /**
  * Transforms the response, rejecting if the status is not 2xx
  * @param response
+ * @param options
  */
 export default function transformAndCheckStatus<T = unknown>(
   response: Response,
-): Promise<T> {
-  return transform(response).then((transformed) => {
+  options?: TransformOptions<T>,
+): Promise<T | null> {
+  const transformHandler = options?.responseTransform || transform;
+
+  return transformHandler(response).then((transformed) => {
     if (response.status >= 200 && response.status < 300) return transformed;
 
     if (response.status >= 400 && response.status < 500) {

packages/kerosene/src/fetch/transformJsonAndCheckStatus.spec.ts

@@ -0,0 +1,100 @@
+import { when } from "jest-when";
+import ClientError from "./clientError";
+import HttpError from "./httpError";
+import ServerError from "./serverError";
+import _transform from "./transform";
+import transformJsonAndCheckStatus from "./transformJsonAndCheckStatus";
+
+jest.mock("./transform");
+const transform = _transform as unknown as jest.MockInstance<
+  ReturnType<typeof _transform>,
+  Parameters<typeof _transform>
+>;
+
+describe("transformJsonAndCheckStatus", () => {
+  it("should resolve a transformed response for 2xx", async () => {
+    const transformed = { key: "value" };
+    const response = {
+      status: 200,
+      json: () => Promise.resolve(transformed),
+    } as Partial<Response> as Response;
+    when(transform).calledWith(response).mockResolvedValue(transformed);
+    await expect(transformJsonAndCheckStatus(response)).resolves.toEqual(
+      transformed,
+    );
+  });
+
+  it("should resolve as null for 204 response", async () => {
+    const transformed = null;
+    const response = {
+      status: 204,
+    } as Partial<Response> as Response;
+    when(transform).calledWith(response).mockResolvedValue(transformed);
+    await expect(transformJsonAndCheckStatus(response)).resolves.toEqual(
+      transformed,
+    );
+  });
+
+  it("should reject with a generic Error for a non-2xx response, but transform the response anyway", async () => {
+    const transformed = { error: "An Error" };
+    const response = {
+      status: 308,
+      statusText: "Permanent Redirect",
+      json: () => Promise.resolve(transformed),
+    } as Partial<Response> as Response;
+    when(transform).calledWith(response).mockResolvedValue(transformed);
+    await transformJsonAndCheckStatus(response).then(
+      () => {
+        throw new Error("Expected transformJsonAndCheckStatus to be rejected");
+      },
+      (error) => {
+        expect(error instanceof HttpError).toBe(true);
+        expect(error instanceof ClientError).toBe(false);
+        expect(error instanceof ServerError).toBe(false);
+        expect(error.message).toBe(response.statusText);
+        expect(error.status).toBe(response.status);
+        expect(error.response).toBe(transformed);
+      },
+    );
+  });
+
+  it("should reject with a ClientError for a 4xx response", async () => {
+    const transformed = { error: "An Error" };
+    const response = {
+      status: 404,
+      statusText: "Not Found",
+      json: () => Promise.resolve(transformed),
+    } as Partial<Response> as Response;
+    when(transform).calledWith(response).mockResolvedValue(transformed);
+    await transformJsonAndCheckStatus(response).then(
+      () => {
+        throw new Error("Expected transformJsonAndCheckStatus to be rejected");
+      },
+      (error) => {
+        expect(error instanceof ClientError).toBe(true);
+        expect(error.message).toBe(response.statusText);
+        expect(error.status).toBe(response.status);
+        expect(error.response).toBe(transformed);
+      },
+    );
+  });
+
+  it("should reject with a ServerError for a 5xx response", async () => {
+    const response = {
+      status: 500,
+      statusText: "Internal Server Error",
+      json: () => Promise.resolve(undefined),
+    } as Partial<Response> as Response;
+    when(transform).calledWith(response).mockResolvedValue(undefined);
+    await transformJsonAndCheckStatus(response).then(
+      () => {
+        throw new Error("Expected transformJsonAndCheckStatus to be rejected");
+      },
+      (error) => {
+        expect(error instanceof ServerError).toBe(true);
+        expect(error.message).toBe(response.statusText);
+        expect(error.status).toBe(response.status);
+      },
+    );
+  });
+});

packages/kerosene/src/fetch/transformJsonAndCheckStatus.ts

@@ -0,0 +1,32 @@
+import ClientError from "./clientError";
+import HttpError from "./httpError";
+import ServerError from "./serverError";
+import transform from "./transform";
+
+/**
+ * Transforms the response, rejecting if the status is not 2xx
+ * @param response
+ */
+export default function transformAndCheckStatus<T = unknown>(
+  response: Response,
+): Promise<T | null> {
+  return transform(response).then(async (originalTransformed) => {
+    // 204 statuses return null in the original transform, so keep that behaviour here
+    if (originalTransformed === null) return originalTransformed;
+
+    // Otherwise we use .json directly, to avoid incorrect transformations when Content-Type is missing
+    const transformed = await response.json();
+
+    if (response.status >= 200 && response.status < 300) return transformed;
+
+    if (response.status >= 400 && response.status < 500) {
+      throw new ClientError(response.statusText, response.status, transformed);
+    }
+
+    if (response.status >= 500 && response.status < 600) {
+      throw new ServerError(response.statusText, response.status, transformed);
+    }
+
+    throw new HttpError(response.statusText, response.status, transformed);
+  });
+}