@kubb/plugin-swr 5.1.1 → 5.1.3

package/dist/index.cjs

@@ -418,34 +418,44 @@ function resolveContractClient(options) {
 * 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 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.
+* path), or when the client plugin's `exclude` / `include` leaves this operation out, since it then
+* emits no `<op>` to import. 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.
 *
-* `returnType` mirrors the client plugin's own `returnType` option (`'full'` when unset), so a
-* dependent's generated call body can match it instead of assuming the full `RequestResult` shape.
+* `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 plugin = driver.getPlugin(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: plugin?.options?.output ?? output,
-			group: plugin?.options?.group ?? void 0
+			output: operationOptions.output ?? output,
+			group: operationOptions.group ?? void 0
 		});
 		return {
 			name: resolver.name(node.operationId),
 			path: file.path,
 			clientPath: node_path.default.resolve(root, ".kubb/client.ts"),
-			returnType: plugin?.options?.returnType ?? "full"
+			returnType: operationOptions.returnType ?? "full"
 		};
 	});
 }
@@ -601,11 +611,11 @@ function resolveMutationConfig(mutation, options) {
 }
 /**
 * Classifies an operation as a query or a mutation from the resolved `query` / `mutation` method lists.
-* `query: false` still marks the operation as a query so the query-family generators keep matching it,
-* and a method already claimed by `query` never counts as a mutation.
+* Disabled query and mutation configs do not claim operations, and a method already claimed by an
+* enabled query config never counts as a mutation.
 */
 function classifyOperation(node, { query, mutation }) {
-	const isQuery = query === false || !!query && query.methods.some((method) => node.method.toLowerCase() === method.toLowerCase());
+	const isQuery = !!query && query.methods.some((method) => node.method.toLowerCase() === method.toLowerCase());
 	const queryMethods = new Set(query ? query.methods : []);
 	return {
 		isQuery,