@kubb/plugin-mcp 5.2.0 → 5.2.1

package/dist/index.js

@@ -1,28 +1,10 @@
 import "./rolldown-runtime-C0LytTxp.js";
-import { Resolver, Url, addGenerator, ast, createResolver, defineExtension, defineGenerator, setMacros, setResolver, useConfig } from "kubb/kit";
+import { Diagnostics, Resolver, Url, addGenerator, ast, createResolver, defineExtension, defineGenerator, setMacros, setResolver, useConfig } from "kubb/kit";
 import path, { posix } from "node:path";
 import { Const, File, Function, jsxRenderer } from "kubb/jsx";
 import { Fragment, jsx, jsxs } from "kubb/jsx/jsx-runtime";
-import { createFunctionParameter, createFunctionParameters, createObjectBindingPattern, functionPrinter, pluginTsName } from "@kubb/plugin-ts";
 import { pluginZodName } from "@kubb/plugin-zod";
-//#region ../../internals/shared/src/params.ts
-/**
-* Drops parameters that share the same name, keeping the first.
-*
-* A malformed spec can declare the same parameter name twice within one `in` location. Both would
-* resolve to the same output property, so emitting both would yield an object type with a duplicate
-* member, which TypeScript rejects. This is a defensive guard against that case, not a casing guard:
-* parameter names flow through unchanged, so no two distinct names ever collide here anymore.
-*/
-function dedupeParams(params) {
-	const seen = /* @__PURE__ */ new Set();
-	return params.filter((param) => {
-		if (seen.has(param.name)) return false;
-		seen.add(param.name);
-		return true;
-	});
-}
-//#endregion
+import { pluginTsName } from "@kubb/plugin-ts";
 //#region ../../internals/shared/src/operation.ts
 /**
 * Builds the `ResolverFileParams` every operation generator passes to
@@ -92,12 +74,12 @@ function getContentTypeInfo(node) {
 function getResponseContentTypeInfo(node) {
 	return buildContentTypeInfo(getPrimarySuccessResponse(node)?.content?.map((e) => e.contentType) ?? []);
 }
+const requestConfigBaseType = `Partial<Omit<RequestConfig, 'path' | 'query' | 'body' | 'headers' | 'url'>>`;
 function buildRequestConfigType(node) {
 	const request = getContentTypeInfo(node);
 	const response = getResponseContentTypeInfo(node);
-	const configType = `Partial<Omit<RequestConfig, 'path' | 'query' | 'body' | 'headers' | 'url'>>`;
 	const members = [request.isMultipleContentTypes ? `request?: ${request.contentTypeUnion}` : null, response.isMultipleContentTypes ? `response?: ${response.contentTypeUnion}` : null].filter(Boolean);
-	return members.length ? `${configType} & { contentType?: { ${members.join("; ")} } }` : configType;
+	return members.length ? `${requestConfigBaseType} & { contentType?: { ${members.join("; ")} } }` : requestConfigBaseType;
 }
 /**
 * Which of the grouped request options an operation carries.
@@ -177,11 +159,19 @@ const operationParameterGroupsByNode = /* @__PURE__ */ new WeakMap();
 function getOperationParameters(node) {
 	const cached = operationParameterGroupsByNode.get(node);
 	if (cached) return cached;
+	const group = (location) => {
+		const seen = /* @__PURE__ */ new Set();
+		return node.parameters.filter((param) => {
+			if (param.in !== location || seen.has(param.name)) return false;
+			seen.add(param.name);
+			return true;
+		});
+	};
 	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"))
+		path: group("path"),
+		query: group("query"),
+		header: group("header"),
+		cookie: group("cookie")
 	};
 	operationParameterGroupsByNode.set(node, groups);
 	return groups;
@@ -203,10 +193,6 @@ function getOperationSuccessResponses(node) {
 function getPrimarySuccessResponse(node) {
 	return getOperationSuccessResponses(node)[0] ?? null;
 }
-function findSuccessStatusCode(responses) {
-	for (const response of responses) if (isSuccessStatusCode(response.statusCode)) return response.statusCode;
-	return null;
-}
 //#endregion
 //#region ../../internals/utils/src/casing.ts
 /**
@@ -251,7 +237,6 @@ function toSlash(p) {
 * ```
 */
 function getRelativePath(rootDir, filePath) {
-	if (!rootDir || !filePath) throw new Error(`Root and file should be filled in when retrieving the relativePath, ${rootDir || ""} ${filePath || ""}`);
 	const relativePath = posix.relative(toSlash(rootDir), toSlash(filePath));
 	return relativePath.startsWith("../") ? relativePath : `./${relativePath}`;
 }
@@ -295,7 +280,6 @@ const requestGroupOrder = [
 	"body"
 ];
 function McpHandler({ name, clientName, node, resolver, returnType = "full" }) {
-	if (!ast.isHttpOperationNode(node)) return null;
 	const { signature, groups } = buildRequestParamsSignature(node, resolver, { isConfigurable: false });
 	const paramsSignature = [signature, "ctx: ServerContext"].filter(Boolean).join(", ");
 	const callConfig = `{ ${[
@@ -333,72 +317,31 @@ function McpHandler({ name, clientName, node, resolver, returnType = "full" }) {
 	});
 }
 //#endregion
-//#region src/utils.ts
-/**
-* Render a group param value — compose individual schemas into `z.object({ ... })`,
-* or use a schema name string directly.
-*/
-function zodGroupExpr(entry) {
-	if (typeof entry === "string") return entry;
-	return `z.object({ ${entry.map((p) => `${JSON.stringify(p.name)}: ${p.schemaName}`).join(", ")} })`;
-}
+//#region src/components/Server.tsx
 /**
-* Convert a SchemaNode type to an inline Zod expression string.
-* Used as fallback when no named zod schema is available for a path parameter.
+* Composes individual param schemas into `z.object({ ... })`.
 */
-function zodExprFromSchemaNode(schema) {
-	const baseExpr = (() => {
-		if (schema.type === "enum") {
-			const rawValues = schema.namedEnumValues?.length ? schema.namedEnumValues.map((v) => v.value) : (schema.enumValues ?? []).filter((v) => v !== null);
-			if (rawValues.length > 0 && rawValues.every((v) => typeof v === "string")) return `z.enum([${rawValues.map((v) => JSON.stringify(v)).join(", ")}])`;
-			if (rawValues.length > 0) {
-				const literals = rawValues.map((v) => `z.literal(${JSON.stringify(v)})`);
-				return literals.length === 1 ? literals[0] : `z.union([${literals.join(", ")}])`;
-			}
-			return "z.string()";
-		}
-		if (schema.type === "integer") return "z.coerce.number()";
-		if (schema.type === "number") return "z.number()";
-		if (schema.type === "boolean") return "z.boolean()";
-		if (schema.type === "array") return "z.array(z.unknown())";
-		return "z.string()";
-	})();
-	return schema.nullable ? `${baseExpr}.nullable()` : baseExpr;
-}
-//#endregion
-//#region src/components/Server.tsx
-const keysPrinter = functionPrinter({ mode: "call" });
+const zodObject = (params) => `z.object({ ${params.map((p) => `${JSON.stringify(p.name)}: ${p.schemaName}`).join(", ")} })`;
 function Server({ serverName, serverVersion, operations }) {
-	const registrations = operations.map(({ tool, mcp, zod, node }) => {
-		const { path: pathParams } = getOperationParameters(node);
+	const registrations = operations.map(({ tool, mcp, zod }) => {
 		const entries = [];
-		if (pathParams.length) {
-			const pathFields = pathParams.map((p) => {
-				const zodParam = zod.pathParams.find((zp) => zp.name === p.name);
-				return `${JSON.stringify(p.name)}: ${zodParam ? zodParam.schemaName : zodExprFromSchemaNode(p.schema)}`;
-			}).join(", ");
-			entries.push({
-				key: "path",
-				value: `z.object({ ${pathFields} })`
-			});
-		}
+		if (zod.pathParams.length) entries.push({
+			key: "path",
+			value: zodObject(zod.pathParams)
+		});
 		if (zod.queryParams) entries.push({
 			key: "query",
-			value: zodGroupExpr(zod.queryParams)
+			value: zodObject(zod.queryParams)
 		});
 		if (zod.headerParams) entries.push({
 			key: "headers",
-			value: zodGroupExpr(zod.headerParams)
+			value: zodObject(zod.headerParams)
 		});
 		if (zod.requestName) entries.push({
 			key: "body",
 			value: zod.requestName
 		});
-		const paramsNode = entries.length ? createFunctionParameters({ params: [createFunctionParameter({
-			name: createObjectBindingPattern({ elements: entries.map((e) => ({ name: e.key })) }),
-			optional: false
-		})] }) : null;
-		const destructured = paramsNode ? keysPrinter.print(paramsNode) ?? "" : "";
+		const destructured = `{ ${entries.map((e) => e.key).join(", ")} }`;
 		const inputSchema = entries.length ? `z.object({ ${entries.map((e) => `${e.key}: ${e.value}`).join(", ")} })` : null;
 		const outputSchema = zod.responseName;
 		const config = [
@@ -506,7 +449,7 @@ const contractPlugins = [
 * @example
 * ```ts
 * resolveClient({ client: undefined, pluginNames: ['plugin-ts'] })
-* // { kind: 'error', message: 'No client plugin is registered…' }
+* // { kind: 'error', code: 'KUBB_MISSING_DEPENDENCY', message: 'No client plugin is registered.', help: 'Add …' }
 * ```
 */
 function resolveClient(options) {
@@ -516,7 +459,9 @@ function resolveClient(options) {
 		const pluginName = selectorToPlugin[client];
 		if (!has(pluginName)) return {
 			kind: "error",
-			message: `\`client: '${client}'\` is set but \`@kubb/plugin-${client}\` is not registered in \`plugins\`. Add it, or drop \`client\` to use a different client plugin.`
+			code: Diagnostics.code.missingDependency,
+			message: `\`client: '${client}'\` is set but \`@kubb/plugin-${client}\` is not registered in \`plugins\`.`,
+			help: `Add \`@kubb/plugin-${client}\` to \`plugins\`, or drop \`client\` to use a different client plugin.`
 		};
 		return {
 			kind: "contract",
@@ -525,7 +470,9 @@ function resolveClient(options) {
 	}
 	if (client !== void 0) return {
 		kind: "error",
-		message: `Option \`client\` is ${typeof client === "string" ? `'${client}'` : String(client)}, but it must be one of 'fetch', 'axios', 'client'. Drop \`client\` to use the registered client plugin.`
+		code: Diagnostics.code.invalidPluginOptions,
+		message: `Option \`client\` is ${typeof client === "string" ? `'${client}'` : String(client)}, but it must be one of 'fetch', 'axios', 'client'.`,
+		help: "Set `client` to one of those values, or drop it to use the registered client plugin."
 	};
 	const registered = contractPlugins.filter(has);
 	if (registered.length === 1) return {
@@ -534,25 +481,40 @@ function resolveClient(options) {
 	};
 	if (registered.length > 1) return {
 		kind: "error",
-		message: `Multiple client plugins are registered (${registered.map((name) => `\`@kubb/${name}\``).join(", ")}). Set \`client: 'fetch' | 'axios' | 'client'\` to choose which client the hooks call, or register a single client plugin.`
+		code: Diagnostics.code.invalidPluginOptions,
+		message: `Multiple client plugins are registered (${registered.map((name) => `\`@kubb/${name}\``).join(", ")}) and \`client\` is not set.`,
+		help: "Set `client: 'fetch' | 'axios' | 'client'` to choose which client the hooks call, or register a single client plugin."
 	};
 	return {
 		kind: "error",
-		message: "No client plugin is registered. Add `@kubb/plugin-axios`, `@kubb/plugin-fetch`, or `@kubb/plugin-client` to `plugins` so the generated code has an HTTP client to call."
+		code: Diagnostics.code.missingDependency,
+		message: "No client plugin is registered.",
+		help: "Add `@kubb/plugin-fetch`, `@kubb/plugin-axios`, or `@kubb/plugin-client` to `plugins` so the generated code has an HTTP client to call."
 	};
 }
 /**
-* Resolves the contract client during a consumer plugin's setup hook. Extracts the plugin names
-* from the raw `plugins` config, applies {@link resolveClient}, and throws the diagnostic on a
-* misconfiguration so every consumer fails fast with the same message.
+* Resolves the contract client during a consumer plugin's setup hook.
+* It extracts the plugin names from the raw `plugins` config and applies {@link resolveClient}.
+* On a misconfiguration it throws a config diagnostic tagged with `plugin`, so every consumer
+* fails fast with the same message.
 */
 function resolveContractClient(options) {
-	const { client, plugins = [] } = options;
+	const { plugin, client, plugins = [] } = options;
 	const resolved = resolveClient({
 		client,
 		pluginNames: plugins.map((plugin) => plugin.name).filter((name) => Boolean(name))
 	});
-	if (resolved.kind === "error") throw new Error(resolved.message);
+	if (resolved.kind === "error") {
+		const { code, message, help } = resolved;
+		throw new Diagnostics.Error({
+			code,
+			severity: "error",
+			message,
+			help,
+			location: { kind: "config" },
+			plugin
+		});
+	}
 	return resolved;
 }
 //#endregion
@@ -645,10 +607,7 @@ const mcpGenerator = defineGenerator({
 		const meta = {
 			name: resolver.handler.name(node),
 			file: resolver.file({
-				name: node.operationId,
-				extname: ".ts",
-				tag: node.tags[0] ?? "default",
-				path: node.path,
+				...operationFileEntry(node, node.operationId),
 				root,
 				output,
 				group: group ?? void 0
@@ -727,22 +686,14 @@ const serverGenerator = defineGenerator({
 		const { output, group } = ctx.options;
 		const pluginZod = ctx.requirePlugin(pluginZodName);
 		const zodResolver = driver.getResolver(pluginZodName);
-		const name = "server";
-		const serverFile = {
-			baseName: "server.ts",
-			path: path.resolve(root, output.path, "server.ts"),
-			meta: { pluginName: plugin.name }
-		};
-		const startFile = {
-			baseName: "start.ts",
-			path: path.resolve(root, output.path, "start.ts"),
-			meta: { pluginName: plugin.name }
-		};
-		const jsonFile = {
-			baseName: ".mcp.json",
-			path: path.resolve(root, output.path, ".mcp.json"),
+		const fileAt = (baseName) => ({
+			baseName,
+			path: path.resolve(root, output.path, baseName),
 			meta: { pluginName: plugin.name }
-		};
+		});
+		const serverFile = fileAt("server.ts");
+		const startFile = fileAt("start.ts");
+		const jsonFile = fileAt(".mcp.json");
 		const mcpConfig = { mcpServers: { [ctx.meta.title || "server"]: {
 			type: "stdio",
 			command: "npx",
@@ -750,26 +701,21 @@ const serverGenerator = defineGenerator({
 		} } };
 		const operationsMapped = nodes.filter(ast.isHttpOperationNode).map((node) => {
 			const { path: pathParams, query: queryParams, header: headerParams } = getOperationParameters(node);
+			const fileEntry = operationFileEntry(node, node.operationId);
 			const mcpFile = resolver.file({
-				name: node.operationId,
-				extname: ".ts",
-				tag: node.tags[0] ?? "default",
-				path: node.path,
+				...fileEntry,
 				root,
 				output,
 				group: group ?? void 0
 			});
 			const zodFile = zodResolver.file({
-				name: node.operationId,
-				extname: ".ts",
-				tag: node.tags[0] ?? "default",
-				path: node.path,
+				...fileEntry,
 				root,
 				output: pluginZod.options?.output ?? output,
 				group: pluginZod.options?.group ?? void 0
 			});
 			const requestName = node.requestBody?.content?.[0]?.schema ? zodResolver.response.body(node) : null;
-			const successStatus = findSuccessStatusCode(node.responses);
+			const successStatus = getPrimarySuccessResponse(node)?.statusCode;
 			const responseName = successStatus ? zodResolver.response.status(node, successStatus) : null;
 			const resolveParams = (params) => params.map((p) => ({
 				name: p.name,
@@ -792,8 +738,7 @@ const serverGenerator = defineGenerator({
 					requestName,
 					responseName,
 					file: zodFile
-				},
-				node
+				}
 			};
 		});
 		const imports = operationsMapped.flatMap(({ mcp, zod }) => {
@@ -891,7 +836,7 @@ const serverGenerator = defineGenerator({
 				path: jsonFile.path,
 				meta: jsonFile.meta,
 				children: /* @__PURE__ */ jsx(File.Source, {
-					name,
+					name: "server",
 					children: `${JSON.stringify(mcpConfig, null, 2)}\n`
 				})
 			})
@@ -906,7 +851,7 @@ var compatibility = {
 };
 //#endregion
 //#region package.json
-var version = "5.2.0";
+var version = "5.2.1";
 //#endregion
 //#region src/resolvers/resolverMcp.ts
 /**
@@ -992,6 +937,7 @@ const pluginMcp = defineExtension({
 			override,
 			group: createGroupConfig(group),
 			client: resolveContractClient({
+				plugin: pluginMcpName,
 				client,
 				plugins: useConfig().plugins
 			}),