@shipworthy/openapi-fetch 0.0.2 → 1.0.0

package/dist/transform-casing.d.cts

@@ -0,0 +1,138 @@
+/** Return `content` for a Response Object */
+type ResponseContent<T> = T extends {
+  content: any;
+} ? T["content"] : unknown;
+/** Return type of `requestBody` for an Operation Object */
+type OperationRequestBody<T> = "requestBody" extends keyof T ? T["requestBody"] : never;
+/** Internal helper to get object type with only the `requestBody` property */
+type PickRequestBody<T> = "requestBody" extends keyof T ? Pick<T, "requestBody"> : never;
+/** Resolve to `true` if request body is optional, else `false` */
+type IsOperationRequestBodyOptional<T> = RequiredKeysOf<PickRequestBody<T>> extends never ? true : false;
+/** Internal helper used in OperationRequestBodyContent */
+type OperationRequestBodyMediaContent<T> = IsOperationRequestBodyOptional<T> extends true ? ResponseContent<NonNullable<OperationRequestBody<T>>> | undefined : ResponseContent<OperationRequestBody<T>>;
+/** Return first `content` from a Request Object Mapping, allowing any media type */
+type OperationRequestBodyContent<T> = FilterKeys<OperationRequestBodyMediaContent<T>, MediaType> extends never ? FilterKeys<NonNullable<OperationRequestBodyMediaContent<T>>, MediaType> | undefined : FilterKeys<OperationRequestBodyMediaContent<T>, MediaType>;
+/** Find first match of multiple keys */
+type FilterKeys<Obj, Matchers> = Obj[keyof Obj & Matchers];
+/** Return any `[string]/[string]` media type (important because openapi-fetch allows any content response, not just JSON-like) */
+type MediaType = `${string}/${string}`;
+/** Helper to get the required keys of an object. If no keys are required, will be `undefined` with strictNullChecks enabled, else `never` */
+type RequiredKeysOfHelper<T> = { [K in keyof T]: {} extends Pick<T, K> ? never : K; }[keyof T];
+/** Get the required keys of an object, or `never` if no keys are required */
+type RequiredKeysOf<T> = RequiredKeysOfHelper<T> extends undefined ? never : RequiredKeysOfHelper<T>;
+type HeadersOptions = Required<RequestInit>["headers"] | Record<string, string | number | boolean | (string | number | boolean)[] | null | undefined>;
+type QuerySerializer<T> = (query: T extends {
+  parameters: any;
+} ? NonNullable<T["parameters"]["query"]> : Record<string, unknown>) => string;
+type BodySerializer<T> = (body: OperationRequestBodyContent<T>, headers?: Headers) => any;
+type PathSerializer = (pathname: string, pathParams: Record<string, unknown>) => string;
+type BodyType<T = unknown> = {
+  json: T;
+  text: Awaited<ReturnType<Response["text"]>>;
+  blob: Awaited<ReturnType<Response["blob"]>>;
+  arrayBuffer: Awaited<ReturnType<Response["arrayBuffer"]>>;
+  stream: Response["body"];
+};
+type ParseAs = keyof BodyType;
+type MergedOptions<T = unknown> = {
+  baseUrl: string;
+  parseAs: ParseAs;
+  querySerializer: QuerySerializer<T>;
+  bodySerializer: BodySerializer<T>;
+  pathSerializer: PathSerializer;
+  fetch: typeof globalThis.fetch;
+};
+interface MiddlewareRequestParams {
+  query?: Record<string, unknown>;
+  header?: HeadersOptions;
+  path?: Record<string, unknown>;
+  cookie?: Record<string, unknown>;
+}
+interface MiddlewareRequestInput {
+  readonly params: MiddlewareRequestParams;
+  readonly body: unknown;
+}
+interface MiddlewareRequestInitParams {
+  readonly schemaPath: string;
+  readonly method: string;
+  readonly input: MiddlewareRequestInput;
+  /** Client, request, and parameter headers merged before serialization. */
+  readonly headers: Headers;
+  readonly id: string;
+  readonly options: MergedOptions;
+}
+interface MiddlewareResult {
+  readonly data?: unknown;
+  readonly error?: unknown;
+  readonly response: Response;
+}
+interface MiddlewareCallbackParams {
+  /** Current Request object */
+  request: Request;
+  /** The original OpenAPI schema path (including curly braces) */
+  readonly schemaPath: string;
+  /** OpenAPI parameters as provided from openapi-fetch */
+  readonly params: MiddlewareRequestParams;
+  /** Unique ID for this request */
+  readonly id: string;
+  /** createClient options (read-only) */
+  readonly options: MergedOptions;
+}
+interface MiddlewareResultParams extends MiddlewareCallbackParams {
+  /** The method requested through the client, before HTTP middleware can replace the Request. */
+  readonly method: string;
+  readonly result: MiddlewareResult;
+}
+type MiddlewareOnRequestInit = (options: MiddlewareRequestInitParams) => void | MiddlewareRequestInput | Promise<MiddlewareRequestInput | void>;
+type MiddlewareOnRequest = (options: MiddlewareCallbackParams) => void | Request | Response | undefined | Promise<Request | Response | undefined | void>;
+type MiddlewareOnResponse = (options: MiddlewareCallbackParams & {
+  response: Response;
+}) => void | Response | undefined | Promise<Response | undefined | void>;
+type MiddlewareOnError = (options: MiddlewareCallbackParams & {
+  error: unknown;
+}) => void | Response | Error | Promise<void | Response | Error>;
+type MiddlewareOnResult = (options: MiddlewareResultParams) => void | Partial<Pick<MiddlewareResult, "data" | "error">> | Promise<Partial<Pick<MiddlewareResult, "data" | "error">> | void>;
+interface MiddlewareHooks {
+  onRequestInit?: MiddlewareOnRequestInit;
+  onRequest?: MiddlewareOnRequest;
+  onResponse?: MiddlewareOnResponse;
+  onError?: MiddlewareOnError;
+  onResult?: MiddlewareOnResult;
+}
+type Middleware = MiddlewareHooks & ({
+  onRequestInit: MiddlewareOnRequestInit;
+} | {
+  onRequest: MiddlewareOnRequest;
+} | {
+  onResponse: MiddlewareOnResponse;
+} | {
+  onError: MiddlewareOnError;
+} | {
+  onResult: MiddlewareOnResult;
+});
+interface CaseSchema {
+  readonly ref?: string;
+  readonly properties?: Readonly<Record<string, {
+    readonly name: string;
+    readonly schema?: CaseSchema;
+  }>>;
+  readonly declared?: readonly string[];
+  readonly items?: CaseSchema;
+  readonly prefixItems?: readonly (CaseSchema | null)[];
+  readonly additionalProperties?: CaseSchema;
+  readonly patternProperties?: Readonly<Record<string, CaseSchema | null>>;
+  readonly variants?: readonly CaseSchema[];
+}
+type CaseMediaMap = Readonly<Record<string, CaseSchema | null>>;
+interface CaseOperation {
+  readonly parameters?: Readonly<Partial<Record<"path" | "query" | "header" | "cookie", CaseSchema>>>;
+  readonly requestBodies?: CaseMediaMap;
+  readonly responses?: Readonly<Record<string, CaseMediaMap | null>>;
+}
+export interface CaseMapping {
+  readonly schemas?: Readonly<Record<string, CaseSchema>>;
+  readonly operations?: Readonly<Record<string, CaseOperation>>;
+}
+/** Convert generated camelCase values at the openapi-fetch request and result stages. */
+export declare function createCaseMappingMiddleware(mapping: CaseMapping): Middleware;
+export {};

package/dist/transform-casing.d.ts

@@ -0,0 +1,138 @@
+/** Return `content` for a Response Object */
+type ResponseContent<T> = T extends {
+  content: any;
+} ? T["content"] : unknown;
+/** Return type of `requestBody` for an Operation Object */
+type OperationRequestBody<T> = "requestBody" extends keyof T ? T["requestBody"] : never;
+/** Internal helper to get object type with only the `requestBody` property */
+type PickRequestBody<T> = "requestBody" extends keyof T ? Pick<T, "requestBody"> : never;
+/** Resolve to `true` if request body is optional, else `false` */
+type IsOperationRequestBodyOptional<T> = RequiredKeysOf<PickRequestBody<T>> extends never ? true : false;
+/** Internal helper used in OperationRequestBodyContent */
+type OperationRequestBodyMediaContent<T> = IsOperationRequestBodyOptional<T> extends true ? ResponseContent<NonNullable<OperationRequestBody<T>>> | undefined : ResponseContent<OperationRequestBody<T>>;
+/** Return first `content` from a Request Object Mapping, allowing any media type */
+type OperationRequestBodyContent<T> = FilterKeys<OperationRequestBodyMediaContent<T>, MediaType> extends never ? FilterKeys<NonNullable<OperationRequestBodyMediaContent<T>>, MediaType> | undefined : FilterKeys<OperationRequestBodyMediaContent<T>, MediaType>;
+/** Find first match of multiple keys */
+type FilterKeys<Obj, Matchers> = Obj[keyof Obj & Matchers];
+/** Return any `[string]/[string]` media type (important because openapi-fetch allows any content response, not just JSON-like) */
+type MediaType = `${string}/${string}`;
+/** Helper to get the required keys of an object. If no keys are required, will be `undefined` with strictNullChecks enabled, else `never` */
+type RequiredKeysOfHelper<T> = { [K in keyof T]: {} extends Pick<T, K> ? never : K; }[keyof T];
+/** Get the required keys of an object, or `never` if no keys are required */
+type RequiredKeysOf<T> = RequiredKeysOfHelper<T> extends undefined ? never : RequiredKeysOfHelper<T>;
+type HeadersOptions = Required<RequestInit>["headers"] | Record<string, string | number | boolean | (string | number | boolean)[] | null | undefined>;
+type QuerySerializer<T> = (query: T extends {
+  parameters: any;
+} ? NonNullable<T["parameters"]["query"]> : Record<string, unknown>) => string;
+type BodySerializer<T> = (body: OperationRequestBodyContent<T>, headers?: Headers) => any;
+type PathSerializer = (pathname: string, pathParams: Record<string, unknown>) => string;
+type BodyType<T = unknown> = {
+  json: T;
+  text: Awaited<ReturnType<Response["text"]>>;
+  blob: Awaited<ReturnType<Response["blob"]>>;
+  arrayBuffer: Awaited<ReturnType<Response["arrayBuffer"]>>;
+  stream: Response["body"];
+};
+type ParseAs = keyof BodyType;
+type MergedOptions<T = unknown> = {
+  baseUrl: string;
+  parseAs: ParseAs;
+  querySerializer: QuerySerializer<T>;
+  bodySerializer: BodySerializer<T>;
+  pathSerializer: PathSerializer;
+  fetch: typeof globalThis.fetch;
+};
+interface MiddlewareRequestParams {
+  query?: Record<string, unknown>;
+  header?: HeadersOptions;
+  path?: Record<string, unknown>;
+  cookie?: Record<string, unknown>;
+}
+interface MiddlewareRequestInput {
+  readonly params: MiddlewareRequestParams;
+  readonly body: unknown;
+}
+interface MiddlewareRequestInitParams {
+  readonly schemaPath: string;
+  readonly method: string;
+  readonly input: MiddlewareRequestInput;
+  /** Client, request, and parameter headers merged before serialization. */
+  readonly headers: Headers;
+  readonly id: string;
+  readonly options: MergedOptions;
+}
+interface MiddlewareResult {
+  readonly data?: unknown;
+  readonly error?: unknown;
+  readonly response: Response;
+}
+interface MiddlewareCallbackParams {
+  /** Current Request object */
+  request: Request;
+  /** The original OpenAPI schema path (including curly braces) */
+  readonly schemaPath: string;
+  /** OpenAPI parameters as provided from openapi-fetch */
+  readonly params: MiddlewareRequestParams;
+  /** Unique ID for this request */
+  readonly id: string;
+  /** createClient options (read-only) */
+  readonly options: MergedOptions;
+}
+interface MiddlewareResultParams extends MiddlewareCallbackParams {
+  /** The method requested through the client, before HTTP middleware can replace the Request. */
+  readonly method: string;
+  readonly result: MiddlewareResult;
+}
+type MiddlewareOnRequestInit = (options: MiddlewareRequestInitParams) => void | MiddlewareRequestInput | Promise<MiddlewareRequestInput | void>;
+type MiddlewareOnRequest = (options: MiddlewareCallbackParams) => void | Request | Response | undefined | Promise<Request | Response | undefined | void>;
+type MiddlewareOnResponse = (options: MiddlewareCallbackParams & {
+  response: Response;
+}) => void | Response | undefined | Promise<Response | undefined | void>;
+type MiddlewareOnError = (options: MiddlewareCallbackParams & {
+  error: unknown;
+}) => void | Response | Error | Promise<void | Response | Error>;
+type MiddlewareOnResult = (options: MiddlewareResultParams) => void | Partial<Pick<MiddlewareResult, "data" | "error">> | Promise<Partial<Pick<MiddlewareResult, "data" | "error">> | void>;
+interface MiddlewareHooks {
+  onRequestInit?: MiddlewareOnRequestInit;
+  onRequest?: MiddlewareOnRequest;
+  onResponse?: MiddlewareOnResponse;
+  onError?: MiddlewareOnError;
+  onResult?: MiddlewareOnResult;
+}
+type Middleware = MiddlewareHooks & ({
+  onRequestInit: MiddlewareOnRequestInit;
+} | {
+  onRequest: MiddlewareOnRequest;
+} | {
+  onResponse: MiddlewareOnResponse;
+} | {
+  onError: MiddlewareOnError;
+} | {
+  onResult: MiddlewareOnResult;
+});
+interface CaseSchema {
+  readonly ref?: string;
+  readonly properties?: Readonly<Record<string, {
+    readonly name: string;
+    readonly schema?: CaseSchema;
+  }>>;
+  readonly declared?: readonly string[];
+  readonly items?: CaseSchema;
+  readonly prefixItems?: readonly (CaseSchema | null)[];
+  readonly additionalProperties?: CaseSchema;
+  readonly patternProperties?: Readonly<Record<string, CaseSchema | null>>;
+  readonly variants?: readonly CaseSchema[];
+}
+type CaseMediaMap = Readonly<Record<string, CaseSchema | null>>;
+interface CaseOperation {
+  readonly parameters?: Readonly<Partial<Record<"path" | "query" | "header" | "cookie", CaseSchema>>>;
+  readonly requestBodies?: CaseMediaMap;
+  readonly responses?: Readonly<Record<string, CaseMediaMap | null>>;
+}
+export interface CaseMapping {
+  readonly schemas?: Readonly<Record<string, CaseSchema>>;
+  readonly operations?: Readonly<Record<string, CaseOperation>>;
+}
+/** Convert generated camelCase values at the openapi-fetch request and result stages. */
+export declare function createCaseMappingMiddleware(mapping: CaseMapping): Middleware;
+export {};

package/dist/transform-casing.js

@@ -0,0 +1,160 @@
+// 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") } : {}
+			};
+		}
+	};
+}
+export { createCaseMappingMiddleware };

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@shipworthy/openapi-fetch",
-  "version": "0.0.2",
+  "version": "1.0.0",
   "files": [
     "dist"
   ],
-  "description": "Fast, type-safe fetch client for your OpenAPI schema. Only 6 kb (min). Works with React, Vue, Svelte, or vanilla JS.",
+  "description": "Fast, type-safe fetch client for your OpenAPI schema. Works with React, Vue, Svelte, or vanilla JS.",
   "keywords": [
     "api",
     "fetch",
@@ -36,6 +36,16 @@
         "default": "./dist/index.cjs"
       }
     },
+    "./middleware/transform-casing": {
+      "import": {
+        "types": "./dist/transform-casing.d.ts",
+        "default": "./dist/transform-casing.js"
+      },
+      "require": {
+        "types": "./dist/transform-casing.d.cts",
+        "default": "./dist/transform-casing.cjs"
+      }
+    },
     "./package.json": "./package.json"
   },
   "scripts": {
@@ -43,9 +53,9 @@
     "test": "vitest run"
   },
   "devDependencies": {
-    "tsdown": "0.23.0",
+    "tsdown": "0.23.7",
     "typescript": "^7.0.2",
-    "vitest": "5.0.3"
+    "vitest": "5.1.0"
   },
   "main": "./dist/index.cjs",
   "module": "./dist/index.js",