@kubb/plugin-swr 5.0.0-beta.103 → 5.0.0-beta.106

package/dist/index.cjs

@@ -23,7 +23,7 @@ var __copyProps = (to, from, except, desc) => {
 	}
 	return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
 	value: mod,
 	enumerable: true
 }) : target, mod));
@@ -72,6 +72,26 @@ function operationFileEntry(node, name, extname = ".ts") {
 		path: node.path
 	};
 }
+/**
+* Resolves a dependency plugin's generated file for `node.operationId`, cached in `cache` (the
+* current node's `ctx.cache`) under the resolver's own plugin name. Several dependents reading the
+* same dependency for the same operation in one pass (a query plugin's several hook generators, the
+* MCP handler, ...) share one computed name and path instead of each calling `resolver.file` again.
+*
+* @example Cache `plugin-ts`'s file for the current operation
+* ```ts
+* const fileTs = resolveDependencyOperationFile({ cache: ctx.cache, node, resolver: tsResolver, root, output })
+* ```
+*/
+function resolveDependencyOperationFile(options) {
+	const { cache, node, resolver, root, output, group } = options;
+	return cache.getOrSet(`${resolver.pluginName}:operationFile`, () => resolver.file({
+		...operationFileEntry(node, node.operationId),
+		root,
+		output,
+		group: group ?? void 0
+	}));
+}
 function getOperationLink(node, link) {
 	if (!link) return null;
 	if (typeof link === "function") return link(node) ?? null;
@@ -165,13 +185,24 @@ function buildOperationComments(node, options = {}) {
 	if (!splitLines) return filteredComments;
 	return filteredComments.flatMap((text) => text.split(/\r?\n/).map((line) => line.trim())).filter((comment) => Boolean(comment));
 }
+const operationParameterGroupsByNode = /* @__PURE__ */ new WeakMap();
+/**
+* Groups an operation's parameters by location (`path`/`query`/`header`/`cookie`), deduping each
+* group by name. Every plugin generator visiting the same `OperationNode` shares one AST instance
+* (see `KubbDriver`), so the result is cached per node to avoid re-filtering and re-deduping the
+* same parameters once per plugin.
+*/
 function getOperationParameters(node) {
-	return {
+	const cached = operationParameterGroupsByNode.get(node);
+	if (cached) return cached;
+	const groups = {
 		path: dedupeParams(node.parameters.filter((param) => param.in === "path")),
 		query: dedupeParams(node.parameters.filter((param) => param.in === "query")),
 		header: dedupeParams(node.parameters.filter((param) => param.in === "header")),
 		cookie: dedupeParams(node.parameters.filter((param) => param.in === "cookie"))
 	};
+	operationParameterGroupsByNode.set(node, groups);
+	return groups;
 }
 function getStatusCodeNumber(statusCode) {
 	const code = Number(statusCode);
@@ -389,23 +420,30 @@ function resolveContractClient(options) {
 * (plugin-fetch or plugin-axios). Returns `null` when no contract plugin is in play (the inline
 * path). The plugin injects `.kubb/client.ts` at the global output root, the same path consumers
 * read `RequestConfig` / `ResponseErrorConfig` from.
+*
+* 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.
 */
 function resolveClientOperation(options) {
-	const { clientPlugin, driver, node, root, output } = options;
+	const { clientPlugin, driver, node, root, output, cache } = options;
 	if (!clientPlugin) return null;
-	const resolver = driver.getResolver(clientPlugin.pluginName);
-	const plugin = driver.getPlugin(clientPlugin.pluginName);
-	const file = resolver.file({
-		...operationFileEntry(node, node.operationId),
-		root,
-		output: plugin?.options?.output ?? output,
-		group: plugin?.options?.group ?? void 0
+	return cache.getOrSet(`${clientPlugin.pluginName}:clientOperation`, () => {
+		const resolver = driver.getResolver(clientPlugin.pluginName);
+		const plugin = driver.getPlugin(clientPlugin.pluginName);
+		const file = resolver.file({
+			...operationFileEntry(node, node.operationId),
+			root,
+			output: plugin?.options?.output ?? output,
+			group: plugin?.options?.group ?? void 0
+		});
+		return {
+			name: resolver.name(node.operationId),
+			path: file.path,
+			clientPath: node_path.default.resolve(root, ".kubb/client.ts")
+		};
 	});
-	return {
-		name: resolver.name(node.operationId),
-		path: file.path,
-		clientPath: node_path.default.resolve(root, ".kubb/client.ts")
-	};
 }
 //#endregion
 //#region ../../internals/tanstack-query/src/utils.ts
@@ -473,14 +511,16 @@ function buildGroupedRequestParam(node, options) {
 */
 function buildQueryOptionsParams(node, options) {
 	const { resolver, memberTypeWrapper } = options;
-	return (0, _kubb_plugin_ts.createFunctionParameters)({ params: [buildGroupedRequestParam(node, {
+	const groupedParam = buildGroupedRequestParam(node, {
 		resolver,
 		memberTypeWrapper
-	}), (0, _kubb_plugin_ts.createFunctionParameter)({
+	});
+	const configParam = (0, _kubb_plugin_ts.createFunctionParameter)({
 		name: "config",
 		type: `Partial<Omit<RequestConfig, 'path' | 'query' | 'body' | 'headers' | 'url'>>`,
 		default: "{}"
-	})].filter((param) => param !== null) });
+	});
+	return (0, _kubb_plugin_ts.createFunctionParameters)({ params: [groupedParam, configParam].filter((param) => param !== null) });
 }
 /**
 * Builds the call to a client `<op>` function inside a query/mutation hook body. The function takes
@@ -697,10 +737,12 @@ function buildMutationParamsNode(node, options) {
 	const { mutationKeyTypeName, mutationArgTypeName, resolver } = options;
 	const responseName = resolver.response.response(node);
 	const errorNames = resolveErrorNames(node, resolver);
+	const TData = responseName;
+	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
 	return (0, _kubb_plugin_ts.createFunctionParameters)({ params: [(0, _kubb_plugin_ts.createFunctionParameter)({
 		name: "options",
 		type: `{
-  mutation?: SWRMutationConfiguration<${responseName}, ${`ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`}, ${mutationKeyTypeName} | null, ${mutationArgTypeName}> & { throwOnError?: boolean },
+  mutation?: SWRMutationConfiguration<${TData}, ${TError}, ${mutationKeyTypeName} | null, ${mutationArgTypeName}> & { throwOnError?: boolean },
   client?: ${buildRequestConfigType(node)},
   shouldFetch?: boolean,
 }`,
@@ -795,17 +837,20 @@ function buildQueryParamsNode(node, options) {
 	const { resolver } = options;
 	const responseName = resolver.response.response(node);
 	const errorNames = resolveErrorNames(node, resolver);
+	const TData = responseName;
+	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
 	const optionsParam = (0, _kubb_plugin_ts.createFunctionParameter)({
 		name: "options",
 		type: `{
-  query?: SWRConfiguration<${[responseName, `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`].join(", ")}>,
+  query?: SWRConfiguration<${[TData, TError].join(", ")}>,
   client?: ${buildClientOptionType()},
   shouldFetch?: boolean,
   immutable?: boolean
 }`,
 		default: "{}"
 	});
-	return (0, _kubb_plugin_ts.createFunctionParameters)({ params: [buildGroupedRequestParam(node, { resolver }), optionsParam].filter((param) => param !== null) });
+	const groupedParam = buildGroupedRequestParam(node, { resolver });
+	return (0, _kubb_plugin_ts.createFunctionParameters)({ params: [groupedParam, optionsParam].filter((param) => param !== null) });
 }
 function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, node, tsResolver }) {
 	const responseName = tsResolver.response.response(node);
@@ -908,7 +953,8 @@ const mutationGenerator = (0, kubb_kit.defineGenerator)({
 			driver,
 			node,
 			root,
-			output
+			output,
+			cache: ctx.cache
 		});
 		if (!contractOp) return null;
 		const mutationHookName = resolver.mutation.name(node);
@@ -925,11 +971,10 @@ const mutationGenerator = (0, kubb_kit.defineGenerator)({
 				output,
 				group
 			}),
-			fileTs: tsResolver.file({
-				name: node.operationId,
-				extname: ".ts",
-				tag: node.tags[0] ?? "default",
-				path: node.path,
+			fileTs: resolveDependencyOperationFile({
+				cache: ctx.cache,
+				node,
+				resolver: tsResolver,
 				root,
 				output: pluginTs.options?.output ?? output,
 				group: pluginTs.options?.group
@@ -1035,7 +1080,8 @@ const queryGenerator = (0, kubb_kit.defineGenerator)({
 			driver,
 			node,
 			root,
-			output
+			output,
+			cache: ctx.cache
 		});
 		if (!contractOp) return null;
 		const queryName = resolver.query.name(node);
@@ -1052,11 +1098,10 @@ const queryGenerator = (0, kubb_kit.defineGenerator)({
 				output,
 				group
 			}),
-			fileTs: tsResolver.file({
-				name: node.operationId,
-				extname: ".ts",
-				tag: node.tags[0] ?? "default",
-				path: node.path,
+			fileTs: resolveDependencyOperationFile({
+				cache: ctx.cache,
+				node,
+				resolver: tsResolver,
 				root,
 				output: pluginTs.options?.output ?? output,
 				group: pluginTs.options?.group