@kubb/plugin-react-query 5.6.0 → 5.6.1

package/dist/index.cjs

@@ -27,6 +27,7 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 let kubb_kit = require("kubb/kit");
 let node_path = require("node:path");
 node_path = __toESM(node_path, 1);
+let _kubb_plugin_zod = require("@kubb/plugin-zod");
 let kubb_jsx = require("kubb/jsx");
 let _kubb_plugin_ts = require("@kubb/plugin-ts");
 let kubb_jsx_jsx_runtime = require("kubb/jsx/jsx-runtime");
@@ -358,7 +359,74 @@ var compatibility = {
 };
 //#endregion
 //#region package.json
-var version = "5.6.0";
+var version = "5.6.1";
+//#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(_kubb_plugin_ts.pluginTsName);
+	const pluginZod = driver.getPlugin(_kubb_plugin_zod.pluginZodName);
+	if (pluginTs && pluginZod?.options?.inferred !== "codec") {
+		const resolver = driver.getResolver(_kubb_plugin_ts.pluginTsName);
+		return {
+			response: resolver.response,
+			resolver,
+			output: pluginTs.options?.output,
+			group: pluginTs.options?.group ?? void 0
+		};
+	}
+	if (!pluginZod?.options?.inferred) throw new kubb_kit.Diagnostics.Error({
+		code: kubb_kit.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(_kubb_plugin_zod.pluginZodName));
+	return {
+		response: resolver.response,
+		resolver,
+		output: pluginZod.options.output,
+		group: pluginZod.options.group ?? void 0
+	};
+}
 //#endregion
 //#region ../../internals/client/src/resolveClient.ts
 /**
@@ -533,13 +601,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(_kubb_plugin_ts.pluginTsName);
-	const tsResolver = ctx.driver.getResolver(_kubb_plugin_ts.pluginTsName);
+	const types = resolveOperationTypes(ctx.driver, resolver.pluginName);
+	const tsResolver = types.resolver;
 	const file = resolver.file({
 		...operationFileEntry(node, name),
 		root,
@@ -551,8 +620,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),
@@ -1674,7 +1743,7 @@ function createQueryGenerator({ name, variant }) {
 			const queryOptionsName = variantResolver.optionsName(node);
 			const queryKeyName = variantResolver.keyName(node);
 			const queryKeyTypeName = variantResolver.keyTypeName(node);
-			const tsResolver = driver.getResolver(_kubb_plugin_ts.pluginTsName);
+			const tsResolver = resolveOperationTypes(driver, resolver.pluginName).resolver;
 			const hook = resolveHookFile(node, ctx, {
 				name: queryName,
 				output,
@@ -2105,7 +2174,7 @@ const pluginReactQuery = (0, kubb_kit.defineExtension)({
 		version,
 		compatibility
 	},
-	dependencies: { [_kubb_plugin_ts.pluginTsName]: {} },
+	dependencies: { [_kubb_plugin_ts.pluginTsName]: { optional: true } },
 	setup(options) {
 		const { output = {
 			path: "hooks",