@kubb/plugin-client 5.5.10 → 5.5.12

package/dist/index.js

@@ -1,28 +1,10 @@
 import "./rolldown-runtime-C0LytTxp.js";
-import { Resolver, Url, addGenerator, ast, createResolver, defineExtension, defineGenerator, macroSimplifyUnion, setMacros, setResolver } from "kubb/kit";
+import { Diagnostics, Resolver, Url, addGenerator, ast, createResolver, defineExtension, defineGenerator, macroSimplifyUnion, setMacros, setResolver } from "kubb/kit";
 import path from "node:path";
 import { createFunctionParameter, createFunctionParameters, functionPrinter, pluginTsName } from "@kubb/plugin-ts";
 import { pluginZodName } from "@kubb/plugin-zod";
 import { File, Function, jsxRenderer } from "kubb/jsx";
 import { jsx, jsxs } from "kubb/jsx/jsx-runtime";
-//#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
 //#region ../../internals/shared/src/operation.ts
 /**
 * Builds the `ResolverFileParams` every operation generator passes to
@@ -184,11 +166,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;
@@ -427,7 +417,135 @@ var compatibility = {
 };
 //#endregion
 //#region package.json
-var version = "5.5.10";
+var version = "5.5.12";
+//#endregion
+//#region ../../internals/client/src/builders/validatorOptions.ts
+/**
+* Returns `true` when any direction of the validator uses zod (used for dependency checks).
+*/
+function isValidatorEnabled(validator) {
+	if (!validator) return false;
+	if (validator === "zod") return true;
+	return Boolean(validator.request || validator.response);
+}
+/**
+* Returns `'zod'` when request body parsing is enabled, `null` otherwise. The string shorthand
+* `'zod'` validates the response only, so it does not enable request parsing.
+*/
+function resolveRequestValidator(validator) {
+	if (!validator || validator === "zod") return null;
+	return validator.request ?? null;
+}
+/**
+* Returns `'zod'` when response parsing is enabled, `null` otherwise. The string shorthand `'zod'`
+* maps to response parsing.
+*/
+function resolveResponseValidator(validator) {
+	if (!validator) return null;
+	if (validator === "zod") return "zod";
+	return validator.response ?? null;
+}
+/**
+* Resolves the zod schema name a generated client validates an error body with on the non-throw path.
+* Uses the error-only `<operation>ErrorSchema` (the union of non-2xx statuses); returns `null` when the
+* operation documents no error responses with a schema.
+*/
+function buildZodErrorParse(node, zodResolver) {
+	if (!node.responses.some((res) => !isSuccessStatusCode(res.statusCode) && res.content?.some((entry) => entry.schema))) return null;
+	return zodResolver.response.error?.(node) || null;
+}
+//#endregion
+//#region ../../internals/client/src/builders/validator.ts
+/**
+* Builds the validator-hook references for one operation. Request validation runs before the send;
+* response validation runs on the success body only. Returns `null` references when the matching
+* direction is disabled or the schema is absent.
+*/
+function buildValidatorHooks({ node, validator, zodResolver }) {
+	const hasRequestBody = Boolean(node.requestBody?.content?.[0]?.schema);
+	const parsesResponse = zodResolver && resolveResponseValidator(validator) === "zod";
+	const response = parsesResponse ? zodResolver.response.response(node) || null : null;
+	const error = parsesResponse ? buildZodErrorParse(node, zodResolver) : null;
+	const request = zodResolver && resolveRequestValidator(validator) === "zod" && hasRequestBody ? zodResolver.response.body(node) || null : null;
+	return {
+		request,
+		response,
+		error,
+		importedZodNames: [
+			response,
+			error,
+			request
+		].filter((name) => Boolean(name))
+	};
+}
+//#endregion
+//#region ../../internals/client/src/builders/security.ts
+function serializeAuth(auth) {
+	const parts = [`type: '${auth.type}'`];
+	if (auth.scheme) parts.push(`scheme: '${auth.scheme}'`);
+	if (auth.name) parts.push(`name: '${auth.name}'`);
+	if (auth.in) parts.push(`in: '${auth.in}'`);
+	return `{ ${parts.join(", ")} }`;
+}
+/**
+* Maps an OpenAPI security scheme to the inline `Auth` object, or `null` when the runtime cannot
+* place it (an unresolved `$ref`, or an `apiKey` without a name or outside `header` / `query` /
+* `cookie`). `http` schemes other than `basic` are treated as bearer.
+*/
+function resolveSecurityScheme(scheme) {
+	if (!scheme || "$ref" in scheme) return null;
+	if (scheme.type === "apiKey") {
+		if (!scheme.name || scheme.in !== "header" && scheme.in !== "query" && scheme.in !== "cookie") return null;
+		return {
+			type: "apiKey",
+			name: scheme.name,
+			in: scheme.in
+		};
+	}
+	if (scheme.type === "http") return {
+		type: "http",
+		scheme: scheme.scheme?.toLowerCase() === "basic" ? "basic" : "bearer"
+	};
+	if (scheme.type === "oauth2") return { type: "oauth2" };
+	if (scheme.type === "openIdConnect") return { type: "openIdConnect" };
+	return null;
+}
+/**
+* Derives the per-operation security metadata from the OpenAPI document. The operation's own
+* `security` overrides the global `security` (an explicit empty array disables auth), and every
+* referenced scheme is resolved from `components.securitySchemes` into a flat, de-duplicated list of
+* `Auth` objects the runtime walks in order.
+*
+* @example
+* `getOperationSecurity({ document, method: 'POST', path: '/pet' })`
+* `// [{ type: 'http', scheme: 'bearer' }]`
+*/
+function getOperationSecurity({ document, method, path }) {
+	if (!document) return void 0;
+	const requirements = (document.paths?.[path]?.[method.toLowerCase()])?.security ?? document.security;
+	if (!requirements?.length) return void 0;
+	const definitions = document.components?.securitySchemes ?? {};
+	const security = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const requirement of requirements) for (const schemeName of Object.keys(requirement)) {
+		if (seen.has(schemeName)) continue;
+		seen.add(schemeName);
+		const auth = resolveSecurityScheme(definitions[schemeName]);
+		if (auth) security.push(auth);
+	}
+	return security.length ? security : void 0;
+}
+/**
+* Serializes the per-operation security into the literal emitted on each generated call's `security`
+* field. The runtime `resolveAuth` helper walks it, calling the configured `auth` resolver per entry.
+*
+* @example
+* `buildSecurityMetadata({ security: [{ type: 'http', scheme: 'bearer' }] }) // "[{ type: 'http', scheme: 'bearer' }]"`
+*/
+function buildSecurityMetadata({ security }) {
+	if (!security?.length) return null;
+	return `[${security.map(serializeAuth).join(", ")}]`;
+}
 //#endregion
 //#region ../../internals/client/src/builders/contentType.ts
 /**
@@ -521,74 +639,6 @@ function buildReturnStatement({ node, types, callConfig, returnType, throwOnErro
 	})}>>)`;
 }
 //#endregion
-//#region ../../internals/client/src/builders/security.ts
-function serializeAuth(auth) {
-	const parts = [`type: '${auth.type}'`];
-	if (auth.scheme) parts.push(`scheme: '${auth.scheme}'`);
-	if (auth.name) parts.push(`name: '${auth.name}'`);
-	if (auth.in) parts.push(`in: '${auth.in}'`);
-	return `{ ${parts.join(", ")} }`;
-}
-/**
-* Maps an OpenAPI security scheme to the inline `Auth` object, or `null` when the runtime cannot
-* place it (an unresolved `$ref`, or an `apiKey` without a name or outside `header` / `query` /
-* `cookie`). `http` schemes other than `basic` are treated as bearer.
-*/
-function resolveSecurityScheme(scheme) {
-	if (!scheme || "$ref" in scheme) return null;
-	if (scheme.type === "apiKey") {
-		if (!scheme.name || scheme.in !== "header" && scheme.in !== "query" && scheme.in !== "cookie") return null;
-		return {
-			type: "apiKey",
-			name: scheme.name,
-			in: scheme.in
-		};
-	}
-	if (scheme.type === "http") return {
-		type: "http",
-		scheme: scheme.scheme?.toLowerCase() === "basic" ? "basic" : "bearer"
-	};
-	if (scheme.type === "oauth2") return { type: "oauth2" };
-	if (scheme.type === "openIdConnect") return { type: "openIdConnect" };
-	return null;
-}
-/**
-* Derives the per-operation security metadata from the OpenAPI document. The operation's own
-* `security` overrides the global `security` (an explicit empty array disables auth), and every
-* referenced scheme is resolved from `components.securitySchemes` into a flat, de-duplicated list of
-* `Auth` objects the runtime walks in order.
-*
-* @example
-* `getOperationSecurity({ document, method: 'POST', path: '/pet' })`
-* `// [{ type: 'http', scheme: 'bearer' }]`
-*/
-function getOperationSecurity({ document, method, path }) {
-	if (!document) return void 0;
-	const requirements = (document.paths?.[path]?.[method.toLowerCase()])?.security ?? document.security;
-	if (!requirements?.length) return void 0;
-	const definitions = document.components?.securitySchemes ?? {};
-	const security = [];
-	const seen = /* @__PURE__ */ new Set();
-	for (const requirement of requirements) for (const schemeName of Object.keys(requirement)) {
-		if (seen.has(schemeName)) continue;
-		seen.add(schemeName);
-		const auth = resolveSecurityScheme(definitions[schemeName]);
-		if (auth) security.push(auth);
-	}
-	return security.length ? security : void 0;
-}
-/**
-* Serializes the per-operation security into the literal emitted on each generated call's `security`
-* field. The runtime `resolveAuth` helper walks it, calling the configured `auth` resolver per entry.
-*
-* @example
-* `buildSecurityMetadata({ security: [{ type: 'http', scheme: 'bearer' }] }) // "[{ type: 'http', scheme: 'bearer' }]"`
-*/
-function buildSecurityMetadata({ security }) {
-	if (!security?.length) return null;
-	return `[${security.map(serializeAuth).join(", ")}]`;
-}
-//#endregion
 //#region ../../internals/client/src/builders/signature.ts
 const declarationPrinter = functionPrinter({ mode: "declaration" });
 /**
@@ -618,76 +668,6 @@ function buildGroupedOptionsSignature({ node, types, returnType, throwOnErrorDef
 	};
 }
 //#endregion
-//#region ../../internals/client/src/builders/validatorOptions.ts
-/**
-* Returns `'zod'` when request body parsing is enabled, `null` otherwise. The string shorthand
-* `'zod'` validates the response only, so it does not enable request parsing.
-*/
-function resolveRequestValidator(validator) {
-	if (!validator || validator === "zod") return null;
-	return validator.request ?? null;
-}
-/**
-* Returns `'zod'` when response parsing is enabled, `null` otherwise. The string shorthand `'zod'`
-* maps to response parsing.
-*/
-function resolveResponseValidator(validator) {
-	if (!validator) return null;
-	if (validator === "zod") return "zod";
-	return validator.response ?? null;
-}
-/**
-* Resolves the zod expression a generated client validates a success response with. Only success
-* (2xx) bodies reach the parse under the throw-on-error contract, so the success-only
-* `<operation>ResponseSchema` is used; error bodies are never zod-parsed.
-*/
-function buildZodResponseParse(node, zodResolver) {
-	const name = zodResolver.response.response(node);
-	return name ? {
-		expression: name,
-		importNames: [name]
-	} : null;
-}
-/**
-* Resolves the zod expression a generated client validates an error body with on the non-throw path.
-* Uses the error-only `<operation>ErrorSchema` (the union of non-2xx statuses); returns `null` when the
-* operation documents no error responses with a schema.
-*/
-function buildZodErrorParse(node, zodResolver) {
-	if (!node.responses.some((res) => !isSuccessStatusCode(res.statusCode) && res.content?.some((entry) => entry.schema))) return null;
-	const name = zodResolver.response.error?.(node);
-	return name ? {
-		expression: name,
-		importNames: [name]
-	} : null;
-}
-//#endregion
-//#region ../../internals/client/src/builders/validator.ts
-/**
-* Builds the validator-hook references for one operation. Request validation runs before the send;
-* response validation runs on the success body only. Returns `null` references when the matching
-* direction is disabled or the schema is absent.
-*/
-function buildValidatorHooks({ node, validator, zodResolver }) {
-	const importedZodNames = [];
-	const hasRequestBody = Boolean(node.requestBody?.content?.[0]?.schema);
-	const zodRequestName = zodResolver && resolveRequestValidator(validator) === "zod" && hasRequestBody ? zodResolver.response.body(node) : null;
-	const request = zodRequestName ?? null;
-	if (zodRequestName) importedZodNames.push(zodRequestName);
-	const responseParse = zodResolver && resolveResponseValidator(validator) === "zod" ? buildZodResponseParse(node, zodResolver) : null;
-	const response = responseParse ? responseParse.expression : null;
-	if (responseParse) importedZodNames.push(...responseParse.importNames);
-	const errorParse = zodResolver && resolveResponseValidator(validator) === "zod" ? buildZodErrorParse(node, zodResolver) : null;
-	const error = errorParse ? errorParse.expression : null;
-	if (errorParse) importedZodNames.push(...errorParse.importNames);
-	return {
-		request,
-		response,
-		error,
-		importedZodNames
-	};
-}
-//#endregion
 //#region ../../internals/client/src/builders/styles.ts
 /**
 * Renders a parameter name as an object-literal key, quoted when it is not a bare identifier.
@@ -748,7 +728,7 @@ function buildStyles({ node }) {
 * type, signature, and call config are built with the AST factory, and only the jsx-renderer emits
 * the source.
 */
-function Operation({ name, node, types, zodResolver, validator, returnType, throwOnErrorDefault, security, isExportable = true, isIndexable = true }) {
+function Operation({ name, node, types, zodResolver, validator, returnType, throwOnErrorDefault, security }) {
 	if (!ast.isHttpOperationNode(node)) return null;
 	const signature = buildGroupedOptionsSignature({
 		node,
@@ -795,11 +775,11 @@ function Operation({ name, node, types, zodResolver, validator, returnType, thro
 	});
 	return /* @__PURE__ */ jsx(File.Source, {
 		name,
-		isExportable,
-		isIndexable,
+		isExportable: true,
+		isIndexable: true,
 		children: /* @__PURE__ */ jsxs(Function, {
 			name,
-			export: isExportable,
+			export: true,
 			generics: signature.generics,
 			params: signature.paramsSignature,
 			returnType: functionReturnType,
@@ -819,27 +799,22 @@ function Operation({ name, node, types, zodResolver, validator, returnType, thro
 //#endregion
 //#region ../../internals/client/src/resolveOperationTypes.ts
 /**
-* Warning a client generator reports when neither plugin can supply the operation types, so the
-* pipeline says why nothing was generated instead of silently emitting no files.
-*/
-const MISSING_OPERATION_TYPES_WARNING = "Skipped: no operation types available. Add `pluginTs()`, or `pluginZod({ inferred: true })` to type the client from its zod schemas.";
-/**
 * Picks the plugin a generated client takes its `Options` and `Responses` types from.
 *
 * `plugin-ts` wins whenever it is in the pipeline, so existing configs keep the types they generate
 * today. Without it, `pluginZod({ inferred: true })` takes over: its inferred options and responses
 * types are built from the same shared schemas as the `plugin-ts` ones, so a client typed off
 * `z.infer` carries what the codecs decode to (a `Temporal` instance, a `Date`) rather than the raw
-* wire type. Returns `null` when neither is available, leaving the caller nothing to type against.
+* wire type. Throws `KUBB_MISSING_DEPENDENCY` for `pluginName` when neither is available, since the
+* client has nothing to type against.
 *
 * @example
 * ```ts
-* const types = resolveOperationTypes(ctx.driver)
-* if (!types) return null
+* const types = resolveOperationTypes(ctx.driver, ctx.plugin.name)
 * types.response.options(node) // 'GetPetByIdOptions', or 'GetPetByIdOptionsSchemaType' from zod
 * ```
 */
-function resolveOperationTypes(driver) {
+function resolveOperationTypes(driver, pluginName) {
 	const pluginTs = driver.getPlugin(pluginTsName);
 	if (pluginTs) {
 		const resolver = driver.getResolver(pluginTsName);
@@ -851,7 +826,14 @@ function resolveOperationTypes(driver) {
 		};
 	}
 	const pluginZod = driver.getPlugin(pluginZodName);
-	if (!pluginZod?.options?.inferred) return null;
+	if (!pluginZod?.options?.inferred) throw new Diagnostics.Error({
+		code: 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 = driver.getResolver(pluginZodName);
 	return {
 		response: {
@@ -881,20 +863,15 @@ function createClientGenerator(name, resolveClientPath) {
 			if (!ast.isHttpOperationNode(node)) return null;
 			const { config, driver, resolver, root } = ctx;
 			const { output, validator, returnType, throwOnErrorDefault, group } = ctx.options;
-			const types = resolveOperationTypes(driver);
-			if (!types) {
-				ctx.warn(MISSING_OPERATION_TYPES_WARNING);
-				return null;
-			}
+			const types = resolveOperationTypes(driver, ctx.plugin.name);
 			const pluginZod = resolveResponseValidator(validator) === "zod" || resolveRequestValidator(validator) === "zod" ? driver.getPlugin(pluginZodName) : null;
 			const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : null;
-			const hasRequestBody = Boolean(node.requestBody?.content?.[0]?.schema);
 			const importedTypeNames = [types.response.options(node), types.response.responses(node)];
-			const importedZodNames = zodResolver ? [
-				resolveResponseValidator(validator) === "zod" ? zodResolver.response.response?.(node) : null,
-				resolveResponseValidator(validator) === "zod" ? buildZodErrorParse(node, zodResolver)?.expression ?? null : null,
-				resolveRequestValidator(validator) === "zod" && hasRequestBody ? zodResolver.response.body?.(node) : null
-			].filter((name) => Boolean(name)) : [];
+			const importedZodNames = buildValidatorHooks({
+				node,
+				validator,
+				zodResolver
+			}).importedZodNames;
 			const meta = {
 				name: resolver.name(node.operationId),
 				file: resolver.file({
@@ -1070,7 +1047,7 @@ const pluginClient = defineExtension({
 	},
 	dependencies: (options) => ({
 		[pluginTsName]: { optional: true },
-		[pluginZodName]: { optional: !options.validator }
+		[pluginZodName]: { optional: !isValidatorEnabled(options.validator) }
 	}),
 	setup(options) {
 		const { output = {