Provide unserialized body to onRequest middleware

packages/openapi-fetch/src/index.d.ts

@@ -150,7 +150,10 @@ export interface MiddlewareCallbackParams {
 }
 
 type MiddlewareOnRequest = (
-  options: MiddlewareCallbackParams,
+  options: MiddlewareCallbackParams & {
+    /** body as provided to the original openapi-fetch function, pre-serialization */
+    body?: unknown;
+  },
 ) => void | Request | Response | undefined | Promise<Request | Response | undefined | void>;
 type MiddlewareOnResponse = (
   options: MiddlewareCallbackParams & { response: Response },

packages/openapi-fetch/src/index.js

@@ -143,6 +143,7 @@ export default function createClient(clientOptions) {
             request,
             schemaPath,
             params,
+            body,
             options,
             id,
           });

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

@@ -1,5 +1,5 @@
 import { assertType, expect, expectTypeOf, test } from "vitest";
-import type { Middleware, MiddlewareCallbackParams } from "../../src/index.js";
+import type { Middleware, MiddlewareCallbackParams, MiddlewareOnRequest } from "../../src/index.js";
 import { createObservedClient } from "../helpers.js";
 import type { paths } from "./schemas/middleware.js";
 
@@ -297,19 +297,22 @@ test("receives OpenAPI options passed in from parent", async () => {
 
   let receivedPath = "";
   let receivedParams: MiddlewareCallbackParams["params"] = {};
+  let receivedBody: unknown = {};
 
   const client = createObservedClient<paths>();
   client.use({
-    onRequest({ schemaPath, params }) {
+    onRequest({ schemaPath, params, body }) {
       receivedPath = schemaPath;
       receivedParams = params;
+      receivedBody = body;
       return undefined;
     },
   });
   await client.PUT(pathname, tagData);
 
   expect(receivedPath).toBe(pathname);
   expect(receivedParams).toEqual(tagData.params);
+  expect(receivedBody).toEqual(tagData.body);
 });
 
 test("can be skipped without interrupting request", async () => {