@kubb/plugin-fetch 5.1.0-canary.20260824T161549 → 5.1.0

package/dist/index.d.ts

@@ -1,6 +1,5 @@
 import { t as __name } from "./rolldown-runtime-C0LytTxp.js";
 import { Exclude, Group, Include, Output, OutputOptions, Override, PluginFactoryOptions, Resolver, ResolverPatch, ast } from "kubb/kit";
-import "@kubb/plugin-ts";
 import "kubb/jsx";
 import "@kubb/plugin-zod";
 //#region ../../internals/client/src/types.d.ts

package/dist/index.js

@@ -440,15 +440,15 @@ function createGroupConfig(group) {
 //#endregion
 //#region ../../internals/client/src/builders/generics.ts
 /**
-* Builds the `RequestResult` generic arguments for one operation: the plugin-ts per-status responses
-* record plus the per-call `ThrowOnError` flag. `SuccessOf` / `ErrorOf` split the record inside the
+* Builds the `RequestResult` generic arguments for one operation: the per-status responses record
+* plus the per-call `ThrowOnError` flag. `SuccessOf` / `ErrorOf` split the record inside the
 * runtime, so this only names the record and threads `ThrowOnError`.
 *
 * @example
-* `buildRequestResultGenerics({ node, tsResolver }) // 'AddPetResponses, ThrowOnError'`
+* `buildRequestResultGenerics({ node, types }) // 'AddPetResponses, ThrowOnError'`
 */
-function buildRequestResultGenerics({ node, tsResolver }) {
-	return `${tsResolver.response.responses(node)}, ThrowOnError`;
+function buildRequestResultGenerics({ node, types }) {
+	return `${types.response.responses(node)}, ThrowOnError`;
 }
 //#endregion
 //#region ../../internals/client/src/builders/returnStatement.ts
@@ -460,10 +460,10 @@ function buildRequestResultGenerics({ node, tsResolver }) {
 * @example
 * `return request({ method: 'POST', url: '/pet', ...config }) as Promise<RequestResult<AddPetResponses, ThrowOnError>>`
 */
-function buildReturnStatement({ node, tsResolver, callConfig }) {
+function buildReturnStatement({ node, types, callConfig }) {
 	return `return request(${callConfig}) as Promise<RequestResult<${buildRequestResultGenerics({
 		node,
-		tsResolver
+		types
 	})}>>`;
 }
 //#endregion
@@ -539,30 +539,28 @@ function buildSecurityMetadata({ security }) {
 const declarationPrinter = functionPrinter({ mode: "declaration" });
 /**
 * Builds the grouped-options signature for one operation: a single `options` object whose `TData`
-* is the plugin-ts `<Name>Options` (carrying a literal `url`), and a `RequestResult` return type
-* keyed to the plugin-ts per-status responses record. There are no positional arguments.
+* is the `<Name>Options` type, and a `RequestResult` return type keyed to the per-status responses
+* record. There are no positional arguments.
 *
 * The generated file imports `<Name>Options` and `<Name>Responses` and uses them directly, so no
-* per-operation input type has to be emitted.
+* per-operation input type has to be emitted. Both names come from `types`, which is `plugin-ts` or
+* `plugin-zod`'s inferred types (see `resolveOperationTypes`).
 */
-function buildGroupedOptionsSignature({ node, tsResolver }) {
-	const optionsName = tsResolver.response.options(node);
-	const responsesName = tsResolver.response.responses(node);
+function buildGroupedOptionsSignature({ node, types }) {
+	const optionsName = types.response.options(node);
 	const resultGenerics = buildRequestResultGenerics({
 		node,
-		tsResolver
+		types
 	});
 	const { isOptional } = getRequestGroupOptionality(node);
 	return {
-		dataTypeName: optionsName,
 		paramsSignature: declarationPrinter.print(createFunctionParameters({ params: [createFunctionParameter({
 			name: "options",
 			type: `Options<${optionsName}, ThrowOnError>`,
 			...isOptional ? { default: "{}" } : {}
 		})] })) ?? "",
 		returnType: `Promise<RequestResult<${resultGenerics}>>`,
-		generics: ["ThrowOnError extends boolean = true"],
-		importedTypeNames: [optionsName, responsesName]
+		generics: ["ThrowOnError extends boolean = true"]
 	};
 }
 //#endregion
@@ -681,15 +679,15 @@ function buildCallConfig({ node, validator, zodResolver, security }) {
 * returns the `RequestResult`. A per-call `options.client` still overrides the instance client, so
 * one operation can be routed to a different environment without a new instance.
 */
-function buildSdkMethod({ node, name, tsResolver, zodResolver, validator, security }) {
+function buildSdkMethod({ node, name, types, zodResolver, validator, security }) {
 	if (!ast.isHttpOperationNode(node)) return "";
 	const signature = buildGroupedOptionsSignature({
 		node,
-		tsResolver
+		types
 	});
 	const returnStatement = buildReturnStatement({
 		node,
-		tsResolver,
+		types,
 		callConfig: buildCallConfig({
 			node,
 			validator,
@@ -770,11 +768,11 @@ function buildStyles({ node }) {
 * single `options` object to the resolved client and returns the `RequestResult`. The type, signature,
 * and call config are built with the AST factory, and only the jsx-renderer emits the source.
 */
-function Operation({ name, node, tsResolver, zodResolver, validator, security, isExportable = true, isIndexable = true }) {
+function Operation({ name, node, types, zodResolver, validator, security, isExportable = true, isIndexable = true }) {
 	if (!ast.isHttpOperationNode(node)) return null;
 	const signature = buildGroupedOptionsSignature({
 		node,
-		tsResolver
+		types
 	});
 	const validators = buildValidatorHooks({
 		node,
@@ -806,11 +804,11 @@ function Operation({ name, node, tsResolver, zodResolver, validator, security, i
 		responseTypeLiteral,
 		"...config"
 	].filter(Boolean).join(", ")} }`;
-	const eventType = `SuccessOf<${tsResolver.response.responses(node)}>`;
+	const eventType = `SuccessOf<${types.response.responses(node)}>`;
 	const returnType = eventStream ? `Promise<EventStreamResult<${eventType}>>` : signature.returnType;
 	const returnStatement = eventStream ? `return toEventStream<${eventType}>(request(${callConfig}))` : buildReturnStatement({
 		node,
-		tsResolver,
+		types,
 		callConfig
 	});
 	return /* @__PURE__ */ jsx(File.Source, {
@@ -845,10 +843,10 @@ function Operation({ name, node, tsResolver, zodResolver, validator, security, i
 * still overrides the instance client for a one-off call.
 */
 function SdkClient({ name, isExportable = true, isIndexable = true, operations, validator, children }) {
-	const methods = operations.map(({ node, name: methodName, tsResolver, zodResolver, security }) => buildSdkMethod({
+	const methods = operations.map(({ node, name: methodName, types, zodResolver, security }) => buildSdkMethod({
 		node,
 		name: methodName,
-		tsResolver,
+		types,
 		zodResolver,
 		validator,
 		security
@@ -868,6 +866,53 @@ function SdkClient({ name, isExportable = true, isIndexable = true, operations,
 	});
 }
 //#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.
+*
+* @example
+* ```ts
+* const types = resolveOperationTypes(ctx.driver)
+* if (!types) return null
+* types.response.options(node) // 'GetPetByIdOptions', or 'GetPetByIdOptionsSchemaType' from zod
+* ```
+*/
+function resolveOperationTypes(driver) {
+	const pluginTs = driver.getPlugin(pluginTsName);
+	if (pluginTs) {
+		const resolver = driver.getResolver(pluginTsName);
+		return {
+			response: resolver.response,
+			resolver,
+			output: pluginTs.options?.output,
+			group: pluginTs.options?.group
+		};
+	}
+	const pluginZod = driver.getPlugin(pluginZodName);
+	if (!pluginZod?.options?.inferred) return null;
+	const resolver = driver.getResolver(pluginZodName);
+	return {
+		response: {
+			options: resolver.response.options,
+			responses: (node) => resolver.schema.type(resolver.response.responses(node))
+		},
+		resolver,
+		output: pluginZod.options.output,
+		group: pluginZod.options.group
+	};
+}
+//#endregion
 //#region ../../internals/client/src/generators/clientGenerator.tsx
 /**
 * Builds the built-in per-operation generator shared by the client plugins (`@kubb/plugin-fetch`,
@@ -884,13 +929,15 @@ function createClientGenerator(name) {
 			if (!ast.isHttpOperationNode(node)) return null;
 			const { config, driver, resolver, root } = ctx;
 			const { output, validator, group } = ctx.options;
-			const pluginTs = driver.getPlugin(pluginTsName);
-			if (!pluginTs) return null;
-			const tsResolver = driver.getResolver(pluginTsName);
+			const types = resolveOperationTypes(driver);
+			if (!types) {
+				ctx.warn(MISSING_OPERATION_TYPES_WARNING);
+				return null;
+			}
 			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 = [tsResolver.response.options(node), tsResolver.response.responses(node)];
+			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,
@@ -904,13 +951,13 @@ function createClientGenerator(name) {
 					output,
 					group: group ?? void 0
 				}),
-				fileTs: resolveDependencyOperationFile({
+				fileTypes: resolveDependencyOperationFile({
 					cache: ctx.cache,
 					node,
-					resolver: tsResolver,
+					resolver: types.resolver,
 					root,
-					output: pluginTs.options?.output ?? output,
-					group: pluginTs.options?.group
+					output: types.output ?? output,
+					group: types.group
 				}),
 				fileZod: zodResolver && pluginZod?.options ? zodResolver.file({
 					...operationFileEntry(node, node.operationId),
@@ -962,10 +1009,10 @@ function createClientGenerator(name) {
 						path: clientPath,
 						isTypeOnly: true
 					}),
-					meta.fileTs && importedTypeNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
+					meta.fileTypes && importedTypeNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
 						name: Array.from(new Set(importedTypeNames)),
 						root: meta.file.path,
-						path: meta.fileTs.path,
+						path: meta.fileTypes.path,
 						isTypeOnly: true
 					}),
 					meta.fileZod && importedZodNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
@@ -976,7 +1023,7 @@ function createClientGenerator(name) {
 					/* @__PURE__ */ jsx(Operation, {
 						name: meta.name,
 						node,
-						tsResolver,
+						types,
 						zodResolver,
 						validator,
 						security
@@ -1012,8 +1059,8 @@ function SdkFacade({ name, isExportable = true, isIndexable = true, members, chi
 }
 //#endregion
 //#region ../../internals/client/src/generators/sdkGenerator.tsx
-function resolveTypeImportNames(node, tsResolver) {
-	return [tsResolver.response.options(node), tsResolver.response.responses(node)];
+function resolveTypeImportNames(node, types) {
+	return [types.response.options(node), types.response.responses(node)];
 }
 function resolveZodImportNames(node, zodResolver, validator) {
 	const { query: queryParams } = getOperationParameters(node);
@@ -1028,21 +1075,18 @@ function resolveZodImportNames(node, zodResolver, validator) {
 * Groups operations into one controller per tag. Operations without a tag fall back to a single
 * `Client`/`ApiClient` controller, matching the resolver's default naming.
 */
-function buildControllers(nodes, ctx) {
+function buildControllers(nodes, ctx, types) {
 	const { driver, resolver, root } = ctx;
 	const { output, group, validator } = ctx.options;
-	const pluginTs = driver.getPlugin(pluginTsName);
-	const tsResolver = driver.getResolver(pluginTsName);
-	const tsPluginOptions = pluginTs.options;
 	const pluginZod = isValidatorEnabled(validator) ? driver.getPlugin(pluginZodName) : null;
 	const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : null;
 	const document = ctx.adapter.document;
 	function buildOperationData(node) {
-		const typeFile = tsResolver.file({
+		const typeFile = types.resolver.file({
 			...operationFileEntry(node, node.operationId),
 			root,
-			output: tsPluginOptions?.output ?? output,
-			group: tsPluginOptions?.group
+			output: types.output ?? output,
+			group: types.group
 		});
 		const zodFile = zodResolver && pluginZod?.options ? zodResolver.file({
 			...operationFileEntry(node, node.operationId),
@@ -1058,7 +1102,7 @@ function buildControllers(nodes, ctx) {
 		return {
 			node,
 			name: resolver.name(node.operationId),
-			tsResolver,
+			types,
 			zodResolver,
 			typeFile,
 			zodFile,
@@ -1123,8 +1167,13 @@ function createSdkGenerator() {
 		operations(nodes, ctx) {
 			const { config, resolver, root } = ctx;
 			const { output, group, validator, sdk } = ctx.options;
-			if (!ctx.driver.getPlugin(pluginTsName) || !sdk) return null;
-			const controllers = buildControllers(nodes, ctx);
+			if (!sdk) return null;
+			const types = resolveOperationTypes(ctx.driver);
+			if (!types) {
+				ctx.warn(MISSING_OPERATION_TYPES_WARNING);
+				return null;
+			}
+			const controllers = buildControllers(nodes, ctx, types);
 			const clientPath = path.resolve(root, ".kubb/client.ts");
 			const banner = (file) => resolver.default.banner(ctx.meta, {
 				output,
@@ -1145,7 +1194,7 @@ function createSdkGenerator() {
 			const renderClassFile = (className, file, ops) => {
 				const { namesByPath: typeNamesByPath, filesByPath: typeFilesByPath } = collectImportsByFile(ops, (op) => ({
 					file: op.typeFile,
-					names: resolveTypeImportNames(op.node, op.tsResolver)
+					names: resolveTypeImportNames(op.node, op.types)
 				}));
 				const { namesByPath: zodNamesByPath, filesByPath: zodFilesByPath } = isValidatorEnabled(validator) ? collectImportsByFile(ops, (op) => ({
 					file: op.zodFile,
@@ -1352,7 +1401,7 @@ const pluginFetch = definePlugin((options) => {
 	return {
 		name: pluginFetchName,
 		options,
-		dependencies: [pluginTsName, isValidatorEnabled(resolved.validator) ? pluginZodName : null].filter((dependency) => Boolean(dependency)),
+		dependencies: [pluginTsName, pluginZodName],
 		hooks: { "kubb:plugin:setup"(ctx) {
 			ctx.setOptions(resolved);
 			ctx.setResolver(resolved.resolver);