refactor: switch from go to bun

apps/client/app/api-client/@tanstack/react-query.gen.ts

@@ -0,0 +1,71 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import { type Options, getApiV1Volumes } from "../sdk.gen";
+import { queryOptions } from "@tanstack/react-query";
+import type { GetApiV1VolumesData } from "../types.gen";
+import { client as _heyApiClient } from "../client.gen";
+
+export type QueryKey<TOptions extends Options> = [
+	Pick<TOptions, "baseUrl" | "body" | "headers" | "path" | "query"> & {
+		_id: string;
+		_infinite?: boolean;
+		tags?: ReadonlyArray<string>;
+	},
+];
+
+const createQueryKey = <TOptions extends Options>(
+	id: string,
+	options?: TOptions,
+	infinite?: boolean,
+	tags?: ReadonlyArray<string>,
+): [QueryKey<TOptions>[0]] => {
+	const params: QueryKey<TOptions>[0] = {
+		_id: id,
+		baseUrl:
+			options?.baseUrl ||
+			(options?.client ?? _heyApiClient).getConfig().baseUrl,
+	} as QueryKey<TOptions>[0];
+	if (infinite) {
+		params._infinite = infinite;
+	}
+	if (tags) {
+		params.tags = tags;
+	}
+	if (options?.body) {
+		params.body = options.body;
+	}
+	if (options?.headers) {
+		params.headers = options.headers;
+	}
+	if (options?.path) {
+		params.path = options.path;
+	}
+	if (options?.query) {
+		params.query = options.query;
+	}
+	return [params];
+};
+
+export const getApiV1VolumesQueryKey = (
+	options?: Options<GetApiV1VolumesData>,
+) => createQueryKey("getApiV1Volumes", options);
+
+/**
+ * List all volumes
+ */
+export const getApiV1VolumesOptions = (
+	options?: Options<GetApiV1VolumesData>,
+) => {
+	return queryOptions({
+		queryFn: async ({ queryKey, signal }) => {
+			const { data } = await getApiV1Volumes({
+				...options,
+				...queryKey[0],
+				signal,
+				throwOnError: true,
+			});
+			return data;
+		},
+		queryKey: getApiV1VolumesQueryKey(options),
+	});
+};

apps/client/app/api-client/client.gen.ts

@@ -0,0 +1,28 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import type { ClientOptions } from "./types.gen";
+import {
+	type Config,
+	type ClientOptions as DefaultClientOptions,
+	createClient,
+	createConfig,
+} from "./client";
+
+/**
+ * The `createClientConfig()` function will be called on client initialization
+ * and the returned object will become the client's initial configuration.
+ *
+ * You may want to initialize your client this way instead of calling
+ * `setConfig()`. This is useful for example if you're using Next.js
+ * to ensure your client always has the correct values.
+ */
+export type CreateClientConfig<T extends DefaultClientOptions = ClientOptions> =
+	(
+		override?: Config<DefaultClientOptions & T>,
+	) => Config<Required<DefaultClientOptions> & T>;
+
+export const client = createClient(
+	createConfig<ClientOptions>({
+		baseUrl: "http://localhost:3000",
+	}),
+);

apps/client/app/api-client/client/client.gen.ts

@@ -0,0 +1,199 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import type { Client, Config, ResolvedRequestOptions } from "./types.gen";
+import {
+	buildUrl,
+	createConfig,
+	createInterceptors,
+	getParseAs,
+	mergeConfigs,
+	mergeHeaders,
+	setAuthParams,
+} from "./utils.gen";
+
+type ReqInit = Omit<RequestInit, "body" | "headers"> & {
+	body?: any;
+	headers: ReturnType<typeof mergeHeaders>;
+};
+
+export const createClient = (config: Config = {}): Client => {
+	let _config = mergeConfigs(createConfig(), config);
+
+	const getConfig = (): Config => ({ ..._config });
+
+	const setConfig = (config: Config): Config => {
+		_config = mergeConfigs(_config, config);
+		return getConfig();
+	};
+
+	const interceptors = createInterceptors<
+		Request,
+		Response,
+		unknown,
+		ResolvedRequestOptions
+	>();
+
+	const request: Client["request"] = async (options) => {
+		const opts = {
+			..._config,
+			...options,
+			fetch: options.fetch ?? _config.fetch ?? globalThis.fetch,
+			headers: mergeHeaders(_config.headers, options.headers),
+			serializedBody: undefined,
+		};
+
+		if (opts.security) {
+			await setAuthParams({
+				...opts,
+				security: opts.security,
+			});
+		}
+
+		if (opts.requestValidator) {
+			await opts.requestValidator(opts);
+		}
+
+		if (opts.body && opts.bodySerializer) {
+			opts.serializedBody = opts.bodySerializer(opts.body);
+		}
+
+		// remove Content-Type header if body is empty to avoid sending invalid requests
+		if (opts.serializedBody === undefined || opts.serializedBody === "") {
+			opts.headers.delete("Content-Type");
+		}
+
+		const url = buildUrl(opts);
+		const requestInit: ReqInit = {
+			redirect: "follow",
+			...opts,
+			body: opts.serializedBody,
+		};
+
+		let request = new Request(url, requestInit);
+
+		for (const fn of interceptors.request._fns) {
+			if (fn) {
+				request = await fn(request, opts);
+			}
+		}
+
+		// fetch must be assigned here, otherwise it would throw the error:
+		// TypeError: Failed to execute 'fetch' on 'Window': Illegal invocation
+		const _fetch = opts.fetch!;
+		let response = await _fetch(request);
+
+		for (const fn of interceptors.response._fns) {
+			if (fn) {
+				response = await fn(response, request, opts);
+			}
+		}
+
+		const result = {
+			request,
+			response,
+		};
+
+		if (response.ok) {
+			if (
+				response.status === 204 ||
+				response.headers.get("Content-Length") === "0"
+			) {
+				return opts.responseStyle === "data"
+					? {}
+					: {
+							data: {},
+							...result,
+						};
+			}
+
+			const parseAs =
+				(opts.parseAs === "auto"
+					? getParseAs(response.headers.get("Content-Type"))
+					: opts.parseAs) ?? "json";
+
+			let data: any;
+			switch (parseAs) {
+				case "arrayBuffer":
+				case "blob":
+				case "formData":
+				case "json":
+				case "text":
+					data = await response[parseAs]();
+					break;
+				case "stream":
+					return opts.responseStyle === "data"
+						? response.body
+						: {
+								data: response.body,
+								...result,
+							};
+			}
+
+			if (parseAs === "json") {
+				if (opts.responseValidator) {
+					await opts.responseValidator(data);
+				}
+
+				if (opts.responseTransformer) {
+					data = await opts.responseTransformer(data);
+				}
+			}
+
+			return opts.responseStyle === "data"
+				? data
+				: {
+						data,
+						...result,
+					};
+		}
+
+		const textError = await response.text();
+		let jsonError: unknown;
+
+		try {
+			jsonError = JSON.parse(textError);
+		} catch {
+			// noop
+		}
+
+		const error = jsonError ?? textError;
+		let finalError = error;
+
+		for (const fn of interceptors.error._fns) {
+			if (fn) {
+				finalError = (await fn(error, response, request, opts)) as string;
+			}
+		}
+
+		finalError = finalError || ({} as string);
+
+		if (opts.throwOnError) {
+			throw finalError;
+		}
+
+		// TODO: we probably want to return error and improve types
+		return opts.responseStyle === "data"
+			? undefined
+			: {
+					error: finalError,
+					...result,
+				};
+	};
+
+	return {
+		buildUrl,
+		connect: (options) => request({ ...options, method: "CONNECT" }),
+		delete: (options) => request({ ...options, method: "DELETE" }),
+		get: (options) => request({ ...options, method: "GET" }),
+		getConfig,
+		head: (options) => request({ ...options, method: "HEAD" }),
+		interceptors,
+		options: (options) => request({ ...options, method: "OPTIONS" }),
+		patch: (options) => request({ ...options, method: "PATCH" }),
+		post: (options) => request({ ...options, method: "POST" }),
+		put: (options) => request({ ...options, method: "PUT" }),
+		request,
+		setConfig,
+		trace: (options) => request({ ...options, method: "TRACE" }),
+	};
+};

apps/client/app/api-client/client/index.ts

@@ -0,0 +1,25 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+export type { Auth } from "../core/auth.gen";
+export type { QuerySerializerOptions } from "../core/bodySerializer.gen";
+export {
+	formDataBodySerializer,
+	jsonBodySerializer,
+	urlSearchParamsBodySerializer,
+} from "../core/bodySerializer.gen";
+export { buildClientParams } from "../core/params.gen";
+export { createClient } from "./client.gen";
+export type {
+	Client,
+	ClientOptions,
+	Config,
+	CreateClientConfig,
+	Options,
+	OptionsLegacyParser,
+	RequestOptions,
+	RequestResult,
+	ResolvedRequestOptions,
+	ResponseStyle,
+	TDataShape,
+} from "./types.gen";
+export { createConfig, mergeHeaders } from "./utils.gen";

apps/client/app/api-client/client/types.gen.ts

@@ -0,0 +1,232 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import type { Auth } from "../core/auth.gen";
+import type {
+	Client as CoreClient,
+	Config as CoreConfig,
+} from "../core/types.gen";
+import type { Middleware } from "./utils.gen";
+
+export type ResponseStyle = "data" | "fields";
+
+export interface Config<T extends ClientOptions = ClientOptions>
+	extends Omit<RequestInit, "body" | "headers" | "method">,
+		CoreConfig {
+	/**
+	 * Base URL for all requests made by this client.
+	 */
+	baseUrl?: T["baseUrl"];
+	/**
+	 * Fetch API implementation. You can use this option to provide a custom
+	 * fetch instance.
+	 *
+	 * @default globalThis.fetch
+	 */
+	fetch?: (request: Request) => ReturnType<typeof fetch>;
+	/**
+	 * Please don't use the Fetch client for Next.js applications. The `next`
+	 * options won't have any effect.
+	 *
+	 * Install {@link https://www.npmjs.com/package/@hey-api/client-next `@hey-api/client-next`} instead.
+	 */
+	next?: never;
+	/**
+	 * Return the response data parsed in a specified format. By default, `auto`
+	 * will infer the appropriate method from the `Content-Type` response header.
+	 * You can override this behavior with any of the {@link Body} methods.
+	 * Select `stream` if you don't want to parse response data at all.
+	 *
+	 * @default 'auto'
+	 */
+	parseAs?:
+		| "arrayBuffer"
+		| "auto"
+		| "blob"
+		| "formData"
+		| "json"
+		| "stream"
+		| "text";
+	/**
+	 * Should we return only data or multiple fields (data, error, response, etc.)?
+	 *
+	 * @default 'fields'
+	 */
+	responseStyle?: ResponseStyle;
+	/**
+	 * Throw an error instead of returning it in the response?
+	 *
+	 * @default false
+	 */
+	throwOnError?: T["throwOnError"];
+}
+
+export interface RequestOptions<
+	TResponseStyle extends ResponseStyle = "fields",
+	ThrowOnError extends boolean = boolean,
+	Url extends string = string,
+> extends Config<{
+		responseStyle: TResponseStyle;
+		throwOnError: ThrowOnError;
+	}> {
+	/**
+	 * Any body that you want to add to your request.
+	 *
+	 * {@link https://developer.mozilla.org/docs/Web/API/fetch#body}
+	 */
+	body?: unknown;
+	path?: Record<string, unknown>;
+	query?: Record<string, unknown>;
+	/**
+	 * Security mechanism(s) to use for the request.
+	 */
+	security?: ReadonlyArray<Auth>;
+	url: Url;
+}
+
+export interface ResolvedRequestOptions<
+	TResponseStyle extends ResponseStyle = "fields",
+	ThrowOnError extends boolean = boolean,
+	Url extends string = string,
+> extends RequestOptions<TResponseStyle, ThrowOnError, Url> {
+	serializedBody?: string;
+}
+
+export type RequestResult<
+	TData = unknown,
+	TError = unknown,
+	ThrowOnError extends boolean = boolean,
+	TResponseStyle extends ResponseStyle = "fields",
+> = ThrowOnError extends true
+	? Promise<
+			TResponseStyle extends "data"
+				? TData extends Record<string, unknown>
+					? TData[keyof TData]
+					: TData
+				: {
+						data: TData extends Record<string, unknown>
+							? TData[keyof TData]
+							: TData;
+						request: Request;
+						response: Response;
+					}
+		>
+	: Promise<
+			TResponseStyle extends "data"
+				?
+						| (TData extends Record<string, unknown>
+								? TData[keyof TData]
+								: TData)
+						| undefined
+				: (
+						| {
+								data: TData extends Record<string, unknown>
+									? TData[keyof TData]
+									: TData;
+								error: undefined;
+						  }
+						| {
+								data: undefined;
+								error: TError extends Record<string, unknown>
+									? TError[keyof TError]
+									: TError;
+						  }
+					) & {
+						request: Request;
+						response: Response;
+					}
+		>;
+
+export interface ClientOptions {
+	baseUrl?: string;
+	responseStyle?: ResponseStyle;
+	throwOnError?: boolean;
+}
+
+type MethodFn = <
+	TData = unknown,
+	TError = unknown,
+	ThrowOnError extends boolean = false,
+	TResponseStyle extends ResponseStyle = "fields",
+>(
+	options: Omit<RequestOptions<TResponseStyle, ThrowOnError>, "method">,
+) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+
+type RequestFn = <
+	TData = unknown,
+	TError = unknown,
+	ThrowOnError extends boolean = false,
+	TResponseStyle extends ResponseStyle = "fields",
+>(
+	options: Omit<RequestOptions<TResponseStyle, ThrowOnError>, "method"> &
+		Pick<Required<RequestOptions<TResponseStyle, ThrowOnError>>, "method">,
+) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
+
+type BuildUrlFn = <
+	TData extends {
+		body?: unknown;
+		path?: Record<string, unknown>;
+		query?: Record<string, unknown>;
+		url: string;
+	},
+>(
+	options: Pick<TData, "url"> & Options<TData>,
+) => string;
+
+export type Client = CoreClient<RequestFn, Config, MethodFn, BuildUrlFn> & {
+	interceptors: Middleware<Request, Response, unknown, ResolvedRequestOptions>;
+};
+
+/**
+ * The `createClientConfig()` function will be called on client initialization
+ * and the returned object will become the client's initial configuration.
+ *
+ * You may want to initialize your client this way instead of calling
+ * `setConfig()`. This is useful for example if you're using Next.js
+ * to ensure your client always has the correct values.
+ */
+export type CreateClientConfig<T extends ClientOptions = ClientOptions> = (
+	override?: Config<ClientOptions & T>,
+) => Config<Required<ClientOptions> & T>;
+
+export interface TDataShape {
+	body?: unknown;
+	headers?: unknown;
+	path?: unknown;
+	query?: unknown;
+	url: string;
+}
+
+type OmitKeys<T, K> = Pick<T, Exclude<keyof T, K>>;
+
+export type Options<
+	TData extends TDataShape = TDataShape,
+	ThrowOnError extends boolean = boolean,
+	TResponseStyle extends ResponseStyle = "fields",
+> = OmitKeys<
+	RequestOptions<TResponseStyle, ThrowOnError>,
+	"body" | "path" | "query" | "url"
+> &
+	Omit<TData, "url">;
+
+export type OptionsLegacyParser<
+	TData = unknown,
+	ThrowOnError extends boolean = boolean,
+	TResponseStyle extends ResponseStyle = "fields",
+> = TData extends { body?: any }
+	? TData extends { headers?: any }
+		? OmitKeys<
+				RequestOptions<TResponseStyle, ThrowOnError>,
+				"body" | "headers" | "url"
+			> &
+				TData
+		: OmitKeys<RequestOptions<TResponseStyle, ThrowOnError>, "body" | "url"> &
+				TData &
+				Pick<RequestOptions<TResponseStyle, ThrowOnError>, "headers">
+	: TData extends { headers?: any }
+		? OmitKeys<
+				RequestOptions<TResponseStyle, ThrowOnError>,
+				"headers" | "url"
+			> &
+				TData &
+				Pick<RequestOptions<TResponseStyle, ThrowOnError>, "body">
+		: OmitKeys<RequestOptions<TResponseStyle, ThrowOnError>, "url"> & TData;

apps/client/app/api-client/client/utils.gen.ts

@@ -0,0 +1,445 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import { getAuthToken } from "../core/auth.gen";
+import type {
+	QuerySerializer,
+	QuerySerializerOptions,
+} from "../core/bodySerializer.gen";
+import { jsonBodySerializer } from "../core/bodySerializer.gen";
+import {
+	serializeArrayParam,
+	serializeObjectParam,
+	serializePrimitiveParam,
+} from "../core/pathSerializer.gen";
+import type {
+	Client,
+	ClientOptions,
+	Config,
+	RequestOptions,
+} from "./types.gen";
+
+interface PathSerializer {
+	path: Record<string, unknown>;
+	url: string;
+}
+
+const PATH_PARAM_RE = /\{[^{}]+\}/g;
+
+type ArrayStyle = "form" | "spaceDelimited" | "pipeDelimited";
+type MatrixStyle = "label" | "matrix" | "simple";
+type ArraySeparatorStyle = ArrayStyle | MatrixStyle;
+
+const defaultPathSerializer = ({ path, url: _url }: PathSerializer) => {
+	let url = _url;
+	const matches = _url.match(PATH_PARAM_RE);
+	if (matches) {
+		for (const match of matches) {
+			let explode = false;
+			let name = match.substring(1, match.length - 1);
+			let style: ArraySeparatorStyle = "simple";
+
+			if (name.endsWith("*")) {
+				explode = true;
+				name = name.substring(0, name.length - 1);
+			}
+
+			if (name.startsWith(".")) {
+				name = name.substring(1);
+				style = "label";
+			} else if (name.startsWith(";")) {
+				name = name.substring(1);
+				style = "matrix";
+			}
+
+			const value = path[name];
+
+			if (value === undefined || value === null) {
+				continue;
+			}
+
+			if (Array.isArray(value)) {
+				url = url.replace(
+					match,
+					serializeArrayParam({ explode, name, style, value }),
+				);
+				continue;
+			}
+
+			if (typeof value === "object") {
+				url = url.replace(
+					match,
+					serializeObjectParam({
+						explode,
+						name,
+						style,
+						value: value as Record<string, unknown>,
+						valueOnly: true,
+					}),
+				);
+				continue;
+			}
+
+			if (style === "matrix") {
+				url = url.replace(
+					match,
+					`;${serializePrimitiveParam({
+						name,
+						value: value as string,
+					})}`,
+				);
+				continue;
+			}
+
+			const replaceValue = encodeURIComponent(
+				style === "label" ? `.${value as string}` : (value as string),
+			);
+			url = url.replace(match, replaceValue);
+		}
+	}
+	return url;
+};
+
+export const createQuerySerializer = <T = unknown>({
+	allowReserved,
+	array,
+	object,
+}: QuerySerializerOptions = {}) => {
+	const querySerializer = (queryParams: T) => {
+		const search: string[] = [];
+		if (queryParams && typeof queryParams === "object") {
+			for (const name in queryParams) {
+				const value = queryParams[name];
+
+				if (value === undefined || value === null) {
+					continue;
+				}
+
+				if (Array.isArray(value)) {
+					const serializedArray = serializeArrayParam({
+						allowReserved,
+						explode: true,
+						name,
+						style: "form",
+						value,
+						...array,
+					});
+					if (serializedArray) search.push(serializedArray);
+				} else if (typeof value === "object") {
+					const serializedObject = serializeObjectParam({
+						allowReserved,
+						explode: true,
+						name,
+						style: "deepObject",
+						value: value as Record<string, unknown>,
+						...object,
+					});
+					if (serializedObject) search.push(serializedObject);
+				} else {
+					const serializedPrimitive = serializePrimitiveParam({
+						allowReserved,
+						name,
+						value: value as string,
+					});
+					if (serializedPrimitive) search.push(serializedPrimitive);
+				}
+			}
+		}
+		return search.join("&");
+	};
+	return querySerializer;
+};
+
+/**
+ * Infers parseAs value from provided Content-Type header.
+ */
+export const getParseAs = (
+	contentType: string | null,
+): Exclude<Config["parseAs"], "auto"> => {
+	if (!contentType) {
+		// If no Content-Type header is provided, the best we can do is return the raw response body,
+		// which is effectively the same as the 'stream' option.
+		return "stream";
+	}
+
+	const cleanContent = contentType.split(";")[0]?.trim();
+
+	if (!cleanContent) {
+		return;
+	}
+
+	if (
+		cleanContent.startsWith("application/json") ||
+		cleanContent.endsWith("+json")
+	) {
+		return "json";
+	}
+
+	if (cleanContent === "multipart/form-data") {
+		return "formData";
+	}
+
+	if (
+		["application/", "audio/", "image/", "video/"].some((type) =>
+			cleanContent.startsWith(type),
+		)
+	) {
+		return "blob";
+	}
+
+	if (cleanContent.startsWith("text/")) {
+		return "text";
+	}
+
+	return;
+};
+
+const checkForExistence = (
+	options: Pick<RequestOptions, "auth" | "query"> & {
+		headers: Headers;
+	},
+	name?: string,
+): boolean => {
+	if (!name) {
+		return false;
+	}
+	if (
+		options.headers.has(name) ||
+		options.query?.[name] ||
+		options.headers.get("Cookie")?.includes(`${name}=`)
+	) {
+		return true;
+	}
+	return false;
+};
+
+export const setAuthParams = async ({
+	security,
+	...options
+}: Pick<Required<RequestOptions>, "security"> &
+	Pick<RequestOptions, "auth" | "query"> & {
+		headers: Headers;
+	}) => {
+	for (const auth of security) {
+		if (checkForExistence(options, auth.name)) {
+			continue;
+		}
+
+		const token = await getAuthToken(auth, options.auth);
+
+		if (!token) {
+			continue;
+		}
+
+		const name = auth.name ?? "Authorization";
+
+		switch (auth.in) {
+			case "query":
+				if (!options.query) {
+					options.query = {};
+				}
+				options.query[name] = token;
+				break;
+			case "cookie":
+				options.headers.append("Cookie", `${name}=${token}`);
+				break;
+			case "header":
+			default:
+				options.headers.set(name, token);
+				break;
+		}
+	}
+};
+
+export const buildUrl: Client["buildUrl"] = (options) => {
+	const url = getUrl({
+		baseUrl: options.baseUrl as string,
+		path: options.path,
+		query: options.query,
+		querySerializer:
+			typeof options.querySerializer === "function"
+				? options.querySerializer
+				: createQuerySerializer(options.querySerializer),
+		url: options.url,
+	});
+	return url;
+};
+
+export const getUrl = ({
+	baseUrl,
+	path,
+	query,
+	querySerializer,
+	url: _url,
+}: {
+	baseUrl?: string;
+	path?: Record<string, unknown>;
+	query?: Record<string, unknown>;
+	querySerializer: QuerySerializer;
+	url: string;
+}) => {
+	const pathUrl = _url.startsWith("/") ? _url : `/${_url}`;
+	let url = (baseUrl ?? "") + pathUrl;
+	if (path) {
+		url = defaultPathSerializer({ path, url });
+	}
+	let search = query ? querySerializer(query) : "";
+	if (search.startsWith("?")) {
+		search = search.substring(1);
+	}
+	if (search) {
+		url += `?${search}`;
+	}
+	return url;
+};
+
+export const mergeConfigs = (a: Config, b: Config): Config => {
+	const config = { ...a, ...b };
+	if (config.baseUrl?.endsWith("/")) {
+		config.baseUrl = config.baseUrl.substring(0, config.baseUrl.length - 1);
+	}
+	config.headers = mergeHeaders(a.headers, b.headers);
+	return config;
+};
+
+export const mergeHeaders = (
+	...headers: Array<Required<Config>["headers"] | undefined>
+): Headers => {
+	const mergedHeaders = new Headers();
+	for (const header of headers) {
+		if (!header || typeof header !== "object") {
+			continue;
+		}
+
+		const iterator =
+			header instanceof Headers ? header.entries() : Object.entries(header);
+
+		for (const [key, value] of iterator) {
+			if (value === null) {
+				mergedHeaders.delete(key);
+			} else if (Array.isArray(value)) {
+				for (const v of value) {
+					mergedHeaders.append(key, v as string);
+				}
+			} else if (value !== undefined) {
+				// assume object headers are meant to be JSON stringified, i.e. their
+				// content value in OpenAPI specification is 'application/json'
+				mergedHeaders.set(
+					key,
+					typeof value === "object" ? JSON.stringify(value) : (value as string),
+				);
+			}
+		}
+	}
+	return mergedHeaders;
+};
+
+type ErrInterceptor<Err, Res, Req, Options> = (
+	error: Err,
+	response: Res,
+	request: Req,
+	options: Options,
+) => Err | Promise<Err>;
+
+type ReqInterceptor<Req, Options> = (
+	request: Req,
+	options: Options,
+) => Req | Promise<Req>;
+
+type ResInterceptor<Res, Req, Options> = (
+	response: Res,
+	request: Req,
+	options: Options,
+) => Res | Promise<Res>;
+
+class Interceptors<Interceptor> {
+	_fns: (Interceptor | null)[];
+
+	constructor() {
+		this._fns = [];
+	}
+
+	clear() {
+		this._fns = [];
+	}
+
+	getInterceptorIndex(id: number | Interceptor): number {
+		if (typeof id === "number") {
+			return this._fns[id] ? id : -1;
+		} else {
+			return this._fns.indexOf(id);
+		}
+	}
+	exists(id: number | Interceptor) {
+		const index = this.getInterceptorIndex(id);
+		return !!this._fns[index];
+	}
+
+	eject(id: number | Interceptor) {
+		const index = this.getInterceptorIndex(id);
+		if (this._fns[index]) {
+			this._fns[index] = null;
+		}
+	}
+
+	update(id: number | Interceptor, fn: Interceptor) {
+		const index = this.getInterceptorIndex(id);
+		if (this._fns[index]) {
+			this._fns[index] = fn;
+			return id;
+		} else {
+			return false;
+		}
+	}
+
+	use(fn: Interceptor) {
+		this._fns = [...this._fns, fn];
+		return this._fns.length - 1;
+	}
+}
+
+// `createInterceptors()` response, meant for external use as it does not
+// expose internals
+export interface Middleware<Req, Res, Err, Options> {
+	error: Pick<
+		Interceptors<ErrInterceptor<Err, Res, Req, Options>>,
+		"eject" | "use"
+	>;
+	request: Pick<Interceptors<ReqInterceptor<Req, Options>>, "eject" | "use">;
+	response: Pick<
+		Interceptors<ResInterceptor<Res, Req, Options>>,
+		"eject" | "use"
+	>;
+}
+
+// do not add `Middleware` as return type so we can use _fns internally
+export const createInterceptors = <Req, Res, Err, Options>() => ({
+	error: new Interceptors<ErrInterceptor<Err, Res, Req, Options>>(),
+	request: new Interceptors<ReqInterceptor<Req, Options>>(),
+	response: new Interceptors<ResInterceptor<Res, Req, Options>>(),
+});
+
+const defaultQuerySerializer = createQuerySerializer({
+	allowReserved: false,
+	array: {
+		explode: true,
+		style: "form",
+	},
+	object: {
+		explode: true,
+		style: "deepObject",
+	},
+});
+
+const defaultHeaders = {
+	"Content-Type": "application/json",
+};
+
+export const createConfig = <T extends ClientOptions = ClientOptions>(
+	override: Config<Omit<ClientOptions, keyof T> & T> = {},
+): Config<Omit<ClientOptions, keyof T> & T> => ({
+	...jsonBodySerializer,
+	headers: defaultHeaders,
+	parseAs: "auto",
+	querySerializer: defaultQuerySerializer,
+	...override,
+});

apps/client/app/api-client/core/auth.gen.ts

@@ -0,0 +1,42 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+export type AuthToken = string | undefined;
+
+export interface Auth {
+	/**
+	 * Which part of the request do we use to send the auth?
+	 *
+	 * @default 'header'
+	 */
+	in?: "header" | "query" | "cookie";
+	/**
+	 * Header or query parameter name.
+	 *
+	 * @default 'Authorization'
+	 */
+	name?: string;
+	scheme?: "basic" | "bearer";
+	type: "apiKey" | "http";
+}
+
+export const getAuthToken = async (
+	auth: Auth,
+	callback: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken,
+): Promise<string | undefined> => {
+	const token =
+		typeof callback === "function" ? await callback(auth) : callback;
+
+	if (!token) {
+		return;
+	}
+
+	if (auth.scheme === "bearer") {
+		return `Bearer ${token}`;
+	}
+
+	if (auth.scheme === "basic") {
+		return `Basic ${btoa(token)}`;
+	}
+
+	return token;
+};

apps/client/app/api-client/core/bodySerializer.gen.ts

@@ -0,0 +1,92 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import type {
+	ArrayStyle,
+	ObjectStyle,
+	SerializerOptions,
+} from "./pathSerializer.gen";
+
+export type QuerySerializer = (query: Record<string, unknown>) => string;
+
+export type BodySerializer = (body: any) => any;
+
+export interface QuerySerializerOptions {
+	allowReserved?: boolean;
+	array?: SerializerOptions<ArrayStyle>;
+	object?: SerializerOptions<ObjectStyle>;
+}
+
+const serializeFormDataPair = (
+	data: FormData,
+	key: string,
+	value: unknown,
+): void => {
+	if (typeof value === "string" || value instanceof Blob) {
+		data.append(key, value);
+	} else if (value instanceof Date) {
+		data.append(key, value.toISOString());
+	} else {
+		data.append(key, JSON.stringify(value));
+	}
+};
+
+const serializeUrlSearchParamsPair = (
+	data: URLSearchParams,
+	key: string,
+	value: unknown,
+): void => {
+	if (typeof value === "string") {
+		data.append(key, value);
+	} else {
+		data.append(key, JSON.stringify(value));
+	}
+};
+
+export const formDataBodySerializer = {
+	bodySerializer: <T extends Record<string, any> | Array<Record<string, any>>>(
+		body: T,
+	): FormData => {
+		const data = new FormData();
+
+		Object.entries(body).forEach(([key, value]) => {
+			if (value === undefined || value === null) {
+				return;
+			}
+			if (Array.isArray(value)) {
+				value.forEach((v) => serializeFormDataPair(data, key, v));
+			} else {
+				serializeFormDataPair(data, key, value);
+			}
+		});
+
+		return data;
+	},
+};
+
+export const jsonBodySerializer = {
+	bodySerializer: <T>(body: T): string =>
+		JSON.stringify(body, (_key, value) =>
+			typeof value === "bigint" ? value.toString() : value,
+		),
+};
+
+export const urlSearchParamsBodySerializer = {
+	bodySerializer: <T extends Record<string, any> | Array<Record<string, any>>>(
+		body: T,
+	): string => {
+		const data = new URLSearchParams();
+
+		Object.entries(body).forEach(([key, value]) => {
+			if (value === undefined || value === null) {
+				return;
+			}
+			if (Array.isArray(value)) {
+				value.forEach((v) => serializeUrlSearchParamsPair(data, key, v));
+			} else {
+				serializeUrlSearchParamsPair(data, key, value);
+			}
+		});
+
+		return data.toString();
+	},
+};

apps/client/app/api-client/core/params.gen.ts

@@ -0,0 +1,153 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+type Slot = "body" | "headers" | "path" | "query";
+
+export type Field =
+	| {
+			in: Exclude<Slot, "body">;
+			/**
+			 * Field name. This is the name we want the user to see and use.
+			 */
+			key: string;
+			/**
+			 * Field mapped name. This is the name we want to use in the request.
+			 * If omitted, we use the same value as `key`.
+			 */
+			map?: string;
+	  }
+	| {
+			in: Extract<Slot, "body">;
+			/**
+			 * Key isn't required for bodies.
+			 */
+			key?: string;
+			map?: string;
+	  };
+
+export interface Fields {
+	allowExtra?: Partial<Record<Slot, boolean>>;
+	args?: ReadonlyArray<Field>;
+}
+
+export type FieldsConfig = ReadonlyArray<Field | Fields>;
+
+const extraPrefixesMap: Record<string, Slot> = {
+	$body_: "body",
+	$headers_: "headers",
+	$path_: "path",
+	$query_: "query",
+};
+const extraPrefixes = Object.entries(extraPrefixesMap);
+
+type KeyMap = Map<
+	string,
+	{
+		in: Slot;
+		map?: string;
+	}
+>;
+
+const buildKeyMap = (fields: FieldsConfig, map?: KeyMap): KeyMap => {
+	if (!map) {
+		map = new Map();
+	}
+
+	for (const config of fields) {
+		if ("in" in config) {
+			if (config.key) {
+				map.set(config.key, {
+					in: config.in,
+					map: config.map,
+				});
+			}
+		} else if (config.args) {
+			buildKeyMap(config.args, map);
+		}
+	}
+
+	return map;
+};
+
+interface Params {
+	body: unknown;
+	headers: Record<string, unknown>;
+	path: Record<string, unknown>;
+	query: Record<string, unknown>;
+}
+
+const stripEmptySlots = (params: Params) => {
+	for (const [slot, value] of Object.entries(params)) {
+		if (value && typeof value === "object" && !Object.keys(value).length) {
+			delete params[slot as Slot];
+		}
+	}
+};
+
+export const buildClientParams = (
+	args: ReadonlyArray<unknown>,
+	fields: FieldsConfig,
+) => {
+	const params: Params = {
+		body: {},
+		headers: {},
+		path: {},
+		query: {},
+	};
+
+	const map = buildKeyMap(fields);
+
+	let config: FieldsConfig[number] | undefined;
+
+	for (const [index, arg] of args.entries()) {
+		if (fields[index]) {
+			config = fields[index];
+		}
+
+		if (!config) {
+			continue;
+		}
+
+		if ("in" in config) {
+			if (config.key) {
+				const field = map.get(config.key)!;
+				const name = field.map || config.key;
+				(params[field.in] as Record<string, unknown>)[name] = arg;
+			} else {
+				params.body = arg;
+			}
+		} else {
+			for (const [key, value] of Object.entries(arg ?? {})) {
+				const field = map.get(key);
+
+				if (field) {
+					const name = field.map || key;
+					(params[field.in] as Record<string, unknown>)[name] = value;
+				} else {
+					const extra = extraPrefixes.find(([prefix]) =>
+						key.startsWith(prefix),
+					);
+
+					if (extra) {
+						const [prefix, slot] = extra;
+						(params[slot] as Record<string, unknown>)[
+							key.slice(prefix.length)
+						] = value;
+					} else {
+						for (const [slot, allowed] of Object.entries(
+							config.allowExtra ?? {},
+						)) {
+							if (allowed) {
+								(params[slot as Slot] as Record<string, unknown>)[key] = value;
+								break;
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
+	stripEmptySlots(params);
+
+	return params;
+};

apps/client/app/api-client/core/pathSerializer.gen.ts

@@ -0,0 +1,181 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+interface SerializeOptions<T>
+	extends SerializePrimitiveOptions,
+		SerializerOptions<T> {}
+
+interface SerializePrimitiveOptions {
+	allowReserved?: boolean;
+	name: string;
+}
+
+export interface SerializerOptions<T> {
+	/**
+	 * @default true
+	 */
+	explode: boolean;
+	style: T;
+}
+
+export type ArrayStyle = "form" | "spaceDelimited" | "pipeDelimited";
+export type ArraySeparatorStyle = ArrayStyle | MatrixStyle;
+type MatrixStyle = "label" | "matrix" | "simple";
+export type ObjectStyle = "form" | "deepObject";
+type ObjectSeparatorStyle = ObjectStyle | MatrixStyle;
+
+interface SerializePrimitiveParam extends SerializePrimitiveOptions {
+	value: string;
+}
+
+export const separatorArrayExplode = (style: ArraySeparatorStyle) => {
+	switch (style) {
+		case "label":
+			return ".";
+		case "matrix":
+			return ";";
+		case "simple":
+			return ",";
+		default:
+			return "&";
+	}
+};
+
+export const separatorArrayNoExplode = (style: ArraySeparatorStyle) => {
+	switch (style) {
+		case "form":
+			return ",";
+		case "pipeDelimited":
+			return "|";
+		case "spaceDelimited":
+			return "%20";
+		default:
+			return ",";
+	}
+};
+
+export const separatorObjectExplode = (style: ObjectSeparatorStyle) => {
+	switch (style) {
+		case "label":
+			return ".";
+		case "matrix":
+			return ";";
+		case "simple":
+			return ",";
+		default:
+			return "&";
+	}
+};
+
+export const serializeArrayParam = ({
+	allowReserved,
+	explode,
+	name,
+	style,
+	value,
+}: SerializeOptions<ArraySeparatorStyle> & {
+	value: unknown[];
+}) => {
+	if (!explode) {
+		const joinedValues = (
+			allowReserved ? value : value.map((v) => encodeURIComponent(v as string))
+		).join(separatorArrayNoExplode(style));
+		switch (style) {
+			case "label":
+				return `.${joinedValues}`;
+			case "matrix":
+				return `;${name}=${joinedValues}`;
+			case "simple":
+				return joinedValues;
+			default:
+				return `${name}=${joinedValues}`;
+		}
+	}
+
+	const separator = separatorArrayExplode(style);
+	const joinedValues = value
+		.map((v) => {
+			if (style === "label" || style === "simple") {
+				return allowReserved ? v : encodeURIComponent(v as string);
+			}
+
+			return serializePrimitiveParam({
+				allowReserved,
+				name,
+				value: v as string,
+			});
+		})
+		.join(separator);
+	return style === "label" || style === "matrix"
+		? separator + joinedValues
+		: joinedValues;
+};
+
+export const serializePrimitiveParam = ({
+	allowReserved,
+	name,
+	value,
+}: SerializePrimitiveParam) => {
+	if (value === undefined || 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}=${allowReserved ? value : encodeURIComponent(value)}`;
+};
+
+export const serializeObjectParam = ({
+	allowReserved,
+	explode,
+	name,
+	style,
+	value,
+	valueOnly,
+}: SerializeOptions<ObjectSeparatorStyle> & {
+	value: Record<string, unknown> | Date;
+	valueOnly?: boolean;
+}) => {
+	if (value instanceof Date) {
+		return valueOnly ? value.toISOString() : `${name}=${value.toISOString()}`;
+	}
+
+	if (style !== "deepObject" && !explode) {
+		let values: string[] = [];
+		Object.entries(value).forEach(([key, v]) => {
+			values = [
+				...values,
+				key,
+				allowReserved ? (v as string) : encodeURIComponent(v as string),
+			];
+		});
+		const joinedValues = values.join(",");
+		switch (style) {
+			case "form":
+				return `${name}=${joinedValues}`;
+			case "label":
+				return `.${joinedValues}`;
+			case "matrix":
+				return `;${name}=${joinedValues}`;
+			default:
+				return joinedValues;
+		}
+	}
+
+	const separator = separatorObjectExplode(style);
+	const joinedValues = Object.entries(value)
+		.map(([key, v]) =>
+			serializePrimitiveParam({
+				allowReserved,
+				name: style === "deepObject" ? `${name}[${key}]` : key,
+				value: v as string,
+			}),
+		)
+		.join(separator);
+	return style === "label" || style === "matrix"
+		? separator + joinedValues
+		: joinedValues;
+};

apps/client/app/api-client/core/types.gen.ts

@@ -0,0 +1,120 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import type { Auth, AuthToken } from "./auth.gen";
+import type {
+	BodySerializer,
+	QuerySerializer,
+	QuerySerializerOptions,
+} from "./bodySerializer.gen";
+
+export interface Client<
+	RequestFn = never,
+	Config = unknown,
+	MethodFn = never,
+	BuildUrlFn = never,
+> {
+	/**
+	 * Returns the final request URL.
+	 */
+	buildUrl: BuildUrlFn;
+	connect: MethodFn;
+	delete: MethodFn;
+	get: MethodFn;
+	getConfig: () => Config;
+	head: MethodFn;
+	options: MethodFn;
+	patch: MethodFn;
+	post: MethodFn;
+	put: MethodFn;
+	request: RequestFn;
+	setConfig: (config: Config) => Config;
+	trace: MethodFn;
+}
+
+export interface Config {
+	/**
+	 * Auth token or a function returning auth token. The resolved value will be
+	 * added to the request payload as defined by its `security` array.
+	 */
+	auth?: ((auth: Auth) => Promise<AuthToken> | AuthToken) | AuthToken;
+	/**
+	 * A function for serializing request body parameter. By default,
+	 * {@link JSON.stringify()} will be used.
+	 */
+	bodySerializer?: BodySerializer | null;
+	/**
+	 * An object containing any HTTP headers that you want to pre-populate your
+	 * `Headers` object with.
+	 *
+	 * {@link https://developer.mozilla.org/docs/Web/API/Headers/Headers#init See more}
+	 */
+	headers?:
+		| RequestInit["headers"]
+		| Record<
+				string,
+				| string
+				| number
+				| boolean
+				| (string | number | boolean)[]
+				| null
+				| undefined
+				| unknown
+		  >;
+	/**
+	 * The request method.
+	 *
+	 * {@link https://developer.mozilla.org/docs/Web/API/fetch#method See more}
+	 */
+	method?:
+		| "CONNECT"
+		| "DELETE"
+		| "GET"
+		| "HEAD"
+		| "OPTIONS"
+		| "PATCH"
+		| "POST"
+		| "PUT"
+		| "TRACE";
+	/**
+	 * A function for serializing request query parameters. By default, arrays
+	 * will be exploded in form style, objects will be exploded in deepObject
+	 * style, and reserved characters are percent-encoded.
+	 *
+	 * This method will have no effect if the native `paramsSerializer()` Axios
+	 * API function is used.
+	 *
+	 * {@link https://swagger.io/docs/specification/serialization/#query View examples}
+	 */
+	querySerializer?: QuerySerializer | QuerySerializerOptions;
+	/**
+	 * A function validating request data. This is useful if you want to ensure
+	 * the request conforms to the desired shape, so it can be safely sent to
+	 * the server.
+	 */
+	requestValidator?: (data: unknown) => Promise<unknown>;
+	/**
+	 * A function transforming response data before it's returned. This is useful
+	 * for post-processing data, e.g. converting ISO strings into Date objects.
+	 */
+	responseTransformer?: (data: unknown) => Promise<unknown>;
+	/**
+	 * A function validating response data. This is useful if you want to ensure
+	 * the response conforms to the desired shape, so it can be safely passed to
+	 * the transformers and returned to the user.
+	 */
+	responseValidator?: (data: unknown) => Promise<unknown>;
+}
+
+type IsExactlyNeverOrNeverUndefined<T> = [T] extends [never]
+	? true
+	: [T] extends [never | undefined]
+		? [undefined] extends [T]
+			? false
+			: true
+		: false;
+
+export type OmitNever<T extends Record<string, unknown>> = {
+	[K in keyof T as IsExactlyNeverOrNeverUndefined<T[K]> extends true
+		? never
+		: K]: T[K];
+};

apps/client/app/api-client/index.ts

@@ -0,0 +1,3 @@
+// This file is auto-generated by @hey-api/openapi-ts
+export * from "./types.gen";
+export * from "./sdk.gen";

apps/client/app/api-client/sdk.gen.ts

@@ -0,0 +1,41 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+import type { Options as ClientOptions, TDataShape, Client } from "./client";
+import type {
+	GetApiV1VolumesData,
+	GetApiV1VolumesResponses,
+} from "./types.gen";
+import { client as _heyApiClient } from "./client.gen";
+
+export type Options<
+	TData extends TDataShape = TDataShape,
+	ThrowOnError extends boolean = boolean,
+> = ClientOptions<TData, ThrowOnError> & {
+	/**
+	 * You can provide a client instance returned by `createClient()` instead of
+	 * individual options. This might be also useful if you want to implement a
+	 * custom client.
+	 */
+	client?: Client;
+	/**
+	 * You can pass arbitrary values through the `meta` object. This can be
+	 * used to access values that aren't defined as part of the SDK function.
+	 */
+	meta?: Record<string, unknown>;
+};
+
+/**
+ * List all volumes
+ */
+export const getApiV1Volumes = <ThrowOnError extends boolean = false>(
+	options?: Options<GetApiV1VolumesData, ThrowOnError>,
+) => {
+	return (options?.client ?? _heyApiClient).get<
+		GetApiV1VolumesResponses,
+		unknown,
+		ThrowOnError
+	>({
+		url: "/api/v1/volumes",
+		...options,
+	});
+};

apps/client/app/api-client/types.gen.ts

@@ -0,0 +1,28 @@
+// This file is auto-generated by @hey-api/openapi-ts
+
+export type GetApiV1VolumesData = {
+	body?: never;
+	path?: never;
+	query?: never;
+	url: "/api/v1/volumes";
+};
+
+export type GetApiV1VolumesResponses = {
+	/**
+	 * A list of volumes
+	 */
+	200: {
+		volumes: Array<{
+			createdAt: string;
+			mountpoint: string;
+			name: string;
+		}>;
+	};
+};
+
+export type GetApiV1VolumesResponse =
+	GetApiV1VolumesResponses[keyof GetApiV1VolumesResponses];
+
+export type ClientOptions = {
+	baseUrl: "http://localhost:3000" | (string & {});
+};