@kubb/plugin-react-query 5.7.0-canary.20261025T201031 → 5.8.0-canary.20261025T213931

package/dist/index.cjs

@@ -193,6 +193,22 @@ function getOperationParameters(node) {
 	operationParameterGroupsByNode.set(node, groups);
 	return groups;
 }
+/**
+* Builds the combined `{ body, path, query, headers }` options object schema for an operation,
+* referencing the already-resolved body and grouped param names. Shared by `@kubb/plugin-ts`'s
+* `Options` type and `@kubb/plugin-zod`'s inferred options schema, so both printers emit the same
+* shape from the same inputs. `primitive: 'object'` is a no-op for the TS printer and tells the Zod
+* printer to emit `z.object(…)` rather than a record.
+*/
+function hasRequestContentTypeChoice(node) {
+	return (node.requestBody?.content ?? []).filter((entry) => entry.schema).length > 1;
+}
+/**
+* Casts a call argument to the client's parameter type; a `'plain'` client is non-generic.
+*/
+function castToClientOptions(callArg, clientName, returnType = "full") {
+	return `${callArg} as Parameters<typeof ${clientName}${returnType === "plain" ? "" : "<true>"}>[0]`;
+}
 function getStatusCodeNumber(statusCode) {
 	const code = Number(statusCode);
 	return Number.isNaN(code) ? null : code;
@@ -304,6 +320,146 @@ function capitalize(text) {
 	return `${text.charAt(0).toUpperCase()}${text.slice(1)}`;
 }
 //#endregion
+//#region ../../internals/utils/src/reserved.ts
+/**
+* JavaScript and Java reserved words.
+* @link https://github.com/jonschlinkert/reserved/blob/master/index.js
+*/
+const reservedWords = /* @__PURE__ */ new Set([
+	"abstract",
+	"arguments",
+	"await",
+	"boolean",
+	"break",
+	"byte",
+	"case",
+	"catch",
+	"char",
+	"class",
+	"const",
+	"continue",
+	"debugger",
+	"default",
+	"delete",
+	"do",
+	"double",
+	"else",
+	"enum",
+	"eval",
+	"export",
+	"extends",
+	"false",
+	"final",
+	"finally",
+	"float",
+	"for",
+	"function",
+	"goto",
+	"if",
+	"implements",
+	"import",
+	"in",
+	"instanceof",
+	"int",
+	"interface",
+	"let",
+	"long",
+	"native",
+	"new",
+	"null",
+	"package",
+	"private",
+	"protected",
+	"public",
+	"return",
+	"short",
+	"static",
+	"super",
+	"switch",
+	"synchronized",
+	"this",
+	"throw",
+	"throws",
+	"transient",
+	"true",
+	"try",
+	"typeof",
+	"var",
+	"void",
+	"volatile",
+	"while",
+	"with",
+	"yield",
+	"Array",
+	"Date",
+	"hasOwnProperty",
+	"Infinity",
+	"isFinite",
+	"isNaN",
+	"isPrototypeOf",
+	"length",
+	"Math",
+	"name",
+	"NaN",
+	"Number",
+	"Object",
+	"prototype",
+	"String",
+	"toString",
+	"undefined",
+	"valueOf"
+]);
+/**
+* Returns `true` when `name` is a syntactically valid JavaScript variable name.
+*
+* @example
+* ```ts
+* isValidVarName('status')  // true
+* isValidVarName('class')   // false (reserved word)
+* isValidVarName('42foo')   // false (starts with digit)
+* ```
+*/
+function isValidVarName(name) {
+	if (!name || reservedWords.has(name)) return false;
+	return isIdentifier(name);
+}
+/**
+* Returns `name` when it's a syntactically valid JavaScript variable name,
+* otherwise prefixes it with `_` so the result is a valid identifier.
+*
+* Useful for sanitizing OpenAPI schema names or operation IDs that start with
+* a digit (e.g. `409`, `504AccountCancel`) before using them as exported
+* variable, type, or function names.
+*
+* @example
+* ```ts
+* ensureValidVarName('409')             // '_409'
+* ensureValidVarName('504AccountCancel') // '_504AccountCancel'
+* ensureValidVarName('Pet')              // 'Pet'
+* ensureValidVarName('class')            // '_class'
+* ```
+*/
+function ensureValidVarName(name) {
+	if (!name || isValidVarName(name)) return name;
+	return `_${name}`;
+}
+/**
+* Returns `true` when `name` is syntactically a valid identifier, ignoring reserved words.
+*
+* Reserved words and globals (`class`, `name`, `Date`, …) are valid as bare object-literal keys
+* even though they are not valid variable names, so use this (not {@link isValidVarName}) when
+* deciding whether an object key needs quoting.
+*
+* @example
+* ```ts
+* isIdentifier('name')   // true
+* isIdentifier('x-total')// false
+* ```
+*/
+function isIdentifier(name) {
+	return /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(name);
+}
+//#endregion
 //#region ../../internals/utils/src/strings.ts
 /**
 * Renders a dotted path or string array as an optional-chaining accessor expression rooted at
@@ -321,6 +477,11 @@ function getNestedAccessor(param, accessor) {
 	return `${accessor}?.['${`${parts.join("']?.['")}']`}`;
 }
 //#endregion
+//#region ../../internals/shared/src/resolver.ts
+function resolveOperationName(name) {
+	return ensureValidVarName(camelCase(name));
+}
+//#endregion
 //#region ../../internals/shared/src/group.ts
 /**
 * Builds the `group` config a Kubb plugin passes to `ctx.setOptions`, applying the
@@ -359,7 +520,7 @@ var compatibility = {
 };
 //#endregion
 //#region package.json
-var version = "5.7.0-canary.20261025T201031";
+var version = "5.8.0-canary.20261025T213931";
 //#endregion
 //#region ../../internals/client/src/resolveOperationTypes.ts
 /**
@@ -715,7 +876,7 @@ function maybeValueOrGetter(type) {
 * `MaybeRefOrGetter` per group.
 */
 function buildGroupedRequestParam(node, options) {
-	const { resolver, keys = requestGroupOrder, memberTypeWrapper } = options;
+	const { resolver, keys = requestGroupOrder, memberTypeWrapper, withContentType = false } = options;
 	const { groups, hasRequiredPath, hasRequiredQuery, hasRequiredHeader } = getRequestGroupOptionality(node);
 	const names = keys.filter((key) => groups[key]);
 	if (names.length === 0) return null;
@@ -727,6 +888,11 @@ function buildGroupedRequestParam(node, options) {
 	};
 	const isOptional = names.every((name) => !requiredByGroup[name]);
 	const optionsName = resolver.response.options(node);
+	if (withContentType && hasRequestContentTypeChoice(node)) return (0, _kubb_plugin_ts.createFunctionParameter)({
+		name: "variables",
+		type: optionsName,
+		optional: false
+	});
 	const omittedKeys = requestGroupOrder.filter((key) => !keys.includes(key));
 	const optionsType = omittedKeys.length > 0 ? `Omit<${optionsName}, ${omittedKeys.map((key) => `'${key}'`).join(" | ")}>` : optionsName;
 	if (memberTypeWrapper) {
@@ -784,14 +950,17 @@ function buildQueryOptionsParams(node, options) {
 * ```
 */
 function buildClientCall(node, options) {
-	const { clientName, signal = false, unwrapName } = options;
+	const { clientName, signal = false, unwrapName, withContentType = false, returnType = "full" } = options;
 	const { groups } = getRequestGroupOptionality(node);
-	return `${clientName}({ ${[
+	const names = requestGroupOrder.filter((key) => groups[key]);
+	const args = [
 		"...config",
-		...requestGroupOrder.filter((key) => groups[key]).map((name) => unwrapName ? `${name}: ${unwrapName(name)}` : name),
+		...withContentType && hasRequestContentTypeChoice(node) ? ["...variables"] : names.map((name) => unwrapName ? `${name}: ${unwrapName(name)}` : name),
 		signal ? "signal: config.signal ?? signal" : null,
 		"throwOnError: true"
-	].filter((part) => part !== null).join(", ")} })`;
+	].filter((part) => part !== null);
+	if (withContentType && hasRequestContentTypeChoice(node)) return `${clientName}(${castToClientOptions(`{ ${args.join(", ")} }`, clientName, returnType)})`;
+	return `${clientName}({ ${args.join(", ")} })`;
 }
 /**
 * Builds the query/mutation body that resolves a `buildClientCall` expression down to the bare
@@ -1870,14 +2039,19 @@ function MutationOptions({ name, clientName, node, tsResolver, mutationKeyName,
 	const { TData, TError } = buildResponseTypes(node, tsResolver);
 	const configParamsNode = buildMutationConfigParamsNode(node);
 	const paramsSignature = declarationPrinter$1.print(configParamsNode) ?? "";
-	const groupedParam = buildGroupedRequestParam(node, { resolver: tsResolver });
+	const groupedParam = buildGroupedRequestParam(node, {
+		resolver: tsResolver,
+		withContentType: true
+	});
 	const hasMutationParams = groupedParam !== null;
 	const groupedParamsNode = (0, _kubb_plugin_ts.createFunctionParameters)({ params: groupedParam ? [groupedParam] : [] });
 	const TRequest = hasMutationParams ? tsResolver.response.options(node) : "undefined";
 	const argBindingStr = hasMutationParams ? callPrinter$1.print(groupedParamsNode) ?? "" : "_";
 	const mutationFnBody = buildCallResultBody(buildClientCall(node, {
 		clientName,
-		signal: false
+		signal: false,
+		withContentType: true,
+		returnType
 	}), { returnType });
 	return /* @__PURE__ */ (0, kubb_jsx_jsx_runtime.jsx)(kubb_jsx.File.Source, {
 		name,
@@ -2098,7 +2272,7 @@ const suspenseQueryGenerator = createQueryGenerator({
 * `useFooSuspense`, `useFooInfinite`, ...) and its companion helpers
 * (`fooQueryKey`, `fooQueryOptions`).
 *
-* Functions and files use the built-in camelCase casing; hooks get the `use`
+* Functions use safe camelCase identifiers; hooks get the `use`
 * prefix; suspense and infinite variants are suffixed with `Suspense`/`Infinite`.
 *
 * @example Resolve hook and helper names
@@ -2113,6 +2287,7 @@ const suspenseQueryGenerator = createQueryGenerator({
 */
 const resolverReactQuery = (0, kubb_kit.createResolver)({
 	pluginName: "plugin-react-query",
+	name: resolveOperationName,
 	query: createQueryResolver(),
 	suspenseQuery: createQueryResolver("Suspense"),
 	infiniteQuery: createQueryResolver("Infinite"),