@kubb/plugin-swr 5.0.0-beta.85 → 5.0.0-beta.86

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { t as __name } from "./rolldown-runtime-C0LytTxp.js";
-import { Exclude, Group, Include, Output, OutputOptions, Override, PluginFactoryOptions, Resolver, ast } from "kubb/kit";
+import { Exclude, Group, Include, Output, OutputOptions, Override, PluginFactoryOptions, Resolver, ResolverPatch, ast } from "kubb/kit";
 //#region ../../internals/client/src/resolveClient.d.ts
 /**
  * Resolves which client plugin a consumer (react-query, vue-query, swr, mcp) should call for an
@@ -31,56 +31,85 @@ type Transformer = (props: {
 //#endregion
 //#region src/types.d.ts
 /**
- * Resolver for SWR that provides naming methods for hook functions.
+ * The concrete resolver type for `@kubb/plugin-swr`.
+ * Extends the base `Resolver` (which provides `default` naming and option helpers, the top-level
+ * `name` casing, and the `file` builder) with plugin-specific naming namespaces for the generated
+ * `useSWR` and `useSWRMutation` hooks and their companion helpers.
  */
 type ResolverSwr = Resolver & {
   /**
-   * Resolves the base function name for an operation.
-   *
-   * @example Resolving base operation names
-   * `resolver.resolveName('show pet by id') // -> 'showPetById'`
-   */
-  resolveName(this: ResolverSwr, name: string): string;
-  /**
-   * Resolves the output file name for a hook module.
-   */
-  resolvePathName(this: ResolverSwr, name: string, type?: 'file' | 'function' | 'type' | 'const'): string;
-  /**
-   * Resolves a query hook function name.
-   */
-  resolveQueryName(this: ResolverSwr, node: ast.OperationNode): string;
-  /**
-   * Resolves a mutation hook function name.
-   */
-  resolveMutationName(this: ResolverSwr, node: ast.OperationNode): string;
-  /**
-   * Resolves the query options helper name.
-   */
-  resolveQueryOptionsName(this: ResolverSwr, node: ast.OperationNode): string;
-  /**
-   * Resolves the query key helper name.
-   */
-  resolveQueryKeyName(this: ResolverSwr, node: ast.OperationNode): string;
-  /**
-   * Resolves the mutation key helper name.
-   */
-  resolveMutationKeyName(this: ResolverSwr, node: ast.OperationNode): string;
-  /**
-   * Resolves the query key type name.
-   */
-  resolveQueryKeyTypeName(this: ResolverSwr, node: ast.OperationNode): string;
-  /**
-   * Resolves the mutation key type name.
-   */
-  resolveMutationKeyTypeName(this: ResolverSwr, node: ast.OperationNode): string;
-  /**
-   * Resolves the mutation argument type name emitted alongside the mutation hook.
+   * Naming for the generated `useSWR` hook and its companion helpers.
    */
-  resolveMutationArgTypeName(this: ResolverSwr, node: ast.OperationNode): string;
+  query: {
+    /**
+     * Resolves a query hook function name.
+     *
+     * @example Query hook names
+     * `resolver.query.name(node) // → 'useGetPetById'`
+     */
+    name(node: ast.OperationNode): string;
+    /**
+     * Resolves the query options helper name.
+     *
+     * @example Query options helper names
+     * `resolver.query.optionsName(node) // → 'getPetByIdQueryOptions'`
+     */
+    optionsName(node: ast.OperationNode): string;
+    /**
+     * Resolves the query key helper name.
+     *
+     * @example Query key helper names
+     * `resolver.query.keyName(node) // → 'getPetByIdQueryKey'`
+     */
+    keyName(node: ast.OperationNode): string;
+    /**
+     * Resolves the query key type name.
+     *
+     * @example Query key type names
+     * `resolver.query.keyTypeName(node) // → 'GetPetByIdQueryKey'`
+     */
+    keyTypeName(node: ast.OperationNode): string;
+    /**
+     * Resolves the client function name generated inline by query hooks.
+     *
+     * @example Client function names
+     * `resolver.query.clientName(node) // → 'getPetById'`
+     */
+    clientName(node: ast.OperationNode): string;
+  };
   /**
-   * Resolves the client function name generated inline by query hooks.
+   * Naming for the generated `useSWRMutation` hook and its companion helpers.
    */
-  resolveClientName(this: ResolverSwr, node: ast.OperationNode): string;
+  mutation: {
+    /**
+     * Resolves a mutation hook function name.
+     *
+     * @example Mutation hook names
+     * `resolver.mutation.name(node) // → 'useUpdatePet'`
+     */
+    name(node: ast.OperationNode): string;
+    /**
+     * Resolves the mutation key helper name.
+     *
+     * @example Mutation key helper names
+     * `resolver.mutation.keyName(node) // → 'updatePetMutationKey'`
+     */
+    keyName(node: ast.OperationNode): string;
+    /**
+     * Resolves the mutation key type name.
+     *
+     * @example Mutation key type names
+     * `resolver.mutation.keyTypeName(node) // → 'UpdatePetMutationKey'`
+     */
+    keyTypeName(node: ast.OperationNode): string;
+    /**
+     * Resolves the mutation argument type name emitted alongside the mutation hook.
+     *
+     * @example Mutation argument type names
+     * `resolver.mutation.argTypeName(node) // → 'UpdatePetMutationArg'`
+     */
+    argTypeName(node: ast.OperationNode): string;
+  };
 };
 /**
  * Customize the queryKey.
@@ -173,7 +202,7 @@ type Options = OutputOptions & {
   /**
    * Override naming conventions for function names and types.
    */
-  resolver?: Partial<ResolverSwr> & ThisType<ResolverSwr>;
+  resolver?: ResolverPatch<ResolverSwr>;
   /**
    * Macros that rewrite generated nodes before printing.
    */

package/dist/index.js

@@ -1,7 +1,7 @@
 import { t as __name } from "./rolldown-runtime-C0LytTxp.js";
-import path from "node:path";
-import { ast, defineGenerator, definePlugin, defineResolver } from "kubb/kit";
+import { Resolver, ast, createResolver, defineGenerator, definePlugin } from "kubb/kit";
 import { createFunctionParameter, createFunctionParameters, createObjectBindingPattern, createTypeLiteral, functionPrinter, pluginTsName } from "@kubb/plugin-ts";
+import path from "node:path";
 import { File, Function, Type, jsxRenderer } from "kubb/jsx";
 import { Fragment, jsx, jsxs } from "kubb/jsx/jsx-runtime";
 //#region ../../internals/utils/src/casing.ts
@@ -31,31 +31,6 @@ function camelCase(text, { prefix = "", suffix = "" } = {}) {
 	return toCamelOrPascal(`${prefix} ${text} ${suffix}`, false);
 }
 //#endregion
-//#region ../../internals/utils/src/fs.ts
-/**
-* Builds a nested file path from a dotted name. Splits on dots that precede a letter
-* (so version numbers embedded in operationIds like `v2025.0` stay intact), camelCases
-* every earlier segment, applies `caseLast` to the final segment, and joins with `/`.
-*
-* Empty segments are dropped before joining. They arise when the name starts with a dot
-* followed by a letter (e.g. `..Schema` splits into `['..', 'Schema']` and `'..'` cases to
-* an empty string). Without this a leading `/` would form, which `path.resolve` reads as an
-* absolute path, letting generated files escape the configured output directory.
-*
-* @example Nested path from a dotted name
-* `toFilePath('pet.petId') // 'pet/petId'`
-*
-* @example PascalCase the final segment
-* `toFilePath('pet.Pet', pascalCase) // 'pet/Pet'`
-*
-* @example Suffix applied to the final segment only
-* `toFilePath('tag.tag', (part) => camelCase(part, { suffix: 'schema' })) // 'tag/tagSchema'`
-*/
-function toFilePath(name, caseLast = camelCase) {
-	const parts = name.split(/\.(?=[a-zA-Z])/);
-	return parts.map((part, i) => i === parts.length - 1 ? caseLast(part) : camelCase(part)).filter(Boolean).join("/");
-}
-//#endregion
 //#region ../../internals/utils/src/reserved.ts
 /**
 * JavaScript and Java reserved words.
@@ -311,13 +286,13 @@ function dedupeByCasedName(params) {
 //#region ../../internals/shared/src/operation.ts
 /**
 * Builds the `ResolverFileParams` every operation generator passes to
-* `resolver.resolveFile`: a file named `name`, tagged by the operation's first
+* `resolver.file`: a file named `name`, tagged by the operation's first
 * tag (or `'default'`), at the operation's path. Centralizes the entry object
 * that was repeated at dozens of call sites across the client and query plugins.
 *
 * @example
 * ```ts
-* resolver.resolveFile(operationFileEntry(node, node.operationId), { root, output, group })
+* resolver.file(operationFileEntry(node, node.operationId), { root, output, group })
 * ```
 */
 function operationFileEntry(node, name, extname = ".ts") {
@@ -455,10 +430,10 @@ function getPrimarySuccessResponse(node) {
 	return getOperationSuccessResponses(node)[0] ?? null;
 }
 function resolveErrorNames(node, resolver) {
-	return node.responses.filter((response) => isErrorStatusCode(response.statusCode)).map((response) => resolver.resolveResponseStatusName(node, response.statusCode));
+	return node.responses.filter((response) => isErrorStatusCode(response.statusCode)).map((response) => resolver.response.status(node, response.statusCode));
 }
 function resolveStatusCodeNames(node, resolver) {
-	return node.responses.map((response) => resolver.resolveResponseStatusName(node, response.statusCode));
+	return node.responses.map((response) => resolver.response.status(node, response.statusCode));
 }
 const typeNamesByResolver = /* @__PURE__ */ new WeakMap();
 function resolveOperationTypeNames(node, resolver, options = {}) {
@@ -475,11 +450,11 @@ function resolveOperationTypeNames(node, resolver, options = {}) {
 	const responseStatusNames = options.responseStatusNames === "error" ? resolveErrorNames(node, resolver) : options.responseStatusNames === false ? [] : resolveStatusCodeNames(node, resolver);
 	const exclude = new Set(options.exclude ?? []);
 	const paramNames = options.includeParams === false ? [] : [
-		...path.map((param) => resolver.resolvePathParamsName(node, param)),
-		...query.map((param) => resolver.resolveQueryParamsName(node, param)),
-		...header.map((param) => resolver.resolveHeaderParamsName(node, param))
+		...path.map((param) => resolver.param.path(node, param)),
+		...query.map((param) => resolver.param.query(node, param)),
+		...header.map((param) => resolver.param.headers(node, param))
 	];
-	const bodyAndResponseNames = [node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : null, resolver.resolveResponseName(node)];
+	const bodyAndResponseNames = [node.requestBody?.content?.[0]?.schema ? resolver.response.body(node) : null, resolver.response.response(node)];
 	const result = (options.order === "body-response-first" ? [
 		...bodyAndResponseNames,
 		...paramNames,
@@ -603,15 +578,15 @@ function resolveClientOperation(options) {
 	const { clientPlugin, driver, node, root, output } = options;
 	if (!clientPlugin) return null;
 	const resolver = driver.getResolver(clientPlugin.pluginName);
-	if (!resolver) return null;
 	const plugin = driver.getPlugin(clientPlugin.pluginName);
-	const file = resolver.resolveFile(operationFileEntry(node, node.operationId), {
+	const file = resolver.file({
+		...operationFileEntry(node, node.operationId),
 		root,
 		output: plugin?.options?.output ?? output,
 		group: plugin?.options?.group ?? void 0
 	});
 	return {
-		name: resolver.resolveName(node.operationId),
+		name: resolver.name(node.operationId),
 		path: file.path,
 		clientPath: path.resolve(root, ".kubb/client.ts")
 	};
@@ -659,12 +634,12 @@ const requestGroupOrder = [
 /**
 * Builds the grouped `{ path, query, body, headers }` parameter that mirrors the client
 * function signature. Only the groups the operation carries are emitted, typed from the
-* operation's `RequestConfig`. `keys` narrows the emitted groups, used by the query key which
+* operation's `Options`. `keys` narrows the emitted groups, used by the query key which
 * never carries `headers`.
 *
-* By default the whole group is typed as the single `RequestConfig` reference. When
+* By default the whole group is typed as the single `Options` reference. When
 * `memberTypeWrapper` is set, each group is emitted as its own member typed from the matching
-* `RequestConfig['<group>']` slice and wrapped, used by vue-query to apply
+* `Options['<group>']` slice and wrapped, used by vue-query to apply
 * `MaybeRefOrGetter` per group.
 */
 function buildGroupedRequestParam(node, options) {
@@ -679,13 +654,13 @@ function buildGroupedRequestParam(node, options) {
 		headers: hasRequiredHeader
 	};
 	const isOptional = names.every((name) => !requiredByGroup[name]);
-	const requestConfigName = resolver.resolveRequestConfigName(node);
+	const optionsName = resolver.response.options(node);
 	const omittedKeys = requestGroupOrder.filter((key) => !keys.includes(key));
-	const requestConfigType = omittedKeys.length > 0 ? `Omit<${requestConfigName}, ${omittedKeys.map((key) => `'${key}'`).join(" | ")}>` : requestConfigName;
+	const optionsType = omittedKeys.length > 0 ? `Omit<${optionsName}, ${omittedKeys.map((key) => `'${key}'`).join(" | ")}>` : optionsName;
 	if (memberTypeWrapper) {
 		const members = names.map((name) => ({
 			name,
-			type: memberTypeWrapper(`${requestConfigType}['${name}']`),
+			type: memberTypeWrapper(`${optionsType}['${name}']`),
 			optional: !requiredByGroup[name]
 		}));
 		return createFunctionParameter({
@@ -697,7 +672,7 @@ function buildGroupedRequestParam(node, options) {
 	}
 	return createFunctionParameter({
 		name: createObjectBindingPattern({ elements: names.map((name) => ({ name })) }),
-		type: requestConfigType,
+		type: optionsType,
 		optional: false,
 		...isOptional ? { default: "{}" } : {}
 	});
@@ -743,7 +718,7 @@ function buildClientCall(node, options) {
 }
 /**
 * Build QueryKey params as the grouped `{ path, query, body }` object (NO headers, NO config),
-* typed from the operation's `RequestConfig` minus `url`. The query key transformer reads the
+* typed from the operation's `Options` minus `url`. The query key transformer reads the
 * grouped `path`/`query`/`body` bindings.
 */
 function buildQueryKeyParams(node, options) {
@@ -805,7 +780,7 @@ const declarationPrinter$2 = functionPrinter({ mode: "declaration" });
 const callPrinter$1 = functionPrinter({ mode: "call" });
 function buildMutationParamsNode(node, options) {
 	const { mutationKeyTypeName, mutationArgTypeName, resolver } = options;
-	const responseName = resolver.resolveResponseName(node);
+	const responseName = resolver.response.response(node);
 	const errorNames = resolveErrorNames(node, resolver);
 	return createFunctionParameters({ params: [createFunctionParameter({
 		name: "options",
@@ -818,14 +793,14 @@ function buildMutationParamsNode(node, options) {
 	})] });
 }
 function Mutation({ name, clientName, mutationKeyName, mutationKeyTypeName, mutationArgTypeName, node, tsResolver }) {
-	const responseName = tsResolver.resolveResponseName(node);
+	const responseName = tsResolver.response.response(node);
 	const errorNames = resolveErrorNames(node, tsResolver);
 	const TData = responseName;
 	const TError = `ResponseErrorConfig<${errorNames.length > 0 ? errorNames.join(" | ") : "Error"}>`;
 	const groupedParam = buildGroupedRequestParam(node, { resolver: tsResolver });
 	const hasMutationParams = groupedParam !== null;
 	const groupedParamsNode = createFunctionParameters({ params: groupedParam ? [groupedParam] : [] });
-	const argTypeBody = hasMutationParams ? tsResolver.resolveRequestConfigName(node) : "";
+	const argTypeBody = hasMutationParams ? tsResolver.response.options(node) : "";
 	const argBindingStr = hasMutationParams ? callPrinter$1.print(groupedParamsNode) ?? "" : "";
 	const mutationFnBody = `const { data } = await ${buildClientCall(node, {
 		clientName,
@@ -935,7 +910,7 @@ const declarationPrinter = functionPrinter({ mode: "declaration" });
 const callPrinter = functionPrinter({ mode: "call" });
 function buildQueryParamsNode(node, options) {
 	const { resolver } = options;
-	const responseName = resolver.resolveResponseName(node);
+	const responseName = resolver.response.response(node);
 	const errorNames = resolveErrorNames(node, resolver);
 	const optionsParam = createFunctionParameter({
 		name: "options",
@@ -950,7 +925,7 @@ function buildQueryParamsNode(node, options) {
 	return createFunctionParameters({ params: [buildGroupedRequestParam(node, { resolver }), optionsParam].filter((param) => param !== null) });
 }
 function Query({ name, queryKeyTypeName, queryOptionsName, queryKeyName, node, tsResolver }) {
-	const responseName = tsResolver.resolveResponseName(node);
+	const responseName = tsResolver.response.response(node);
 	const errorNames = resolveErrorNames(node, tsResolver);
 	const generics = [
 		responseName,
@@ -1022,33 +997,31 @@ const mutationGenerator = defineGenerator({
 			output
 		});
 		if (!contractOp) return null;
-		const mutationHookName = resolver.resolveMutationName(node);
-		const mutationKeyName = resolver.resolveMutationKeyName(node);
-		const mutationKeyTypeName = resolver.resolveMutationKeyTypeName(node);
-		const mutationArgTypeName = resolver.resolveMutationArgTypeName(node);
+		const mutationHookName = resolver.mutation.name(node);
+		const mutationKeyName = resolver.mutation.keyName(node);
+		const mutationKeyTypeName = resolver.mutation.keyTypeName(node);
+		const mutationArgTypeName = resolver.mutation.argTypeName(node);
 		const meta = {
-			file: resolver.resolveFile({
+			file: resolver.file({
 				name: mutationHookName,
 				extname: ".ts",
 				tag: node.tags[0] ?? "default",
-				path: node.path
-			}, {
+				path: node.path,
 				root,
 				output,
 				group
 			}),
-			fileTs: tsResolver.resolveFile({
+			fileTs: tsResolver.file({
 				name: node.operationId,
 				extname: ".ts",
 				tag: node.tags[0] ?? "default",
-				path: node.path
-			}, {
+				path: node.path,
 				root,
 				output: pluginTs.options?.output ?? output,
 				group: pluginTs.options?.group
 			})
 		};
-		const importedTypeNames = [tsResolver.resolveRequestConfigName(node), ...resolveOperationTypeNames(node, tsResolver, {
+		const importedTypeNames = [tsResolver.response.options(node), ...resolveOperationTypeNames(node, tsResolver, {
 			order: "body-response-first",
 			includeParams: false
 		})].filter((name) => Boolean(name));
@@ -1057,7 +1030,7 @@ const mutationGenerator = defineGenerator({
 			baseName: meta.file.baseName,
 			path: meta.file.path,
 			meta: meta.file.meta,
-			banner: resolver.resolveBanner(ctx.meta, {
+			banner: resolver.default.banner(ctx.meta, {
 				output,
 				config,
 				file: {
@@ -1065,7 +1038,7 @@ const mutationGenerator = defineGenerator({
 					baseName: meta.file.baseName
 				}
 			}),
-			footer: resolver.resolveFooter(ctx.meta, {
+			footer: resolver.default.footer(ctx.meta, {
 				output,
 				config,
 				file: {
@@ -1150,33 +1123,31 @@ const queryGenerator = defineGenerator({
 			output
 		});
 		if (!contractOp) return null;
-		const queryName = resolver.resolveQueryName(node);
-		const queryOptionsName = resolver.resolveQueryOptionsName(node);
-		const queryKeyName = resolver.resolveQueryKeyName(node);
-		const queryKeyTypeName = resolver.resolveQueryKeyTypeName(node);
+		const queryName = resolver.query.name(node);
+		const queryOptionsName = resolver.query.optionsName(node);
+		const queryKeyName = resolver.query.keyName(node);
+		const queryKeyTypeName = resolver.query.keyTypeName(node);
 		const meta = {
-			file: resolver.resolveFile({
+			file: resolver.file({
 				name: queryName,
 				extname: ".ts",
 				tag: node.tags[0] ?? "default",
-				path: node.path
-			}, {
+				path: node.path,
 				root,
 				output,
 				group
 			}),
-			fileTs: tsResolver.resolveFile({
+			fileTs: tsResolver.file({
 				name: node.operationId,
 				extname: ".ts",
 				tag: node.tags[0] ?? "default",
-				path: node.path
-			}, {
+				path: node.path,
 				root,
 				output: pluginTs.options?.output ?? output,
 				group: pluginTs.options?.group
 			})
 		};
-		const importedTypeNames = [tsResolver.resolveRequestConfigName(node), ...resolveOperationTypeNames(node, tsResolver, {
+		const importedTypeNames = [tsResolver.response.options(node), ...resolveOperationTypeNames(node, tsResolver, {
 			exclude: [queryKeyTypeName],
 			order: "body-response-first",
 			includeParams: false
@@ -1186,7 +1157,7 @@ const queryGenerator = defineGenerator({
 			baseName: meta.file.baseName,
 			path: meta.file.path,
 			meta: meta.file.meta,
-			banner: resolver.resolveBanner(ctx.meta, {
+			banner: resolver.default.banner(ctx.meta, {
 				output,
 				config,
 				file: {
@@ -1194,7 +1165,7 @@ const queryGenerator = defineGenerator({
 					baseName: meta.file.baseName
 				}
 			}),
-			footer: resolver.resolveFooter(ctx.meta, {
+			footer: resolver.default.footer(ctx.meta, {
 				output,
 				config,
 				file: {
@@ -1262,53 +1233,55 @@ function capitalize(name) {
 	return `${name.charAt(0).toUpperCase()}${name.slice(1)}`;
 }
 /**
-* Naming convention resolver for the SWR plugin.
+* Default resolver used by `@kubb/plugin-swr`. Decides the names and file paths for every generated
+* SWR hook (`useFoo`, `useFooMutation`) and its companion helpers (`fooQueryKey`, `fooQueryOptions`,
+* `fooMutationKey`).
 *
-* Provides default naming helpers using camelCase for functions and file paths.
+* Functions and files use the built-in camelCase casing; hooks get the `use` prefix.
 *
-* @example
-* `resolverSwr.default('list pets', 'function')  // → 'listPets'`
+* @example Resolve hook and helper names
+* ```ts
+* import { resolverSwr } from '@kubb/plugin-swr'
+*
+* resolverSwr.query.name(operationNode)       // 'useGetPetById'
+* resolverSwr.query.keyName(operationNode)     // 'getPetByIdQueryKey'
+* resolverSwr.mutation.name(operationNode)     // 'useUpdatePet'
+* ```
 */
-const resolverSwr = defineResolver(() => ({
-	name: "default",
+const resolverSwr = createResolver({
 	pluginName: "plugin-swr",
-	default(name, type) {
-		return type === "file" ? toFilePath(name) : camelCase(name);
-	},
-	resolveName(name) {
-		return this.default(name, "function");
-	},
-	resolvePathName(name, type) {
-		return this.default(name, type);
-	},
-	resolveQueryName(node) {
-		return `use${capitalize(this.resolveName(node.operationId))}`;
-	},
-	resolveMutationName(node) {
-		return `use${capitalize(this.resolveName(node.operationId))}`;
-	},
-	resolveQueryOptionsName(node) {
-		return `${this.resolveName(node.operationId)}QueryOptions`;
-	},
-	resolveQueryKeyName(node) {
-		return `${this.resolveName(node.operationId)}QueryKey`;
-	},
-	resolveMutationKeyName(node) {
-		return `${this.resolveName(node.operationId)}MutationKey`;
-	},
-	resolveQueryKeyTypeName(node) {
-		return `${capitalize(this.resolveName(node.operationId))}QueryKey`;
-	},
-	resolveMutationKeyTypeName(node) {
-		return `${capitalize(this.resolveName(node.operationId))}MutationKey`;
-	},
-	resolveMutationArgTypeName(node) {
-		return `${capitalize(this.resolveName(node.operationId))}MutationArg`;
+	query: {
+		name(node) {
+			return `use${capitalize(this.name(node.operationId))}`;
+		},
+		optionsName(node) {
+			return `${this.name(node.operationId)}QueryOptions`;
+		},
+		keyName(node) {
+			return `${this.name(node.operationId)}QueryKey`;
+		},
+		keyTypeName(node) {
+			return `${capitalize(this.name(node.operationId))}QueryKey`;
+		},
+		clientName(node) {
+			return this.name(node.operationId);
+		}
 	},
-	resolveClientName(node) {
-		return this.resolveName(node.operationId);
+	mutation: {
+		name(node) {
+			return `use${capitalize(this.name(node.operationId))}`;
+		},
+		keyName(node) {
+			return `${this.name(node.operationId)}MutationKey`;
+		},
+		keyTypeName(node) {
+			return `${capitalize(this.name(node.operationId))}MutationKey`;
+		},
+		argTypeName(node) {
+			return `${capitalize(this.name(node.operationId))}MutationArg`;
+		}
 	}
-}));
+});
 //#endregion
 //#region src/plugin.ts
 /**
@@ -1349,10 +1322,7 @@ const pluginSwr = definePlugin((options) => {
 		options,
 		dependencies: [pluginTsName],
 		hooks: { "kubb:plugin:setup"(ctx) {
-			const resolver = userResolver ? {
-				...resolverSwr,
-				...userResolver
-			} : resolverSwr;
+			const resolver = userResolver ? Resolver.merge(resolverSwr, userResolver) : resolverSwr;
 			const resolvedClient = resolveClient({
 				client,
 				pluginNames: (ctx.config.plugins ?? []).map((p) => p.name).filter((name) => Boolean(name))