@kubb/plugin-fetch 5.0.0-beta.81 → 5.0.0-beta.85

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/core";
+import { Exclude, Group, Include, Output, OutputOptions, Override, PluginFactoryOptions, Resolver, ast } from "kubb/kit";
 //#region ../../internals/client/src/types.d.ts
 /**
  * Validator applied to request and response bodies using schemas from `@kubb/plugin-zod`.
@@ -179,7 +179,7 @@ declare global {
  * operation using the shared `Operation` component: a grouped `<Name>Request` type and a function that
  * forwards a single `options` object to the bundled `client` and returns the `RequestResult`.
  */
-declare const clientGenerator: import("@kubb/core").Generator<PluginFetch, unknown>;
+declare const clientGenerator: import("kubb/kit").Generator<PluginFetch, unknown>;
 //#endregion
 //#region src/plugin.d.ts
 /**
@@ -195,7 +195,7 @@ declare const pluginFetchName = "plugin-fetch";
  *
  * @example
  * ```ts
- * import { defineConfig } from 'kubb'
+ * import { defineConfig } from 'kubb/config'
  * import { pluginTs } from '@kubb/plugin-ts'
  * import { pluginFetch } from '@kubb/plugin-fetch'
  *
@@ -209,7 +209,7 @@ declare const pluginFetchName = "plugin-fetch";
  * })
  * ```
  */
-declare const pluginFetch: (options?: Options | undefined) => import("@kubb/core").Plugin<PluginFetch>;
+declare const pluginFetch: (options?: Options | undefined) => import("kubb/kit").Plugin<PluginFetch>;
 //#endregion
 export { type Options, type PluginFetch, type ResolvedOptions, type ResolverClient, clientGenerator, pluginFetch as default, pluginFetch, pluginFetchName };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,12 +1,10 @@
 import "./rolldown-runtime-C0LytTxp.js";
 import path from "node:path";
-import { ast, defineGenerator, definePlugin, defineResolver } from "@kubb/core";
-import { File, Function, jsxRenderer } from "@kubb/renderer-jsx";
+import { ast, defineGenerator, definePlugin, defineResolver } from "kubb/kit";
+import { File, Function, jsxRenderer } from "kubb/jsx";
 import { createFunctionParameter, createFunctionParameters, functionPrinter, pluginTsName } from "@kubb/plugin-ts";
-import { Fragment, jsx, jsxs } from "@kubb/renderer-jsx/jsx-runtime";
+import { Fragment, jsx, jsxs } from "kubb/jsx/jsx-runtime";
 import { pluginZodName } from "@kubb/plugin-zod";
-import { buildJSDoc } from "@kubb/ast/utils";
-import { macroSimplifyUnion } from "@kubb/ast/macros";
 import { fileURLToPath } from "node:url";
 //#region ../../internals/utils/src/casing.ts
 /**
@@ -343,6 +341,34 @@ function dedupeByCasedName(params) {
 		return true;
 	});
 }
+function buildParamsMapping(originalParams, mappedParams) {
+	const mapping = {};
+	let hasChanged = false;
+	originalParams.forEach((param, i) => {
+		const mappedName = mappedParams[i]?.name ?? param.name;
+		mapping[param.name] = mappedName;
+		if (param.name !== mappedName) hasChanged = true;
+	});
+	return hasChanged ? mapping : null;
+}
+function toAccess(object, name) {
+	return isValidVarName(name) ? `${object}.${name}` : `${object}[${JSON.stringify(name)}]`;
+}
+/**
+* Renders the object-literal expression that renames the camelCased keys of a grouped request
+* option back to the names the OpenAPI document declares, guarded so an omitted optional group
+* stays omitted. Shared by the client and cypress generators, which pass a `buildParamsMapping`
+* result and the source expression to read the keys from.
+*
+* @example
+* ```ts
+* buildParamsRemapExpression({ source: 'config.query', mapping: { include_deleted: 'includeDeleted' } })
+* // 'config.query ? { "include_deleted": config.query.includeDeleted } : config.query'
+* ```
+*/
+function buildParamsRemapExpression({ source, mapping }) {
+	return `${source} ? { ${Object.entries(mapping).map(([originalName, casedName]) => `${JSON.stringify(originalName)}: ${toAccess(source, casedName)}`).join(", ")} } : ${source}`;
+}
 //#endregion
 //#region ../../internals/shared/src/operation.ts
 /**
@@ -664,6 +690,38 @@ function buildSecurityMetadata({ security }) {
 	return `[${security.map(serializeAuth).join(", ")}]`;
 }
 //#endregion
+//#region ../../internals/client/src/builders/paramsRemap.ts
+/**
+* Builds the call-config entries that rename the camelCased `query` and `headers` keys back to the
+* names the OpenAPI document declares, so the wire format follows the spec while the generated
+* types keep camelCase keys. Returns an empty array when no name changes. Path parameters need no
+* remap because the URL template placeholders are renamed in sync with the `path` keys. Emit the
+* entries after the `...config` spread so they override the camelCased groups the caller passes in.
+*
+* @example
+* ```ts
+* // a query param named include_deleted in the spec
+* buildParamsRemap({ node }) // ['query: config.query ? { "include_deleted": config.query.includeDeleted } : config.query']
+* ```
+*/
+function buildParamsRemap({ node }) {
+	if (!ast.isHttpOperationNode(node)) return [];
+	const original = getOperationParameters(node, { paramsCasing: "original" });
+	const cased = getOperationParameters(node);
+	const queryMapping = buildParamsMapping(original.query, cased.query);
+	const headerMapping = buildParamsMapping(original.header, cased.header);
+	const entries = [];
+	if (queryMapping) entries.push(`query: ${buildParamsRemapExpression({
+		source: "config.query",
+		mapping: queryMapping
+	})}`);
+	if (headerMapping) entries.push(`headers: ${buildParamsRemapExpression({
+		source: "config.headers",
+		mapping: headerMapping
+	})}`);
+	return entries;
+}
+//#endregion
 //#region ../../internals/client/src/builders/generics.ts
 /**
 * Builds the `RequestResult` generic arguments for one operation: the plugin-ts per-status responses
@@ -726,12 +784,13 @@ function buildGroupedOptionsSignature({ node, tsResolver }) {
 //#endregion
 //#region ../../internals/client/src/builders/styles.ts
 /**
-* Renders a parameter name as an object-literal key, quoting it when the camelCased name is not a
-* bare identifier (for example a name that starts with a digit) so the emitted literal stays valid.
+* Renders a parameter name as an object-literal key, quoted when it is not a bare identifier.
+* Path keys are camelCased to match the URL template placeholders. Query, header, and cookie keys
+* keep the spec name, matching the remapped keys the runtime serializes.
 */
-function toKey(name) {
-	const cased = camelCase(name);
-	return isValidVarName(cased) ? cased : JSON.stringify(cased);
+function toKey(name, location) {
+	const key = location === "path" ? camelCase(name) : name;
+	return isValidVarName(key) ? key : JSON.stringify(key);
 }
 /**
 * Serializes one parameter's metadata into a `{ style, explode }` literal, or `null` when the
@@ -745,8 +804,9 @@ function serializeParameter(parameter) {
 	return parts.length > 0 ? `{ ${parts.join(", ")} }` : null;
 }
 /**
-* Builds the per-operation `styles` literal from the operation's parameters, grouped by location and
-* keyed by the camelCased parameter name to match the generated `path` / `query` / `headers` keys.
+* Builds the per-operation `styles` literal from the operation's parameters, grouped by location.
+* Path entries are keyed by the camelCased name to match the URL template placeholders; query,
+* header, and cookie entries keep the spec name to match the keys the runtime serializes.
 * Only parameters whose source defines `style` or `explode` are emitted, so calls without
 * serialization metadata keep the runtime defaults and existing output is unchanged. Returns `null`
 * when no parameter carries metadata.
@@ -768,7 +828,7 @@ function buildStyles({ node }) {
 	for (const parameter of node.parameters) {
 		const literal = serializeParameter(parameter);
 		if (!literal) continue;
-		groups[parameter.in].push(`${toKey(parameter.name)}: ${literal}`);
+		groups[parameter.in].push(`${toKey(parameter.name, parameter.in)}: ${literal}`);
 	}
 	const locations = Object.keys(groups).filter((location) => groups[location].length > 0);
 	if (locations.length === 0) return null;
@@ -841,7 +901,8 @@ function Operation({ name, node, tsResolver, zodResolver, validator, security, i
 		validatorLiteral,
 		contentTypeLiteral,
 		responseTypeLiteral,
-		"...config"
+		"...config",
+		...buildParamsRemap({ node })
 	].filter(Boolean).join(", ")} }`;
 	const eventType = `SuccessOf<${tsResolver.resolveResponsesName(node)}>`;
 	const returnType = eventStream ? `Promise<EventStreamResult<${eventType}>>` : signature.returnType;
@@ -894,7 +955,8 @@ function buildCallConfig({ node, validator, zodResolver, security }) {
 		`url: '${Url.toCasedTemplate(node.path, { casing: "camelcase" })}'`,
 		securityLiteral ? `security: ${securityLiteral}` : null,
 		validatorLiteral,
-		"...config"
+		"...config",
+		...buildParamsRemap({ node })
 	].filter(Boolean).join(", ")} }`;
 }
 /**
@@ -920,7 +982,7 @@ function buildSdkMethod({ node, name, tsResolver, zodResolver, validator, securi
 		})
 	});
 	const generics = signature.generics.length ? `<${signature.generics.join(", ")}>` : "";
-	const jsdoc = buildJSDoc(buildOperationComments(node, {
+	const jsdoc = ast.buildJSDoc(buildOperationComments(node, {
 		link: "urlPath",
 		linkPosition: "beforeDeprecated",
 		splitLines: true
@@ -1234,7 +1296,7 @@ function createSdkGenerator() {
 * drops union members a broader scalar already covers, keeping the generated response and error
 * unions tidy. A plugin wires them with `ctx.setMacros([...defaultMacros, ...userMacros])`.
 */
-const defaultMacros = [macroSimplifyUnion];
+const defaultMacros = [ast.macroSimplifyUnion];
 //#endregion
 //#region ../../internals/client/src/resolver.ts
 /**
@@ -1406,7 +1468,7 @@ const pluginFetchName = "plugin-fetch";
 *
 * @example
 * ```ts
-* import { defineConfig } from 'kubb'
+* import { defineConfig } from 'kubb/config'
 * import { pluginTs } from '@kubb/plugin-ts'
 * import { pluginFetch } from '@kubb/plugin-fetch'
 *