@kubb/plugin-react-query 5.6.0 → 5.6.2

package/dist/index.js

@@ -1,5 +1,6 @@
 import { Diagnostics, Resolver, Url, addGenerator, ast, createResolver, defineExtension, defineGenerator, setMacros, setResolver, useConfig } from "kubb/kit";
 import path from "node:path";
+import { pluginZodName } from "@kubb/plugin-zod";
 import { File, Function, Type, jsxRenderer } from "kubb/jsx";
 import { createFunctionParameter, createFunctionParameters, createObjectBindingPattern, createTypeLiteral, functionPrinter, pluginTsName } from "@kubb/plugin-ts";
 import { Fragment, jsx, jsxs } from "kubb/jsx/jsx-runtime";
@@ -331,7 +332,74 @@ 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
 /**
@@ -506,13 +574,14 @@ function resolveClientOperation(options) {
 //#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,
@@ -524,8 +593,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),
@@ -1647,7 +1716,7 @@ function createQueryGenerator({ name, variant }) {
 			const queryOptionsName = variantResolver.optionsName(node);
 			const queryKeyName = variantResolver.keyName(node);
 			const queryKeyTypeName = variantResolver.keyTypeName(node);
-			const tsResolver = driver.getResolver(pluginTsName);
+			const tsResolver = resolveOperationTypes(driver, resolver.pluginName).resolver;
 			const hook = resolveHookFile(node, ctx, {
 				name: queryName,
 				output,
@@ -2078,7 +2147,7 @@ const pluginReactQuery = defineExtension({
 		version,
 		compatibility
 	},
-	dependencies: { [pluginTsName]: {} },
+	dependencies: { [pluginTsName]: { optional: true } },
 	setup(options) {
 		const { output = {
 			path: "hooks",