@shipworthy/openapi-fetch 0.0.2 → 1.0.0

package/README.md

@@ -14,12 +14,14 @@ To generate the `paths` type, install the CLI and its TypeScript generator as de
 bun add -d @shipworthy/openapi-cli @shipworthy/openapi-typescript
 ```
 
-These packages are build-time tooling; the fetch client has no runtime or peer dependencies.
+These packages are build-time tooling. The fetch package has no runtime or peer dependencies.
 
 Requirements:
 
-- **No dependencies or peer dependencies.**
-- **ESM and CommonJS.** Published packages contain compiled JavaScript in both formats with matching `.d.ts` and `.d.cts` declarations in `dist/`; no TypeScript transpilation of `node_modules` is needed. Declarations type-check with TypeScript 5.0 and later.
+- **No runtime or peer dependencies.** Compile optional case mappings with `@shipworthy/openapi-typescript` at build time.
+- **ESM and CommonJS.** Both runtime entries contain both formats with matching `.d.ts` and
+  `.d.cts` declarations in `dist/`; no TypeScript transpilation of `node_modules` is needed.
+  Declarations type-check with TypeScript 5.0 and later.
 - **No Node.js engine requirement for the client.** The code-generation CLI needs Node.js `>=22.19.0`, or Bun with `bunx --bun`.
 - **Fetch API globals.** The client uses `fetch`, `Request`, `Response`, `Headers`, `FormData`, and `URLSearchParams` from `globalThis`, so it runs in browsers, Bun, Deno, and Node.js 18+. To use a different implementation, pass `fetch` and/or `Request` to `createClient`.
 - **TypeScript** with `strict` (or at least `strictNullChecks`) is recommended. Required/optional inference for `params` and `body` depends on it.
@@ -29,16 +31,16 @@ Requirements:
 ### 1. Generate types
 
 ```sh
-bunx --bun @shipworthy/openapi-cli generate typescript ./openapi.yaml -o ./src/api/schema.ts
+bunx --bun @shipworthy/openapi-cli generate typescript -i ./openapi.yaml -o ./src/api
 ```
 
-The generated file exports `paths`, `components`, and `operations` interfaces. `openapi-fetch` only needs `paths`.
+This writes `src/api/types.ts`. The generated file exports `paths`, `components`, and `operations` interfaces. `openapi-fetch` only needs `paths`.
 
 ### 2. Create a client and call it
 
 ```ts
 import createClient from "@shipworthy/openapi-fetch";
-import type { paths } from "./api/schema";
+import type { paths } from "./api/types";
 
 const client = createClient<paths>({ baseUrl: "https://api.example.com/v1" });
 
@@ -85,7 +87,7 @@ Each call returns `Promise<FetchResponse>`, a discriminated union:
 
 ## API reference
 
-The package's single entry point (`@shipworthy/openapi-fetch`) provides these exports.
+The main entry point (`@shipworthy/openapi-fetch`) provides these exports.
 
 ### `createClient<Paths, Media>(options?)` (default and named export)
 
@@ -111,16 +113,17 @@ function createClient<Paths extends {}, Media extends MediaType = MediaType>(
 | `querySerializer` | `QuerySerializer \| QuerySerializerOptions` | form/explode for arrays, deepObject/explode for objects | Global query string serialization (see [Query serialization](#query-serialization)).                                                                                                                     |
 | `bodySerializer`  | `BodySerializer`                            | `defaultBodySerializer`                                 | Global request body serializer.                                                                                                                                                                          |
 | `pathSerializer`  | `PathSerializer`                            | `defaultPathSerializer`                                 | Global path template serializer.                                                                                                                                                                         |
+| `caseMapping`     | `CaseMapping`                               | none                                                    | Installs schema-based casing middleware for every request and parsed result.                                                                                                                             |
 | `requestInitExt`  | `Record<string, unknown>`                   | `undefined`                                             | Passed as the second argument to `fetch`. It is only used on Node.js 18+ with undici (detected through `process.versions.undici`) and ignored elsewhere, including Bun. Example: an undici `dispatcher`. |
 
 #### `Client<Paths, Media>`
 
-| Member                                                                          | Description                                                                                                                                                                                            |
-| ------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ |
-| `GET(url, init?)`, `PUT`, `POST`, `DELETE`, `OPTIONS`, `HEAD`, `PATCH`, `TRACE` | Call an endpoint. `url` must be a path in `Paths` that defines that method. Use the template form, such as `"/pets/{petId}"`, not a pre-filled URL.                                                    |
-| `request(method, url, init?)`                                                   | Same as above with a lowercase `HttpMethod` (`"get"`, `"post"`, ...). The method is uppercased at runtime.                                                                                             |
-| `use(...middleware)`                                                            | Register client-level middleware. Falsy entries are skipped. Throws `Error("Middleware must be an object with one of `onRequest()`, `onResponse() or `onError()`")` for anything else that is invalid. |
-| `eject(...middleware)`                                                          | Unregister middleware by reference.                                                                                                                                                                    |
+| Member                                                                          | Description                                                                                                                                         |
+| ------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `GET(url, init?)`, `PUT`, `POST`, `DELETE`, `OPTIONS`, `HEAD`, `PATCH`, `TRACE` | Call an endpoint. `url` must be a path in `Paths` that defines that method. Use the template form, such as `"/pets/{petId}"`, not a pre-filled URL. |
+| `request(method, url, init?)`                                                   | Same as above with a lowercase `HttpMethod` (`"get"`, `"post"`, ...). The method is uppercased at runtime.                                          |
+| `use(...middleware)`                                                            | Register client-level middleware. Falsy entries are skipped. Invalid objects throw `Error("Middleware must be an object with a supported hook")`.   |
+| `eject(...middleware)`                                                          | Unregister middleware by reference.                                                                                                                 |
 
 The `init` argument is required when the operation has required parameters or a required body. Otherwise it is optional.
 
@@ -170,7 +173,7 @@ import createClient, {
   createPathBasedClient,
   wrapAsPathBasedClient,
 } from "@shipworthy/openapi-fetch";
-import type { paths } from "./api/schema";
+import type { paths } from "./api/types";
 
 const api = createPathBasedClient<paths>({ baseUrl: "https://api.example.com/v1" });
 const { data, error } = await api["/pets/{petId}"].GET({ params: { path: { petId: "123" } } });
@@ -209,7 +212,8 @@ client.use(auth);
 // later: client.eject(auth);
 ```
 
-A `Middleware` is an object with at least one of `onRequest`, `onResponse`, or `onError`. Each hook receives `MiddlewareCallbackParams`:
+A `Middleware` has at least one of `onRequestInit`, `onRequest`, `onError`, `onResponse`, or
+`onResult`. The existing HTTP hooks receive `MiddlewareCallbackParams`:
 
 | Field        | Description                                                                                                   |
 | ------------ | ------------------------------------------------------------------------------------------------------------- |
@@ -223,6 +227,10 @@ A `Middleware` is an object with at least one of `onRequest`, `onResponse`, or `
 
 The order of the hooks and their valid return values:
 
+- **`onRequestInit`** runs before path, query, header, cookie, and body serialization, in
+  registration order. It receives `method`, `schemaPath`, `{ params, body }` as `input`, and
+  `headers` merged from client, request, and parameter headers. Return a complete replacement
+  `{ params, body }`, or `undefined` to keep the input. Custom serializers receive the result.
 - **`onRequest`** runs in registration order, client-level first and then per-request `middleware`.
   - Return a `Request` to replace the request.
   - Return a `Response` to skip `fetch`, the remaining `onRequest` hooks, and **all** `onResponse` hooks. The returned `Response` is used as-is: no `onResponse` hook runs for it, including hooks registered before the one that returned it. This matches upstream openapi-fetch.
@@ -237,6 +245,56 @@ The order of the hooks and their valid return values:
   - Return a `Response` to replace it.
   - Return `undefined` to keep it.
   - Any other truthy value throws `Error("onResponse: must return new Response() when modifying the response")`.
+- **`onResult`** runs after response parsing, in reverse order. It receives the parsed `result`,
+  original `method` and `schemaPath`, and the final `Response`. Return a `data` and/or `error`
+  update, or `undefined` to keep the parsed values. It also runs for a synthetic `Response`
+  returned by `onRequest`, a response recovered by `onError`, and empty bodies. It cannot replace
+  `result.response`.
+
+### Schema-based case mapping
+
+Pass a `caseMapping` to `createClient` to convert app-facing names in typed path, query,
+header, and cookie parameters and JSON request bodies to the names declared by OpenAPI. It
+converts parsed JSON success and error bodies back before returning `data` or `error`. The raw
+`Response` and dictionary keys retain their wire spelling. Other response parsing modes leave
+successful data unchanged.
+
+Only fields declared by the selected schema are renamed. Undeclared fields keep their API
+spelling, and an error response with no matching status schema or `default` response is returned
+without conversion. String values that happen to name fields also keep their API spelling, for
+example a JSON Pointer such as `errors[].pointer: "/slot_id"`.
+
+```ts
+import createClient from "@shipworthy/openapi-fetch";
+import { caseMapping } from "./generated/case-mapping";
+import type { paths } from "./generated/types";
+
+const client = createClient<paths>({ baseUrl: "https://api.example.com", caseMapping });
+```
+
+For manual registration, import `createCaseMappingMiddleware` from
+`@shipworthy/openapi-fetch/middleware/transform-casing` and call
+`client.use(createCaseMappingMiddleware(caseMapping))`.
+
+The mapping must come from the same OpenAPI document and camelCase naming rule as `paths`.
+At build time, `buildCaseMapping(parsedService)` from
+`@shipworthy/openapi-typescript/case-mapping` returns an
+`Effect<CaseMapping, CaseMappingGenerationError>`. Include the resulting plain object in
+generated code and pass it to the client:
+
+```ts
+import { buildCaseMapping } from "@shipworthy/openapi-typescript/case-mapping";
+import { decode } from "@shipworthy/openapi-transformer";
+import { Effect } from "effect";
+
+const caseMapping = await Effect.runPromise(
+  decode(document).pipe(Effect.flatMap(buildCaseMapping)),
+);
+```
+
+`openapi generate tanstack-query --camel-case` generates the matching types and embeds this
+mapping automatically. `openapi generate typescript --camel-case` without the `tanstack-query`
+plugin generates types only; it does not install runtime conversion.
 
 ### Headers
 
@@ -482,20 +540,21 @@ function removeTrailingSlash(url: string): string; // removes one trailing "/"
 
 Client and request types:
 
-| Type                                                                                                    | Purpose                                               |
-| ------------------------------------------------------------------------------------------------------- | ----------------------------------------------------- |
-| `Client<Paths, Media>`                                                                                  | Return type of `createClient`.                        |
-| `ClientOptions`                                                                                         | Options for `createClient`.                           |
-| `PathBasedClient<Paths, Media>`, `ClientForPath<PathInfo, Media>`                                       | Path-based client shapes.                             |
-| `ClientMethod`, `ClientRequestMethod`                                                                   | Signatures of `GET`/`POST`/... and of `request`.      |
-| `FetchOptions<Op>`, `RequestOptions<Op>`, `MaybeOptionalInit<PathItem, Method>`                         | Shape of the `init` argument for an operation.        |
-| `ParamsOption<Op>`, `RequestBodyOption<Op>`, `DefaultParamsOption`                                      | The `params` and `body` parts of `init`.              |
-| `FetchResponse<Op, Init, Media>`                                                                        | The `{ data, error, response }` union.                |
-| `ParseAs`, `ParseAsResponse<T, Options>`                                                                | `parseAs` values and the resulting `data` type.       |
-| `HeadersOptions`, `QuerySerializer<T>`, `QuerySerializerOptions`, `BodySerializer<T>`, `PathSerializer` | Option types.                                         |
-| `Middleware`, `MiddlewareCallbackParams`, `MiddlewareRequestParams`, `MergedOptions`                    | Middleware types.                                     |
-| `ClientPathsWithMethod<Client, Method>`                                                                 | The paths of a client instance that support `Method`. |
-| `MethodResponse<Client, Method, Path, Options?>`                                                        | The non-nullable `data` type for a call.              |
+| Type                                                                                                                                                                                        | Purpose                                                   |
+| ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------- |
+| `Client<Paths, Media>`                                                                                                                                                                      | Return type of `createClient`.                            |
+| `ClientOptions`                                                                                                                                                                             | Options for `createClient`.                               |
+| `PathBasedClient<Paths, Media>`, `ClientForPath<PathInfo, Media>`                                                                                                                           | Path-based client shapes.                                 |
+| `ClientMethod`, `ClientRequestMethod`                                                                                                                                                       | Signatures of `GET`/`POST`/... and of `request`.          |
+| `FetchOptions<Op>`, `RequestOptions<Op>`, `MaybeOptionalInit<PathItem, Method>`                                                                                                             | Shape of the `init` argument for an operation.            |
+| `ParamsOption<Op>`, `RequestBodyOption<Op>`, `DefaultParamsOption`                                                                                                                          | The `params` and `body` parts of `init`.                  |
+| `FetchResponse<Op, Init, Media>`                                                                                                                                                            | The `{ data, error, response }` union.                    |
+| `ParseAs`, `ParseAsResponse<T, Options>`                                                                                                                                                    | `parseAs` values and the resulting `data` type.           |
+| `HeadersOptions`, `QuerySerializer<T>`, `QuerySerializerOptions`, `BodySerializer<T>`, `PathSerializer`                                                                                     | Option types.                                             |
+| `Middleware`, `MiddlewareCallbackParams`, `MiddlewareRequestInitParams`, `MiddlewareRequestInput`, `MiddlewareRequestParams`, `MiddlewareResult`, `MiddlewareResultParams`, `MergedOptions` | Middleware types.                                         |
+| `CaseMapping` (from `./middleware/transform-casing`)                                                                                                                                        | Schema mapping accepted by `createCaseMappingMiddleware`. |
+| `ClientPathsWithMethod<Client, Method>`                                                                                                                                                     | The paths of a client instance that support `Method`.     |
+| `MethodResponse<Client, Method, Path, Options?>`                                                                                                                                            | The non-nullable `data` type for a call.                  |
 
 Schema helpers:
 
@@ -557,7 +616,7 @@ Without the flag, the types are unchanged.
 ## Key facts (for AI agents)
 
 - Import: `import createClient from "@shipworthy/openapi-fetch"`, a **default** export, also available as the named export `createClient`. Compiled ESM and CommonJS with `.d.ts`/`.d.cts` declarations and no dependencies.
-- Typical setup: `createClient<paths>({ baseUrl })`, where `paths` comes from `openapi generate typescript <schema> -o schema.ts`.
+- Typical setup: `createClient<paths>({ baseUrl })`, where `paths` comes from `openapi generate typescript -i <schema> -o <dir>` (`<dir>/types.ts`).
 - Call signature: `client.GET("/template/{param}", { params: { path, query, header, cookie }, body, headers, parseAs, signal })`. Methods are uppercase: `GET PUT POST DELETE OPTIONS HEAD PATCH TRACE`. `client.request("get", path, init)` is also available.
 - Result: `{ data, error, response }`. The promise does not reject on 4XX/5XX. It rejects on network errors, invalid JSON in a successful response that has a `Content-Length`, and misbehaving middleware.
 - Default serialization:
@@ -567,7 +626,8 @@ Without the flag, the types are unchanged.
   - Query arrays repeat the key (`a=1&a=2`), and query objects use `deepObject` (`o[x]=1`).
 - Header precedence: client `headers` < request `headers` < `params.header`. `null` deletes a header. `headers` accepts a plain object, a `Headers` instance, or `[name, value]` tuples.
 - `params.cookie` is sent as a `Cookie` header (form/explode, URI-encoded), appended to any existing `Cookie` header.
-- Middleware: `client.use({ onRequest, onResponse, onError })`. `onRequest` runs in order; `onResponse` and `onError` run in reverse.
+- Middleware: `client.use({ onRequestInit, onRequest, onError, onResponse, onResult })`.
+  Input and request hooks run in order; error, response, and parsed-result hooks run in reverse.
 - Path-based alternative: `createPathBasedClient<paths>(opts)["/pets/{id}"].GET(init)`.
 - Response data is not validated at runtime.
 

package/dist/index.cjs

@@ -2,7 +2,7 @@ Object.defineProperties(exports, {
 	__esModule: { value: true },
 	[Symbol.toStringTag]: { value: "Module" }
 });
-//#region src/headers.ts
+// src/headers.ts
 /** Iterate any `HeadersOptions` form (plain object, `Headers`, or `[name, value]` tuples) as entries */
 function headerEntries(h) {
 	if (h instanceof Headers) return h.entries();
@@ -20,8 +20,166 @@ function mergeHeaders(...allHeaders) {
 	}
 	return finalHeaders;
 }
-//#endregion
-//#region src/serializers/body.ts
+// src/middleware/transform-casing.ts
+function expandSchemas(schemas, mapping, visited = /* @__PURE__ */ new Set()) {
+	return schemas.flatMap((schema) => {
+		const nested = schema.variants ?? [];
+		if (!schema.ref || visited.has(schema.ref)) return [schema, ...expandSchemas(nested, mapping, visited)];
+		const referenced = mapping.schemas?.[schema.ref];
+		const next = new Set(visited).add(schema.ref);
+		return [schema, ...expandSchemas(referenced ? [referenced, ...nested] : nested, mapping, next)];
+	});
+}
+function createConverter(mapping) {
+	const schemaIds = /* @__PURE__ */ new WeakMap();
+	const plans = /* @__PURE__ */ new Map();
+	let nextId = 0;
+	function planFor(schemas, direction) {
+		if (schemas.length === 0) return void 0;
+		const key = `${direction}:${schemas.map((schema) => {
+			let id = schemaIds.get(schema);
+			if (id === void 0) {
+				id = ++nextId;
+				schemaIds.set(schema, id);
+			}
+			return id;
+		}).join(",")}`;
+		const existing = plans.get(key);
+		if (existing) return existing;
+		const expanded = expandSchemas(schemas, mapping);
+		const fields = /* @__PURE__ */ new Map();
+		for (const schema of expanded) for (const [wireName, field] of Object.entries(schema.properties ?? {})) {
+			const sourceName = direction === "toApi" ? field.name : wireName;
+			const targetName = direction === "toApi" ? wireName : field.name;
+			const current = fields.get(sourceName);
+			if (current) {
+				if (current.name !== targetName) throw new Error(`Conflicting case mapping for ${sourceName}`);
+				if (field.schema) current.schemas.push(field.schema);
+			} else fields.set(sourceName, {
+				name: targetName,
+				schemas: field.schema ? [field.schema] : []
+			});
+		}
+		const plan = {
+			expanded,
+			fields,
+			declared: new Set(expanded.flatMap((schema) => schema.declared ?? [])),
+			patterns: expanded.flatMap((schema) => Object.entries(schema.patternProperties ?? {}).map(([pattern, nested]) => ({
+				regex: new RegExp(pattern),
+				schema: nested
+			}))),
+			additional: expanded.flatMap((schema) => schema.additionalProperties ? [schema.additionalProperties] : []),
+			prefixLength: expanded.reduce((max, schema) => Math.max(max, schema.prefixItems?.length ?? 0), 0)
+		};
+		plans.set(key, plan);
+		return plan;
+	}
+	function itemPlan(plan, index, direction) {
+		if (index >= plan.prefixLength) {
+			if (plan.items === void 0) plan.items = planFor(plan.expanded.flatMap((schema) => schema.items ? [schema.items] : []), direction) ?? null;
+			return plan.items ?? void 0;
+		}
+		const prefixItems = plan.prefixItems ??= [];
+		if (prefixItems[index] === void 0) prefixItems[index] = planFor(plan.expanded.flatMap((schema) => {
+			const prefix = schema.prefixItems;
+			const item = prefix && index < prefix.length ? prefix[index] : schema.items;
+			return item ? [item] : [];
+		}), direction) ?? null;
+		return prefixItems[index] ?? void 0;
+	}
+	function convertWithPlan(value, plan, direction) {
+		if (!plan || value === null || value === void 0) return value;
+		if (Array.isArray(value)) return value.map((item, index) => convertWithPlan(item, itemPlan(plan, index, direction), direction));
+		if (typeof value !== "object") return value;
+		const prototype = Object.getPrototypeOf(value);
+		if (prototype !== Object.prototype && prototype !== null) return value;
+		const convertedNames = /* @__PURE__ */ new Set();
+		const entries = Object.entries(value).map(([name, item]) => {
+			const field = plan.fields.get(name);
+			const matched = [];
+			let hasPattern = false;
+			for (const pattern of plan.patterns) if (pattern.regex.test(name)) {
+				hasPattern = true;
+				if (pattern.schema) matched.push(pattern.schema);
+			}
+			let nested;
+			if (matched.length > 0) nested = planFor([...field?.schemas ?? [], ...matched], direction);
+			else if (field) {
+				if (field.nested === void 0) field.nested = planFor(field.schemas, direction) ?? null;
+				nested = field.nested ?? void 0;
+			} else if (!plan.declared.has(name) && !hasPattern) {
+				if (plan.additionalPlan === void 0) plan.additionalPlan = planFor(plan.additional, direction) ?? null;
+				nested = plan.additionalPlan ?? void 0;
+			}
+			const targetName = field?.name ?? name;
+			if (convertedNames.has(targetName)) throw new Error(`Conflicting case mapping for ${targetName}`);
+			convertedNames.add(targetName);
+			return [targetName, convertWithPlan(item, nested, direction)];
+		});
+		return Object.fromEntries(entries);
+	}
+	return (value, schemas, direction) => {
+		if (schemas.length === 0 || value === null || value === void 0) return value;
+		return convertWithPlan(value, planFor(schemas, direction), direction);
+	};
+}
+function isJsonMediaType(mediaType) {
+	return mediaType === "application/json" || mediaType.endsWith("+json");
+}
+function mediaSchema(media, contentType) {
+	if (!media) return void 0;
+	const type = contentType?.split(";", 1)[0]?.trim().toLowerCase();
+	if (type && !isJsonMediaType(type)) return void 0;
+	const entries = Object.entries(media).filter(([name]) => isJsonMediaType(name.toLowerCase()));
+	const exact = entries.find(([name]) => name.toLowerCase() === type);
+	if (exact) return exact[1] ?? void 0;
+	const json = entries.find(([name]) => name.toLowerCase() === "application/json");
+	if (json) return json[1] ?? void 0;
+	return entries.length === 1 ? entries[0]?.[1] ?? void 0 : void 0;
+}
+function responseMedia(operation, response) {
+	const responses = operation.responses;
+	if (!responses) return void 0;
+	const status = String(response.status);
+	const range = `${status[0]}XX`;
+	return mediaSchema(Object.hasOwn(responses, status) ? responses[status] : Object.hasOwn(responses, range) ? responses[range] : responses.default, response.headers.get("content-type") ?? void 0);
+}
+function convertRequest(input, operation, convertValue, headers) {
+	const parameters = operation.parameters;
+	const params = input.params;
+	const bodySchema = mediaSchema(operation.requestBodies, headers.get("content-type") ?? void 0);
+	return {
+		params: parameters ? {
+			...params,
+			path: convertValue(params.path, parameters.path ? [parameters.path] : [], "toApi"),
+			query: convertValue(params.query, parameters.query ? [parameters.query] : [], "toApi"),
+			header: convertValue(params.header, parameters.header ? [parameters.header] : [], "toApi"),
+			cookie: convertValue(params.cookie, parameters.cookie ? [parameters.cookie] : [], "toApi")
+		} : params,
+		body: bodySchema && input.body !== void 0 ? convertValue(input.body, [bodySchema], "toApi") : input.body
+	};
+}
+/** Convert generated camelCase values at the openapi-fetch request and result stages. */
+function createCaseMappingMiddleware(mapping) {
+	const convertValue = createConverter(mapping);
+	return {
+		onRequestInit({ method, schemaPath, input, headers }) {
+			const operation = mapping.operations?.[`${method} ${schemaPath}`];
+			return operation ? convertRequest(input, operation, convertValue, headers) : void 0;
+		},
+		onResult({ method, schemaPath, result, options }) {
+			const operation = mapping.operations?.[`${method} ${schemaPath}`];
+			if (!operation) return;
+			const schema = responseMedia(operation, result.response);
+			if (!schema) return;
+			return {
+				...options.parseAs === "json" && result.data !== void 0 ? { data: convertValue(result.data, [schema], "fromApi") } : {},
+				...result.error !== void 0 ? { error: convertValue(result.error, [schema], "fromApi") } : {}
+			};
+		}
+	};
+}
+// src/serializers/body.ts
 /** Serialize body object to string */
 function defaultBodySerializer(body, headers) {
 	if (body instanceof FormData) return body;
@@ -30,8 +188,7 @@ function defaultBodySerializer(body, headers) {
 	}
 	return JSON.stringify(body);
 }
-//#endregion
-//#region src/serializers/param.ts
+// src/serializers/param.ts
 /** Serialize primitive params to string */
 function serializePrimitiveParam(name, value, options) {
 	if (value === void 0 || value === null) return "";
@@ -91,8 +248,7 @@ function serializeArrayParam(name, value, options) {
 	else values.push(serializePrimitiveParam(name, v, options));
 	return options.style === "label" || options.style === "matrix" ? `${joiner}${values.join(joiner)}` : values.join(joiner);
 }
-//#endregion
-//#region src/serializers/cookie.ts
+// src/serializers/cookie.ts
 /**
 * Serialize cookie params to a `Cookie` header value using the OpenAPI default
 * (style: form, explode: true). Arrays repeat the name, objects emit one pair per key,
@@ -114,8 +270,7 @@ function serializeCookieParams(cookieParams) {
 	}
 	return pairs.join("; ");
 }
-//#endregion
-//#region src/serializers/path.ts
+// src/serializers/path.ts
 const PATH_PARAM_RE = /\{[^{}]+\}/g;
 /**
 * Handle different OpenAPI 3.x serialization styles
@@ -162,8 +317,7 @@ function defaultPathSerializer(pathname, pathParams) {
 	}
 	return nextURL;
 }
-//#endregion
-//#region src/serializers/query.ts
+// src/serializers/query.ts
 /** Serialize query params to string */
 function createQuerySerializer(options) {
 	return function querySerializer(queryParams) {
@@ -195,8 +349,7 @@ function createQuerySerializer(options) {
 		return search.join("&");
 	};
 }
-//#endregion
-//#region src/serializers/url.ts
+// src/serializers/url.ts
 /** Construct URL string from baseUrl and handle path and query params */
 function createFinalURL(pathname, options) {
 	let finalURL = `${options.baseUrl}${pathname}`;
@@ -211,8 +364,7 @@ function removeTrailingSlash(url) {
 	if (url.endsWith("/")) return url.substring(0, url.length - 1);
 	return url;
 }
-//#endregion
-//#region src/client.ts
+// src/client.ts
 function supportsRequestInitExt() {
 	const nodeProcess = globalThis.process;
 	return typeof nodeProcess === "object" && Number.parseInt(nodeProcess?.versions?.node?.substring(0, 2) ?? "") >= 18 && nodeProcess?.versions?.undici;
@@ -225,15 +377,16 @@ function randomID() {
 * Create an openapi-fetch client.
 */
 function createClient(clientOptions) {
-	let { baseUrl = "", Request: CustomRequest = globalThis.Request, fetch: baseFetch = globalThis.fetch, querySerializer: globalQuerySerializer, bodySerializer: globalBodySerializer, pathSerializer: globalPathSerializer, headers: baseHeaders, requestInitExt, ...baseOptions } = { ...clientOptions };
+	let { baseUrl = "", Request: CustomRequest = globalThis.Request, fetch: baseFetch = globalThis.fetch, querySerializer: globalQuerySerializer, bodySerializer: globalBodySerializer, pathSerializer: globalPathSerializer, caseMapping, headers: baseHeaders, requestInitExt, ...baseOptions } = { ...clientOptions };
 	requestInitExt = supportsRequestInitExt() ? requestInitExt : void 0;
 	baseUrl = removeTrailingSlash(baseUrl);
 	const globalMiddlewares = [];
+	if (caseMapping !== void 0) globalMiddlewares.push(createCaseMappingMiddleware(caseMapping));
 	/**
 	* Per-request fetch (keeps settings created in createClient()
 	*/
 	async function coreFetch(schemaPath, fetchOptions) {
-		const { baseUrl: localBaseUrl, fetch = baseFetch, Request = CustomRequest, headers, params = {}, parseAs = "json", querySerializer: requestQuerySerializer, bodySerializer = globalBodySerializer ?? defaultBodySerializer, pathSerializer: requestPathSerializer, body, middleware: requestMiddlewares = [], ...init } = fetchOptions || {};
+		const { baseUrl: localBaseUrl, fetch = baseFetch, Request = CustomRequest, headers, params: initialParams = {}, parseAs = "json", querySerializer: requestQuerySerializer, bodySerializer = globalBodySerializer ?? defaultBodySerializer, pathSerializer: requestPathSerializer, body: initialBody, middleware: requestMiddlewares = [], ...init } = fetchOptions || {};
 		let finalBaseUrl = baseUrl;
 		if (localBaseUrl) finalBaseUrl = removeTrailingSlash(localBaseUrl) ?? baseUrl;
 		let querySerializer = typeof globalQuerySerializer === "function" ? globalQuerySerializer : createQuerySerializer(globalQuerySerializer);
@@ -242,6 +395,41 @@ function createClient(clientOptions) {
 			...requestQuerySerializer
 		});
 		const pathSerializer = requestPathSerializer || globalPathSerializer || defaultPathSerializer;
+		const finalMiddlewares = [...globalMiddlewares, ...requestMiddlewares];
+		const method = String(init.method ?? "GET").toUpperCase();
+		let id;
+		let options;
+		let params = initialParams;
+		let body = initialBody;
+		if (finalMiddlewares.length) {
+			id = randomID();
+			options = Object.freeze({
+				baseUrl: finalBaseUrl,
+				fetch,
+				parseAs,
+				querySerializer,
+				bodySerializer,
+				pathSerializer
+			});
+			for (const m of finalMiddlewares) if (m && typeof m === "object" && typeof m.onRequestInit === "function") {
+				const result = await m.onRequestInit({
+					schemaPath,
+					method,
+					input: {
+						params,
+						body
+					},
+					headers: mergeHeaders(baseHeaders, headers, params.header),
+					options,
+					id
+				});
+				if (result !== void 0) {
+					if (!result || typeof result !== "object" || !("params" in result) || !("body" in result)) throw new Error("onRequestInit: must return request input when modifying it");
+					params = result.params;
+					body = result.body;
+				}
+			}
+		}
 		const serializedBody = body === void 0 ? void 0 : bodySerializer(body, mergeHeaders(baseHeaders, headers, params.header));
 		const finalHeaders = mergeHeaders(serializedBody === void 0 || serializedBody instanceof FormData ? {} : { "Content-Type": "application/json" }, baseHeaders, headers, params.header);
 		const serializedCookies = serializeCookieParams(params.cookie);
@@ -249,7 +437,6 @@ function createClient(clientOptions) {
 			const existingCookie = finalHeaders.get("Cookie");
 			finalHeaders.set("Cookie", existingCookie ? `${existingCookie}; ${serializedCookies}` : serializedCookies);
 		}
-		const finalMiddlewares = [...globalMiddlewares, ...requestMiddlewares];
 		const requestInit = {
 			redirect: "follow",
 			...baseOptions,
@@ -257,8 +444,6 @@ function createClient(clientOptions) {
 			body: serializedBody,
 			headers: finalHeaders
 		};
-		let id;
-		let options;
 		let request = new Request(createFinalURL(schemaPath, {
 			baseUrl: finalBaseUrl,
 			params,
@@ -269,15 +454,6 @@ function createClient(clientOptions) {
 		/** Add custom parameters to Request object */
 		for (const key in init) if (!(key in request)) request[key] = init[key];
 		if (finalMiddlewares.length) {
-			id = randomID();
-			options = Object.freeze({
-				baseUrl: finalBaseUrl,
-				fetch,
-				parseAs,
-				querySerializer,
-				bodySerializer,
-				pathSerializer
-			});
 			for (const m of finalMiddlewares) if (m && typeof m === "object" && typeof m.onRequest === "function") {
 				const result = await m.onRequest({
 					request,
@@ -346,14 +522,15 @@ function createClient(clientOptions) {
 		}
 		const finalResponse = response;
 		const contentLength = finalResponse.headers.get("Content-Length");
-		if (finalResponse.status === 204 || request.method === "HEAD" || contentLength === "0" && !finalResponse.headers.get("Transfer-Encoding")?.includes("chunked")) return finalResponse.ok ? {
+		let parsedResult;
+		if (finalResponse.status === 204 || request.method === "HEAD" || contentLength === "0" && !finalResponse.headers.get("Transfer-Encoding")?.includes("chunked")) parsedResult = finalResponse.ok ? {
 			data: void 0,
 			response: finalResponse
 		} : {
 			error: void 0,
 			response: finalResponse
 		};
-		if (finalResponse.ok) {
+		else if (finalResponse.ok) {
 			const getResponseData = async () => {
 				if (parseAs === "stream") return finalResponse.body;
 				if (parseAs === "json" && !contentLength) {
@@ -362,24 +539,50 @@ function createClient(clientOptions) {
 				}
 				return await finalResponse[parseAs]();
 			};
-			return {
+			parsedResult = {
 				data: await getResponseData(),
 				response: finalResponse
 			};
+		} else {
+			const raw = await finalResponse.text();
+			if (!raw) parsedResult = {
+				error: void 0,
+				response: finalResponse
+			};
+			else {
+				let error = raw;
+				try {
+					error = JSON.parse(raw);
+				} catch {}
+				parsedResult = {
+					error,
+					response: finalResponse
+				};
+			}
 		}
-		const raw = await finalResponse.text();
-		if (!raw) return {
-			error: void 0,
-			response: finalResponse
-		};
-		let error = raw;
-		try {
-			error = JSON.parse(raw);
-		} catch {}
-		return {
-			error,
-			response: finalResponse
-		};
+		for (let index = finalMiddlewares.length - 1; index >= 0; index--) {
+			const m = finalMiddlewares[index];
+			if (m && typeof m === "object" && typeof m.onResult === "function") {
+				const update = await m.onResult({
+					request,
+					schemaPath,
+					method,
+					params,
+					options,
+					id,
+					result: parsedResult
+				});
+				if (update !== void 0) {
+					if (!update || typeof update !== "object" || Object.keys(update).some((key) => key !== "data" && key !== "error")) throw new Error("onResult: must return data and/or error when modifying the result");
+					parsedResult = {
+						...parsedResult,
+						...update,
+						response: finalResponse
+					};
+				}
+			}
+		}
+		return parsedResult;
 	}
 	return {
 		request(method, url, init) {
@@ -448,7 +651,7 @@ function createClient(clientOptions) {
 		use(...middleware) {
 			for (const m of middleware) {
 				if (!m) continue;
-				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()`");
+				if (typeof m !== "object" || !("onRequestInit" in m || "onRequest" in m || "onResponse" in m || "onError" in m || "onResult" in m)) throw new Error("Middleware must be an object with a supported hook");
 				globalMiddlewares.push(m);
 			}
 		},
@@ -461,8 +664,7 @@ function createClient(clientOptions) {
 		}
 	};
 }
-//#endregion
-//#region src/path-client.ts
+// src/path-client.ts
 var PathCallForwarder = class {
 	client;
 	url;
@@ -522,7 +724,6 @@ function wrapAsPathBasedClient(coreClient) {
 function createPathBasedClient(clientOptions) {
 	return wrapAsPathBasedClient(createClient(clientOptions));
 }
-//#endregion
 exports.createClient = createClient;
 exports.createFinalURL = createFinalURL;
 exports.createPathBasedClient = createPathBasedClient;