@shipworthy/openapi-fetch 0.0.0-stage → 0.0.2

package/dist/index.js

@@ -0,0 +1,522 @@
+//#region 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();
+	if (Array.isArray(h)) return new Headers(h).entries();
+	return Object.entries(h);
+}
+/** Merge headers a and b, with b taking priority */
+function mergeHeaders(...allHeaders) {
+	const finalHeaders = new Headers();
+	for (const h of allHeaders) {
+		if (!h || typeof h !== "object") continue;
+		for (const [k, v] of headerEntries(h)) if (v === null) finalHeaders.delete(k);
+		else if (Array.isArray(v)) for (const v2 of v) finalHeaders.append(k, String(v2));
+		else if (v !== void 0) finalHeaders.set(k, String(v));
+	}
+	return finalHeaders;
+}
+//#endregion
+//#region src/serializers/body.ts
+/** Serialize body object to string */
+function defaultBodySerializer(body, headers) {
+	if (body instanceof FormData) return body;
+	if (headers) {
+		if ((typeof headers.get === "function" ? headers.get("Content-Type") ?? headers.get("content-type") : headers["Content-Type"] ?? headers["content-type"]) === "application/x-www-form-urlencoded") return new URLSearchParams(body).toString();
+	}
+	return JSON.stringify(body);
+}
+//#endregion
+//#region src/serializers/param.ts
+/** Serialize primitive params to string */
+function serializePrimitiveParam(name, value, options) {
+	if (value === void 0 || value === null) return "";
+	if (typeof value === "object") throw new Error("Deeply-nested arrays/objects aren’t supported. Provide your own `querySerializer()` to handle these.");
+	return `${name}=${options?.allowReserved === true ? value : encodeURIComponent(value)}`;
+}
+/** Serialize object param to string */
+function serializeObjectParam(name, value, options) {
+	if (!value || typeof value !== "object") return "";
+	const values = [];
+	const joiner = {
+		simple: ",",
+		label: ".",
+		matrix: ";"
+	}[options.style] || "&";
+	if (options.style !== "deepObject" && options.explode === false) {
+		for (const k in value) values.push(k, options.allowReserved === true ? value[k] : encodeURIComponent(String(value[k])));
+		const final = values.join(",");
+		switch (options.style) {
+			case "form": return `${name}=${final}`;
+			case "label": return `.${final}`;
+			case "matrix": return `;${name}=${final}`;
+			default: return final;
+		}
+	}
+	for (const k in value) {
+		const finalName = options.style === "deepObject" ? `${name}[${k}]` : k;
+		values.push(serializePrimitiveParam(finalName, value[k], options));
+	}
+	const final = values.join(joiner);
+	return options.style === "label" || options.style === "matrix" ? `${joiner}${final}` : final;
+}
+/** Serialize array param (shallow only) */
+function serializeArrayParam(name, value, options) {
+	if (!Array.isArray(value)) return "";
+	if (options.explode === false) {
+		const joiner = {
+			form: ",",
+			spaceDelimited: "%20",
+			pipeDelimited: "|"
+		}[options.style] || ",";
+		const final = (options.allowReserved === true ? value : value.map((v) => encodeURIComponent(String(v)))).join(joiner);
+		switch (options.style) {
+			case "simple": return final;
+			case "label": return `.${final}`;
+			case "matrix": return `;${name}=${final}`;
+			default: return `${name}=${final}`;
+		}
+	}
+	const joiner = {
+		simple: ",",
+		label: ".",
+		matrix: ";"
+	}[options.style] || "&";
+	const values = [];
+	for (const v of value) if (options.style === "simple" || options.style === "label") values.push(options.allowReserved === true ? v : encodeURIComponent(String(v)));
+	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
+/**
+* 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,
+* and values are URI-encoded. `undefined` and `null` values are skipped.
+* @see https://swagger.io/docs/specification/serialization/#cookie
+*/
+function serializeCookieParams(cookieParams) {
+	const pairs = [];
+	if (!cookieParams || typeof cookieParams !== "object") return "";
+	const push = (name, value) => {
+		if (value === void 0 || value === null) return;
+		pairs.push(serializePrimitiveParam(name, value));
+	};
+	for (const name in cookieParams) {
+		const value = cookieParams[name];
+		if (Array.isArray(value)) for (const v of value) push(name, v);
+		else if (value !== null && typeof value === "object") for (const [k, v] of Object.entries(value)) push(k, v);
+		else push(name, value);
+	}
+	return pairs.join("; ");
+}
+//#endregion
+//#region src/serializers/path.ts
+const PATH_PARAM_RE = /\{[^{}]+\}/g;
+/**
+* Handle different OpenAPI 3.x serialization styles
+* @see https://swagger.io/docs/specification/serialization/#path
+*/
+function defaultPathSerializer(pathname, pathParams) {
+	let nextURL = pathname;
+	for (const match of pathname.match(PATH_PARAM_RE) ?? []) {
+		let name = match.substring(1, match.length - 1);
+		let explode = false;
+		let style = "simple";
+		if (name.endsWith("*")) {
+			explode = true;
+			name = name.substring(0, name.length - 1);
+		}
+		if (name.startsWith(".")) {
+			style = "label";
+			name = name.substring(1);
+		} else if (name.startsWith(";")) {
+			style = "matrix";
+			name = name.substring(1);
+		}
+		if (!pathParams || pathParams[name] === void 0 || pathParams[name] === null) continue;
+		const value = pathParams[name];
+		if (Array.isArray(value)) {
+			nextURL = nextURL.replace(match, serializeArrayParam(name, value, {
+				style,
+				explode
+			}));
+			continue;
+		}
+		if (typeof value === "object") {
+			nextURL = nextURL.replace(match, serializeObjectParam(name, value, {
+				style,
+				explode
+			}));
+			continue;
+		}
+		if (style === "matrix") {
+			nextURL = nextURL.replace(match, `;${serializePrimitiveParam(name, value)}`);
+			continue;
+		}
+		nextURL = nextURL.replace(match, style === "label" ? `.${encodeURIComponent(value)}` : encodeURIComponent(value));
+	}
+	return nextURL;
+}
+//#endregion
+//#region src/serializers/query.ts
+/** Serialize query params to string */
+function createQuerySerializer(options) {
+	return function querySerializer(queryParams) {
+		const search = [];
+		if (queryParams && typeof queryParams === "object") for (const name in queryParams) {
+			const value = queryParams[name];
+			if (value === void 0 || value === null) continue;
+			if (Array.isArray(value)) {
+				if (value.length === 0) continue;
+				search.push(serializeArrayParam(name, value, {
+					style: "form",
+					explode: true,
+					...options?.array,
+					allowReserved: options?.allowReserved || false
+				}));
+				continue;
+			}
+			if (typeof value === "object") {
+				search.push(serializeObjectParam(name, value, {
+					style: "deepObject",
+					explode: true,
+					...options?.object,
+					allowReserved: options?.allowReserved || false
+				}));
+				continue;
+			}
+			search.push(serializePrimitiveParam(name, value, options));
+		}
+		return search.join("&");
+	};
+}
+//#endregion
+//#region src/serializers/url.ts
+/** Construct URL string from baseUrl and handle path and query params */
+function createFinalURL(pathname, options) {
+	let finalURL = `${options.baseUrl}${pathname}`;
+	if (options.params?.path) finalURL = options.pathSerializer(finalURL, options.params.path);
+	let search = options.querySerializer(options.params.query ?? {});
+	if (search.startsWith("?")) search = search.substring(1);
+	if (search) finalURL += `?${search}`;
+	return finalURL;
+}
+/** Remove trailing slash from url */
+function removeTrailingSlash(url) {
+	if (url.endsWith("/")) return url.substring(0, url.length - 1);
+	return url;
+}
+//#endregion
+//#region 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;
+}
+/** Returns a cheap, non-cryptographically-secure random ID. */
+function randomID() {
+	return Math.random().toString(36).slice(2, 11);
+}
+/**
+* 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 };
+	requestInitExt = supportsRequestInitExt() ? requestInitExt : void 0;
+	baseUrl = removeTrailingSlash(baseUrl);
+	const globalMiddlewares = [];
+	/**
+	* 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 || {};
+		let finalBaseUrl = baseUrl;
+		if (localBaseUrl) finalBaseUrl = removeTrailingSlash(localBaseUrl) ?? baseUrl;
+		let querySerializer = typeof globalQuerySerializer === "function" ? globalQuerySerializer : createQuerySerializer(globalQuerySerializer);
+		if (requestQuerySerializer) querySerializer = typeof requestQuerySerializer === "function" ? requestQuerySerializer : createQuerySerializer({
+			...typeof globalQuerySerializer === "object" ? globalQuerySerializer : {},
+			...requestQuerySerializer
+		});
+		const pathSerializer = requestPathSerializer || globalPathSerializer || defaultPathSerializer;
+		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);
+		if (serializedCookies) {
+			const existingCookie = finalHeaders.get("Cookie");
+			finalHeaders.set("Cookie", existingCookie ? `${existingCookie}; ${serializedCookies}` : serializedCookies);
+		}
+		const finalMiddlewares = [...globalMiddlewares, ...requestMiddlewares];
+		const requestInit = {
+			redirect: "follow",
+			...baseOptions,
+			...init,
+			body: serializedBody,
+			headers: finalHeaders
+		};
+		let id;
+		let options;
+		let request = new Request(createFinalURL(schemaPath, {
+			baseUrl: finalBaseUrl,
+			params,
+			querySerializer,
+			pathSerializer
+		}), requestInit);
+		let response;
+		/** 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,
+					schemaPath,
+					params,
+					options,
+					id
+				});
+				if (result) {
+					if (result instanceof Request) request = result;
+					else if (result instanceof Response) {
+						response = result;
+						break;
+					} else throw new Error("onRequest: must return new Request() or Response() when modifying the request");
+				}
+			}
+		}
+		if (!response) {
+			try {
+				response = await fetch(request, requestInitExt);
+			} catch (error) {
+				let errorAfterMiddleware = error;
+				if (finalMiddlewares.length) for (let i = finalMiddlewares.length - 1; i >= 0; i--) {
+					const m = finalMiddlewares[i];
+					if (m && typeof m === "object" && typeof m.onError === "function") {
+						const result = await m.onError({
+							request,
+							error: errorAfterMiddleware,
+							schemaPath,
+							params,
+							options,
+							id
+						});
+						if (result) {
+							if (result instanceof Response) {
+								response = result;
+								break;
+							}
+							if (result instanceof Error) {
+								errorAfterMiddleware = result;
+								continue;
+							}
+							throw new Error("onError: must return new Response() or instance of Error");
+						}
+					}
+				}
+				if (!response) throw errorAfterMiddleware;
+			}
+			if (finalMiddlewares.length) for (let i = finalMiddlewares.length - 1; i >= 0; i--) {
+				const m = finalMiddlewares[i];
+				if (m && typeof m === "object" && typeof m.onResponse === "function") {
+					const result = await m.onResponse({
+						request,
+						response,
+						schemaPath,
+						params,
+						options,
+						id
+					});
+					if (result) {
+						if (!(result instanceof Response)) throw new Error("onResponse: must return new Response() when modifying the response");
+						response = result;
+					}
+				}
+			}
+		}
+		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 ? {
+			data: void 0,
+			response: finalResponse
+		} : {
+			error: void 0,
+			response: finalResponse
+		};
+		if (finalResponse.ok) {
+			const getResponseData = async () => {
+				if (parseAs === "stream") return finalResponse.body;
+				if (parseAs === "json" && !contentLength) {
+					const raw = await finalResponse.text();
+					return raw ? JSON.parse(raw) : void 0;
+				}
+				return await finalResponse[parseAs]();
+			};
+			return {
+				data: await getResponseData(),
+				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
+		};
+	}
+	return {
+		request(method, url, init) {
+			return coreFetch(url, {
+				...init,
+				method: method.toUpperCase()
+			});
+		},
+		/** Call a GET endpoint */
+		GET(url, init) {
+			return coreFetch(url, {
+				...init,
+				method: "GET"
+			});
+		},
+		/** Call a PUT endpoint */
+		PUT(url, init) {
+			return coreFetch(url, {
+				...init,
+				method: "PUT"
+			});
+		},
+		/** Call a POST endpoint */
+		POST(url, init) {
+			return coreFetch(url, {
+				...init,
+				method: "POST"
+			});
+		},
+		/** Call a DELETE endpoint */
+		DELETE(url, init) {
+			return coreFetch(url, {
+				...init,
+				method: "DELETE"
+			});
+		},
+		/** Call a OPTIONS endpoint */
+		OPTIONS(url, init) {
+			return coreFetch(url, {
+				...init,
+				method: "OPTIONS"
+			});
+		},
+		/** Call a HEAD endpoint */
+		HEAD(url, init) {
+			return coreFetch(url, {
+				...init,
+				method: "HEAD"
+			});
+		},
+		/** Call a PATCH endpoint */
+		PATCH(url, init) {
+			return coreFetch(url, {
+				...init,
+				method: "PATCH"
+			});
+		},
+		/** Call a TRACE endpoint */
+		TRACE(url, init) {
+			return coreFetch(url, {
+				...init,
+				method: "TRACE"
+			});
+		},
+		/** Register middleware */
+		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()`");
+				globalMiddlewares.push(m);
+			}
+		},
+		/** Unregister middleware */
+		eject(...middleware) {
+			for (const m of middleware) {
+				const i = globalMiddlewares.indexOf(m);
+				if (i !== -1) globalMiddlewares.splice(i, 1);
+			}
+		}
+	};
+}
+//#endregion
+//#region src/path-client.ts
+var PathCallForwarder = class {
+	client;
+	url;
+	constructor(client, url) {
+		this.client = client;
+		this.url = url;
+	}
+	GET = (init) => {
+		return this.client.GET(this.url, init);
+	};
+	PUT = (init) => {
+		return this.client.PUT(this.url, init);
+	};
+	POST = (init) => {
+		return this.client.POST(this.url, init);
+	};
+	DELETE = (init) => {
+		return this.client.DELETE(this.url, init);
+	};
+	OPTIONS = (init) => {
+		return this.client.OPTIONS(this.url, init);
+	};
+	HEAD = (init) => {
+		return this.client.HEAD(this.url, init);
+	};
+	PATCH = (init) => {
+		return this.client.PATCH(this.url, init);
+	};
+	TRACE = (init) => {
+		return this.client.TRACE(this.url, init);
+	};
+};
+var PathClientProxyHandler = class {
+	client = null;
+	get(coreClient, url) {
+		const forwarder = new PathCallForwarder(coreClient, url);
+		this.client[url] = forwarder;
+		return forwarder;
+	}
+};
+/**
+* Wrap openapi-fetch client to support a path based API.
+*/
+function wrapAsPathBasedClient(coreClient) {
+	const handler = new PathClientProxyHandler();
+	const proxy = new Proxy(coreClient, handler);
+	function ClientCtor() {}
+	ClientCtor.prototype = proxy;
+	const client = new ClientCtor();
+	handler.client = client;
+	return client;
+}
+/**
+* Convenience method to an openapi-fetch path based client.
+* Strictly equivalent to `wrapAsPathBasedClient(createClient(...))`.
+*/
+function createPathBasedClient(clientOptions) {
+	return wrapAsPathBasedClient(createClient(clientOptions));
+}
+//#endregion
+export { createClient, createClient as default, createFinalURL, createPathBasedClient, createQuerySerializer, defaultBodySerializer, defaultPathSerializer, mergeHeaders, removeTrailingSlash, serializeArrayParam, serializeObjectParam, serializePrimitiveParam, wrapAsPathBasedClient };

package/package.json

@@ -1,6 +1,57 @@
 {
   "name": "@shipworthy/openapi-fetch",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.0.2",
+  "files": [
+    "dist"
+  ],
+  "description": "Fast, type-safe fetch client for your OpenAPI schema. Only 6 kb (min). Works with React, Vue, Svelte, or vanilla JS.",
+  "keywords": [
+    "api",
+    "fetch",
+    "oapi_3",
+    "oapi_3_1",
+    "openapi",
+    "react",
+    "rest",
+    "svelte",
+    "swagger",
+    "typescript",
+    "vue"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/ShipWorthyAI/openapi.git",
+    "directory": "packages/openapi-fetch"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsdown",
+    "test": "vitest run"
+  },
+  "devDependencies": {
+    "tsdown": "0.23.0",
+    "typescript": "^7.0.2",
+    "vitest": "5.0.3"
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.cts",
+  "react-native": "./dist/index.js",
+  "publishConfig": {
+    "access": "public"
+  }
+}