feat(openapi-fetch): Align tests and vars with feedback

Author: Carson Bruce

packages/openapi-fetch/src/index.js

@@ -34,7 +34,7 @@ export default function createClient(clientOptions) {
   } = { ...clientOptions };
   requestInitExt = supportsRequestInitExt() ? requestInitExt : undefined;
   baseUrl = removeTrailingSlash(baseUrl);
-  const middlewares = [];
+  const globalMiddlewares = [];
 
   /**
    * Per-request fetch (keeps settings created in createClient()
@@ -52,7 +52,7 @@ export default function createClient(clientOptions) {
       querySerializer: requestQuerySerializer,
       bodySerializer = globalBodySerializer ?? defaultBodySerializer,
       body,
-      middleware: fetchMiddlewares = [],
+      middleware: requestMiddlewares = [],
       ...init
     } = fetchOptions || {};
     let finalBaseUrl = baseUrl;
@@ -100,11 +100,8 @@ export default function createClient(clientOptions) {
       params.header,
     );
 
-    const finalMiddlewares = [
-      // Client level middleware take priority over request-level middleware
-      ...(Array.isArray(middlewares) && middlewares),
-      ...(Array.isArray(fetchMiddlewares) && fetchMiddlewares),
-    ];
+    // Client level middleware take priority over request-level middleware
+    const finalMiddlewares = [...globalMiddlewares, ...requestMiddlewares];
 
     const requestInit = {
       redirect: "follow",
@@ -302,15 +299,15 @@ export default function createClient(clientOptions) {
         if (typeof m !== "object" || !("onRequest" in m || "onResponse" in m || "onError" in m)) {
           throw new Error("Middleware must be an object with one of `onRequest()`, `onResponse() or `onError()`");
         }
-        middlewares.push(m);
+        globalMiddlewares.push(m);
       }
     },
     /** Unregister middleware */
     eject(...middleware) {
       for (const m of middleware) {
-        const i = middlewares.indexOf(m);
+        const i = globalMiddlewares.indexOf(m);
         if (i !== -1) {
-          middlewares.splice(i, 1);
+          globalMiddlewares.splice(i, 1);
         }
       }
     },
@@ -670,13 +667,3 @@ export function removeTrailingSlash(url) {
   }
   return url;
 }
-
-/**
- * Validate middleware object
- * @type {import("./index.js").validateMiddleware}
- */
-export function validateMiddleware(middleware) {
-  if (typeof middleware !== "object" || !("onRequest" in middleware || "onResponse" in v || "onError" in middleware)) {
-    throw new Error("Middleware must be an object with one of `onRequest()`, `onResponse() or `onError()`");
-  }
-}

packages/openapi-fetch/test/middleware/middleware.test.ts

@@ -194,16 +194,33 @@ test("executes in expected order", async () => {
         return request;
       },
       onResponse({ response }) {
-        response.headers.set("step", "C");
-        return response;
+        const headers = new Headers(response.headers);
+        headers.set("step", "C");
+        if (response.headers.get("step") === "D") {
+          return new Response(response.body, { ...response, headers });
+        }
       },
     },
   );
 
-  const { response } = await client.GET("/posts/{id}", { params: { path: { id: 123 } } });
+  const { response } = await client.GET("/posts/{id}", {
+    params: { path: { id: 123 } },
+    middleware: [
+      {
+        onRequest({ request }) {
+          request.headers.set("step", "D");
+          return request;
+        },
+        onResponse({ response }) {
+          response.headers.set("step", "D");
+          return response;
+        },
+      },
+    ],
+  });
 
   // assert requests ended up on step C (array order)
-  expect(actualRequest.headers.get("step")).toBe("C");
+  expect(actualRequest.headers.get("step")).toBe("D");
 
   // assert responses ended up on step A (reverse order)
   expect(response.headers.get("step")).toBe("A");
@@ -506,117 +523,22 @@ test("skips onResponse handlers when response is returned from onRequest", async
   expect(onResponseCalled).toBe(false);
 });
 
-test('it should enable a middleware to be added via the "middleware" request option', async () => {
-  let actualRequest = new Request("https://nottherealurl.fake");
-  const client = createObservedClient<paths>({}, async (req) => {
-    actualRequest = new Request(req);
-    return Response.json({});
-  });
-
-  await client.GET("/posts/{id}", {
-    params: { path: { id: 123 } },
-    middleware: [
-      {
-        async onRequest({ request }) {
-          return new Request("https://foo.bar/api/v1", {
-            ...request,
-            method: "OPTIONS",
-            headers: { foo: "bar" },
-          });
-        },
-      },
-    ],
-  });
-
-  expect(actualRequest.url).toBe("https://foo.bar/api/v1");
-  expect(actualRequest.method).toBe("OPTIONS");
-  expect(actualRequest.headers.get("foo")).toBe("bar");
-});
-
 test("add middleware at the request level", async () => {
-  let actualRequest = new Request("https://nottherealurl.fake");
-  const client = createObservedClient<paths>({}, async (req) => {
-    actualRequest = new Request(req);
-    return Response.json({});
-  });
-
-  await client.GET("/posts/{id}", {
-    params: { path: { id: 123 } },
-    middleware: [
-      {
-        async onRequest({ request }) {
-          return new Request("https://foo.bar/api/v1", {
-            ...request,
-            method: "OPTIONS",
-            headers: { foo: "bar" },
-          });
-        },
-      },
-    ],
-  });
-
-  expect(actualRequest.url).toBe("https://foo.bar/api/v1");
-  expect(actualRequest.method).toBe("OPTIONS");
-  expect(actualRequest.headers.get("foo")).toBe("bar");
-});
-
-test("executes a middleware at the client and request request level in the correct orders", async () => {
-  let actualRequest = new Request("https://nottherealurl.fake");
-  const client = createObservedClient<paths>({}, async (req) => {
-    actualRequest = new Request(req);
-    return Response.json({});
+  const customResponse = Response.json({});
+  const client = createObservedClient<paths>({}, async () => {
+    throw new Error("unexpected call to fetch");
   });
-  // this middleware passes along the “step” header
-  // for both requests and responses, but first checks if
-  // it received the end result of the previous middleware step
-  client.use(
-    {
-      async onRequest({ request }) {
-        request.headers.set("step", "A");
-        return request;
-      },
-      async onResponse({ response }) {
-        if (response.headers.get("step") === "B") {
-          const headers = new Headers(response.headers);
-          headers.set("step", "A");
-          return new Response(response.body, { ...response, headers });
-        }
-      },
-    },
-    {
-      async onRequest({ request }) {
-        request.headers.set("step", "B");
-        return request;
-      },
-      async onResponse({ response }) {
-        const headers = new Headers(response.headers);
-        headers.set("step", "B");
-        if (response.headers.get("step") === "C") {
-          return new Response(response.body, { ...response, headers });
-        }
-      },
-    },
-  );
 
   const { response } = await client.GET("/posts/{id}", {
     params: { path: { id: 123 } },
     middleware: [
       {
-        onRequest({ request }) {
-          request.headers.set("step", "C");
-          return request;
-        },
-        onResponse({ response }) {
-          response.headers.set("step", "C");
-          return response;
+        async onRequest() {
+          return customResponse;
         },
       },
     ],
   });
 
-  // assert requests ended up on step C (array order)
-  expect(actualRequest.headers.get("step")).toBe("C");
-
-  // assert responses ended up on step A (reverse order)
-  expect(response.headers.get("step")).toBe("A");
+  expect(response).toBe(customResponse);
 });