@kubb/plugin-vue-query 5.6.0 → 5.6.2

package/dist/index.js

@@ -1,6 +1,7 @@
 import { Diagnostics, Resolver, Url, addGenerator, ast, createResolver, defineExtension, defineGenerator, setMacros, setResolver, useConfig } from "kubb/kit";
 import path from "node:path";
 import { createFunctionParameter, createFunctionParameters, createObjectBindingPattern, createTypeLiteral, functionPrinter, pluginTsName } from "@kubb/plugin-ts";
+import { pluginZodName } from "@kubb/plugin-zod";
 import { File, Function, Type, jsxRenderer } from "kubb/jsx";
 import { Fragment, jsx, jsxs } from "kubb/jsx/jsx-runtime";
 //#endregion
@@ -330,17 +331,256 @@ var compatibility = {
 };
 //#endregion
 //#region package.json
-var version = "5.6.0";
+var version = "5.6.2";
+//#endregion
+//#region ../../internals/client/src/resolveOperationTypes.ts
+/**
+* A `plugin-ts` shaped resolver whose operation type names point at the types `pluginZod({ inferred })`
+* exports next to each schema, so code written against `plugin-ts` names picks up the zod types.
+*/
+function toZodTypeResolver(resolver) {
+	const type = (name) => resolver.schema.type(name);
+	return {
+		...resolver,
+		file: resolver.file.bind(resolver),
+		param: {
+			name: (node, p) => type(resolver.param.name(node, p)),
+			path: (node, p) => type(resolver.param.path(node, p)),
+			query: (node, p) => type(resolver.param.query(node, p)),
+			headers: (node, p) => type(resolver.param.headers(node, p))
+		},
+		response: {
+			body: (node) => type(resolver.response.body(node)),
+			status: (node, statusCode) => type(resolver.response.status(node, statusCode)),
+			response: (node) => type(resolver.response.response(node)),
+			responses: (node) => type(resolver.response.responses(node)),
+			options: (node) => resolver.response.options(node)
+		}
+	};
+}
+/**
+* Picks the plugin generated clients, query hooks, and MCP handlers take their operation types from.
+*
+* `pluginZod({ inferred: 'codec' })` wins, so a codec param takes its domain value. Otherwise `plugin-ts`
+* wins when it is in the pipeline, and without it any `pluginZod({ inferred })`. Throws
+* `KUBB_MISSING_DEPENDENCY` for `pluginName` when neither is available.
+*
+* @example
+* ```ts
+* const types = resolveOperationTypes(ctx.driver, ctx.plugin.name)
+* types.response.options(node) // 'GetPetByIdOptions', or 'GetPetByIdOptionsSchemaType' from zod
+* ```
+*/
+function resolveOperationTypes(driver, pluginName) {
+	const pluginTs = driver.getPlugin(pluginTsName);
+	const pluginZod = driver.getPlugin(pluginZodName);
+	if (pluginTs && pluginZod?.options?.inferred !== "codec") {
+		const resolver = driver.getResolver(pluginTsName);
+		return {
+			response: resolver.response,
+			resolver,
+			output: pluginTs.options?.output,
+			group: pluginTs.options?.group ?? void 0
+		};
+	}
+	if (!pluginZod?.options?.inferred) throw new Diagnostics.Error({
+		code: Diagnostics.code.missingDependency,
+		severity: "error",
+		message: `Plugin "${pluginName}" has no source for operation types.`,
+		help: `Add \`pluginTs()\` before "${pluginName}", or add \`pluginZod({ inferred: true })\`.`,
+		location: { kind: "config" },
+		plugin: pluginName
+	});
+	const resolver = toZodTypeResolver(driver.getResolver(pluginZodName));
+	return {
+		response: resolver.response,
+		resolver,
+		output: pluginZod.options.output,
+		group: pluginZod.options.group ?? void 0
+	};
+}
+//#endregion
+//#region ../../internals/client/src/resolveClient.ts
+/**
+* Resolves which client plugin a consumer (react-query, vue-query, swr, mcp) should call for an
+* operation, shared so the selection rules and diagnostics stay in one place.
+*
+* Every client runtime lives in a dedicated client plugin, so a consumer always calls a registered
+* contract client plugin (plugin-fetch, plugin-axios, or plugin-client) and never emits its own
+* inline client:
+*
+* - `contract` — a registered contract client plugin owns the `<op>` functions and the consumer
+*   imports and calls them.
+* - `error` — no client plugin is registered, several are registered without a selector, the
+*   requested one is missing, or `client` is not a known selector.
+*
+* The `client` string selects explicitly (`'fetch'` / `'axios'` / `'client'`); when it is unset a
+* lone registered contract client plugin is picked up automatically.
+*/
+const pluginFetchName = "plugin-fetch";
+const pluginAxiosName = "plugin-axios";
+const pluginClientName = "plugin-client";
+const selectorToPlugin = {
+	fetch: pluginFetchName,
+	axios: pluginAxiosName,
+	client: pluginClientName
+};
+const contractPlugins = [
+	pluginFetchName,
+	pluginAxiosName,
+	pluginClientName
+];
+/**
+* Applies the `client` resolution rules. See the module comment for the strategy shape.
+*
+* @example
+* ```ts
+* resolveClient({ client: 'fetch', pluginNames: ['plugin-ts', 'plugin-fetch'] })
+* // { kind: 'contract', pluginName: 'plugin-fetch' }
+* ```
+*
+* @example
+* ```ts
+* resolveClient({ client: undefined, pluginNames: ['plugin-ts'] })
+* // { kind: 'error', code: 'KUBB_MISSING_DEPENDENCY', message: 'No client plugin is registered.', help: 'Add …' }
+* ```
+*/
+function resolveClient(options) {
+	const { client, pluginNames } = options;
+	const has = (name) => pluginNames.includes(name);
+	if (client === "fetch" || client === "axios" || client === "client") {
+		const pluginName = selectorToPlugin[client];
+		if (!has(pluginName)) return {
+			kind: "error",
+			code: Diagnostics.code.missingDependency,
+			message: `\`client: '${client}'\` is set but \`@kubb/plugin-${client}\` is not registered in \`plugins\`.`,
+			help: `Add \`@kubb/plugin-${client}\` to \`plugins\`, or drop \`client\` to use a different client plugin.`
+		};
+		return {
+			kind: "contract",
+			pluginName
+		};
+	}
+	if (client !== void 0) return {
+		kind: "error",
+		code: Diagnostics.code.invalidPluginOptions,
+		message: `Option \`client\` is ${typeof client === "string" ? `'${client}'` : String(client)}, but it must be one of 'fetch', 'axios', 'client'.`,
+		help: "Set `client` to one of those values, or drop it to use the registered client plugin."
+	};
+	const registered = contractPlugins.filter(has);
+	if (registered.length === 1) return {
+		kind: "contract",
+		pluginName: registered[0]
+	};
+	if (registered.length > 1) return {
+		kind: "error",
+		code: Diagnostics.code.invalidPluginOptions,
+		message: `Multiple client plugins are registered (${registered.map((name) => `\`@kubb/${name}\``).join(", ")}) and \`client\` is not set.`,
+		help: "Set `client: 'fetch' | 'axios' | 'client'` to choose which client the hooks call, or register a single client plugin."
+	};
+	return {
+		kind: "error",
+		code: Diagnostics.code.missingDependency,
+		message: "No client plugin is registered.",
+		help: "Add `@kubb/plugin-fetch`, `@kubb/plugin-axios`, or `@kubb/plugin-client` to `plugins` so the generated code has an HTTP client to call."
+	};
+}
+/**
+* Resolves the contract client during a consumer plugin's setup hook.
+* It extracts the plugin names from the raw `plugins` config and applies {@link resolveClient}.
+* On a misconfiguration it throws a config diagnostic tagged with `plugin`, so every consumer
+* fails fast with the same message.
+*/
+function resolveContractClient(options) {
+	const { plugin, client, plugins = [] } = options;
+	const resolved = resolveClient({
+		client,
+		pluginNames: plugins.map((plugin) => plugin.name).filter((name) => Boolean(name))
+	});
+	if (resolved.kind === "error") {
+		const { code, message, help } = resolved;
+		throw new Diagnostics.Error({
+			code,
+			severity: "error",
+			message,
+			help,
+			location: { kind: "config" },
+			plugin
+		});
+	}
+	return resolved;
+}
+//#endregion
+//#region ../../internals/client/src/resolveClientOperation.ts
+function isRelativeImport(importPath) {
+	return importPath.startsWith(".");
+}
+function resolveImportPath(options) {
+	const { importPath, operationFile } = options;
+	return isRelativeImport(importPath) ? path.resolve(path.dirname(operationFile), importPath) : importPath;
+}
+/**
+* Resolves the contract client `<op>` a consumer (query hook, MCP handler) imports, by looking up
+* the registered contract client plugin's resolver and output. Works for any contract client plugin
+* (plugin-fetch, plugin-axios, or plugin-client). Returns `null` when no contract plugin is in play (the inline
+* path), or when the client plugin's `exclude` / `include` leaves this operation out, since it then
+* emits no `<op>` to import. plugin-fetch / plugin-axios inject `.kubb/client.ts` at the global
+* output root, the same path consumers read `RequestConfig` / `ResponseErrorConfig` from.
+* With plugin-client they come from the user's `importPath` module instead.
+*
+* The result is cached in the current node's `cache` (`ctx.cache`) under the client plugin's name,
+* so several dependents reading the same client plugin for one operation in a single pass
+* (react-query's query/mutation/infinite generators, vue-query, swr, the MCP handler, ...) share
+* one computed result instead of each re-deriving the name and path.
+*
+* `returnType`, `output`, and `group` are the client plugin's options for this operation, after its
+* `override` entries, the same resolution its own generator sees. A dependent's generated call body
+* and import path therefore match the `<op>` actually emitted, even when an `override` changes it.
+*/
+function resolveClientOperation(options) {
+	const { clientPlugin, driver, node, root, output, cache } = options;
+	if (!clientPlugin) return null;
+	return cache.ensureItem(`${clientPlugin.pluginName}:clientOperation`, () => {
+		const resolver = driver.getResolver(clientPlugin.pluginName);
+		const pluginOptions = driver.getPlugin(clientPlugin.pluginName)?.options ?? {};
+		const { exclude, include, override } = pluginOptions;
+		const operationOptions = Boolean(exclude?.length || include?.length || override?.length) && resolver.default ? resolver.default.options(node, {
+			options: pluginOptions,
+			exclude,
+			include,
+			override
+		}) : pluginOptions;
+		if (!operationOptions) return null;
+		const file = resolver.file({
+			...operationFileEntry(node, node.operationId),
+			root,
+			output: operationOptions.output ?? output,
+			group: operationOptions.group ?? void 0
+		});
+		const { importPath } = operationOptions;
+		return {
+			name: resolver.name(node.operationId),
+			path: file.path,
+			clientPath: importPath === void 0 ? path.resolve(root, ".kubb/client.ts") : resolveImportPath({
+				importPath,
+				operationFile: file.path
+			}),
+			clientPathIsFile: importPath === void 0 || isRelativeImport(importPath),
+			returnType: operationOptions.returnType ?? "full"
+		};
+	});
+}
 //#endregion
 //#region ../../internals/tanstack-query/src/components/HookFile.tsx
 /**
-* Resolves what every TanStack hook file shares: its file, the `@kubb/plugin-ts` file and type names, banner and footer.
+* Resolves what every TanStack hook file shares: its file, the operation types file and names (`@kubb/plugin-ts`, or
+* `pluginZod({ inferred: 'codec' })`), banner and footer.
 */
 function resolveHookFile(node, ctx, options) {
 	const { name, output, group, contractOp, keyTypeName, extraTypeNames = [] } = options;
 	const { config, root, resolver } = ctx;
-	const pluginTs = ctx.requirePlugin(pluginTsName);
-	const tsResolver = ctx.driver.getResolver(pluginTsName);
+	const types = resolveOperationTypes(ctx.driver, resolver.pluginName);
+	const tsResolver = types.resolver;
 	const file = resolver.file({
 		...operationFileEntry(node, name),
 		root,
@@ -352,8 +592,8 @@ function resolveHookFile(node, ctx, options) {
 		node,
 		resolver: tsResolver,
 		root,
-		output: pluginTs.options?.output ?? output,
-		group: pluginTs.options?.group
+		output: types.output ?? output,
+		group: types.group
 	});
 	const importedTypeNames = [
 		tsResolver.response.options(node),
@@ -978,177 +1218,6 @@ function QueryKey({ name, node, tsResolver, typeName, transformer, variant = "qu
 	})] });
 }
 //#endregion
-//#region ../../internals/client/src/resolveClient.ts
-/**
-* Resolves which client plugin a consumer (react-query, vue-query, swr, mcp) should call for an
-* operation, shared so the selection rules and diagnostics stay in one place.
-*
-* Every client runtime lives in a dedicated client plugin, so a consumer always calls a registered
-* contract client plugin (plugin-fetch, plugin-axios, or plugin-client) and never emits its own
-* inline client:
-*
-* - `contract` — a registered contract client plugin owns the `<op>` functions and the consumer
-*   imports and calls them.
-* - `error` — no client plugin is registered, several are registered without a selector, the
-*   requested one is missing, or `client` is not a known selector.
-*
-* The `client` string selects explicitly (`'fetch'` / `'axios'` / `'client'`); when it is unset a
-* lone registered contract client plugin is picked up automatically.
-*/
-const pluginFetchName = "plugin-fetch";
-const pluginAxiosName = "plugin-axios";
-const pluginClientName = "plugin-client";
-const selectorToPlugin = {
-	fetch: pluginFetchName,
-	axios: pluginAxiosName,
-	client: pluginClientName
-};
-const contractPlugins = [
-	pluginFetchName,
-	pluginAxiosName,
-	pluginClientName
-];
-/**
-* Applies the `client` resolution rules. See the module comment for the strategy shape.
-*
-* @example
-* ```ts
-* resolveClient({ client: 'fetch', pluginNames: ['plugin-ts', 'plugin-fetch'] })
-* // { kind: 'contract', pluginName: 'plugin-fetch' }
-* ```
-*
-* @example
-* ```ts
-* resolveClient({ client: undefined, pluginNames: ['plugin-ts'] })
-* // { kind: 'error', code: 'KUBB_MISSING_DEPENDENCY', message: 'No client plugin is registered.', help: 'Add …' }
-* ```
-*/
-function resolveClient(options) {
-	const { client, pluginNames } = options;
-	const has = (name) => pluginNames.includes(name);
-	if (client === "fetch" || client === "axios" || client === "client") {
-		const pluginName = selectorToPlugin[client];
-		if (!has(pluginName)) return {
-			kind: "error",
-			code: Diagnostics.code.missingDependency,
-			message: `\`client: '${client}'\` is set but \`@kubb/plugin-${client}\` is not registered in \`plugins\`.`,
-			help: `Add \`@kubb/plugin-${client}\` to \`plugins\`, or drop \`client\` to use a different client plugin.`
-		};
-		return {
-			kind: "contract",
-			pluginName
-		};
-	}
-	if (client !== void 0) return {
-		kind: "error",
-		code: Diagnostics.code.invalidPluginOptions,
-		message: `Option \`client\` is ${typeof client === "string" ? `'${client}'` : String(client)}, but it must be one of 'fetch', 'axios', 'client'.`,
-		help: "Set `client` to one of those values, or drop it to use the registered client plugin."
-	};
-	const registered = contractPlugins.filter(has);
-	if (registered.length === 1) return {
-		kind: "contract",
-		pluginName: registered[0]
-	};
-	if (registered.length > 1) return {
-		kind: "error",
-		code: Diagnostics.code.invalidPluginOptions,
-		message: `Multiple client plugins are registered (${registered.map((name) => `\`@kubb/${name}\``).join(", ")}) and \`client\` is not set.`,
-		help: "Set `client: 'fetch' | 'axios' | 'client'` to choose which client the hooks call, or register a single client plugin."
-	};
-	return {
-		kind: "error",
-		code: Diagnostics.code.missingDependency,
-		message: "No client plugin is registered.",
-		help: "Add `@kubb/plugin-fetch`, `@kubb/plugin-axios`, or `@kubb/plugin-client` to `plugins` so the generated code has an HTTP client to call."
-	};
-}
-/**
-* Resolves the contract client during a consumer plugin's setup hook.
-* It extracts the plugin names from the raw `plugins` config and applies {@link resolveClient}.
-* On a misconfiguration it throws a config diagnostic tagged with `plugin`, so every consumer
-* fails fast with the same message.
-*/
-function resolveContractClient(options) {
-	const { plugin, client, plugins = [] } = options;
-	const resolved = resolveClient({
-		client,
-		pluginNames: plugins.map((plugin) => plugin.name).filter((name) => Boolean(name))
-	});
-	if (resolved.kind === "error") {
-		const { code, message, help } = resolved;
-		throw new Diagnostics.Error({
-			code,
-			severity: "error",
-			message,
-			help,
-			location: { kind: "config" },
-			plugin
-		});
-	}
-	return resolved;
-}
-//#endregion
-//#region ../../internals/client/src/resolveClientOperation.ts
-function isRelativeImport(importPath) {
-	return importPath.startsWith(".");
-}
-function resolveImportPath(options) {
-	const { importPath, operationFile } = options;
-	return isRelativeImport(importPath) ? path.resolve(path.dirname(operationFile), importPath) : importPath;
-}
-/**
-* Resolves the contract client `<op>` a consumer (query hook, MCP handler) imports, by looking up
-* the registered contract client plugin's resolver and output. Works for any contract client plugin
-* (plugin-fetch, plugin-axios, or plugin-client). Returns `null` when no contract plugin is in play (the inline
-* path), or when the client plugin's `exclude` / `include` leaves this operation out, since it then
-* emits no `<op>` to import. plugin-fetch / plugin-axios inject `.kubb/client.ts` at the global
-* output root, the same path consumers read `RequestConfig` / `ResponseErrorConfig` from.
-* With plugin-client they come from the user's `importPath` module instead.
-*
-* The result is cached in the current node's `cache` (`ctx.cache`) under the client plugin's name,
-* so several dependents reading the same client plugin for one operation in a single pass
-* (react-query's query/mutation/infinite generators, vue-query, swr, the MCP handler, ...) share
-* one computed result instead of each re-deriving the name and path.
-*
-* `returnType`, `output`, and `group` are the client plugin's options for this operation, after its
-* `override` entries, the same resolution its own generator sees. A dependent's generated call body
-* and import path therefore match the `<op>` actually emitted, even when an `override` changes it.
-*/
-function resolveClientOperation(options) {
-	const { clientPlugin, driver, node, root, output, cache } = options;
-	if (!clientPlugin) return null;
-	return cache.ensureItem(`${clientPlugin.pluginName}:clientOperation`, () => {
-		const resolver = driver.getResolver(clientPlugin.pluginName);
-		const pluginOptions = driver.getPlugin(clientPlugin.pluginName)?.options ?? {};
-		const { exclude, include, override } = pluginOptions;
-		const operationOptions = Boolean(exclude?.length || include?.length || override?.length) && resolver.default ? resolver.default.options(node, {
-			options: pluginOptions,
-			exclude,
-			include,
-			override
-		}) : pluginOptions;
-		if (!operationOptions) return null;
-		const file = resolver.file({
-			...operationFileEntry(node, node.operationId),
-			root,
-			output: operationOptions.output ?? output,
-			group: operationOptions.group ?? void 0
-		});
-		const { importPath } = operationOptions;
-		return {
-			name: resolver.name(node.operationId),
-			path: file.path,
-			clientPath: importPath === void 0 ? path.resolve(root, ".kubb/client.ts") : resolveImportPath({
-				importPath,
-				operationFile: file.path
-			}),
-			clientPathIsFile: importPath === void 0 || isRelativeImport(importPath),
-			returnType: operationOptions.returnType ?? "full"
-		};
-	});
-}
-//#endregion
 //#region src/components/QueryOptions.tsx
 const declarationPrinter$2 = functionPrinter({ mode: "declaration" });
 const callPrinter$2 = functionPrinter({ mode: "call" });
@@ -1328,7 +1397,7 @@ const infiniteQueryGenerator = defineGenerator({
 			contractOp,
 			keyTypeName: queryKeyTypeName,
 			extraTypeNames: [resolvePageParamType(node, {
-				resolver: ctx.driver.getResolver(pluginTsName),
+				resolver: resolveOperationTypes(ctx.driver, ctx.resolver.pluginName).resolver,
 				initialPageParam: infiniteOptions.initialPageParam,
 				queryParam: infiniteOptions.queryParam
 			}).queryParamsTypeName]
@@ -1723,7 +1792,7 @@ const pluginVueQuery = defineExtension({
 		version,
 		compatibility
 	},
-	dependencies: { [pluginTsName]: {} },
+	dependencies: { [pluginTsName]: { optional: true } },
 	setup(options) {
 		const { output = {
 			path: "hooks",