@orval/query 8.18.0 → 8.20.0

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { GetterPropType, OutputClient, OutputHttpClient, Verbs, camel, compareVersions, generateFormDataAndUrlEncodedFunction, generateMutator, generateMutatorConfig, generateMutatorRequestOptions, generateOptions, generateVerbImports, getAngularFilteredParamsCallExpression, getAngularFilteredParamsHelperBody, getFullRoute, getRouteAsArray, getSuccessResponseType, isObject, isString, isSyntheticDefaultImportsAllow, jsDoc, kebab, logWarning, makeRouteSafe, mergeDeep, pascal, stringify, toObjectString } from "@orval/core";
+import { GetterPropType, OutputClient, OutputHttpClient, Verbs, camel, compareVersions, generateFormDataAndUrlEncodedFunction, generateMutator, generateMutatorConfig, generateMutatorRequestOptions, generateOptions, generateVerbImports, getAngularFilteredParamsCallExpression, getAngularFilteredParamsHelperBody, getFullRoute, getRouteAsArray, getSuccessResponseType, isObject, isOperationInTagBucket, isString, isSyntheticDefaultImportsAllow, jsDoc, logWarning, makeRouteSafe, mergeDeep, pascal, stringify, toObjectString } from "@orval/core";
 import { generateFetchHeader, generateRequestFunction } from "@orval/fetch";
 import nodePath from "node:path";
 import { styleText } from "node:util";
@@ -48,24 +48,6 @@ const normalizeMutator = (workspace, mutator) => {
 		default: true
 	};
 };
-function vueWrapTypeWithMaybeRef(props) {
-	return props.map((prop) => {
-		const [paramName, paramType] = prop.implementation.split(":");
-		if (!paramType) return prop;
-		const name = prop.type === GetterPropType.NAMED_PATH_PARAMS ? prop.name : paramName;
-		const [type, defaultValue] = paramType.split("=");
-		return {
-			...prop,
-			implementation: `${name}: MaybeRef<${type.trim()}>${defaultValue ? ` = ${defaultValue}` : ""}`
-		};
-	});
-}
-const vueUnRefParams = (props) => {
-	return props.map((prop) => {
-		if (prop.type === GetterPropType.NAMED_PATH_PARAMS) return `const ${prop.destructured} = unref(${prop.name});`;
-		return `${prop.name} = unref(${prop.name});`;
-	}).join("\n");
-};
 const getQueryTypeForFramework = (type) => {
 	switch (type) {
 		case "suspenseQuery": return "query";
@@ -159,7 +141,6 @@ const generateAngularHttpRequestFunction = ({ headers, queryParams, operationNam
 			hasSignal,
 			hasSignalParam,
 			isExactOptionalPropertyTypes,
-			isVue: false,
 			isAngular: context.output.httpClient === OutputHttpClient.ANGULAR
 		});
 		const requestOptions = isRequestOptions ? generateMutatorRequestOptions(override.requestOptions, mutator.hasSecondArg) : "";
@@ -228,11 +209,11 @@ const generateAngularHttpRequestFunction = ({ headers, queryParams, operationNam
   }
 `;
 };
-const generateAxiosRequestFunction = ({ headers, queryParams, operationName, response, mutator, body, props: _props, verb, formData, formUrlEncoded, override, paramsSerializer }, { route: _route, context }, isVue) => {
-	let props = _props;
+const generateAxiosRequestFunction = ({ headers, queryParams, operationName, response, mutator, body, props: _props, verb, formData, formUrlEncoded, override, paramsSerializer }, { route: _route, context }, adapter) => {
+	const props = adapter.transformProps(_props);
 	let route = _route;
-	if (isVue) props = vueWrapTypeWithMaybeRef(_props);
 	if (context.output.urlEncodeParameters) route = makeRouteSafe(route);
+	const unrefStatements = adapter.getRequestUnrefStatements(props);
 	const isRequestOptions = override.requestOptions !== false;
 	const isFormData = !override.formData.disabled;
 	const isFormUrlEncoded = override.formUrlEncoded !== false;
@@ -258,46 +239,34 @@ const generateAxiosRequestFunction = ({ headers, queryParams, operationName, res
 			isFormUrlEncoded,
 			hasSignal,
 			hasSignalParam,
-			isExactOptionalPropertyTypes,
-			isVue
+			isExactOptionalPropertyTypes
 		});
 		const bodyDefinition = body.definition.replace("[]", String.raw`\[\]`);
 		const propsImplementation = mutator.bodyTypeName && body.definition ? toObjectString(props, "implementation").replace(new RegExp(String.raw`(\w*):\s?${bodyDefinition}`), `$1: ${mutator.bodyTypeName}<${body.definition}>`) : toObjectString(props, "implementation");
 		const requestOptions = isRequestOptions ? generateMutatorRequestOptions(override.requestOptions, mutator.hasSecondArg) : "";
 		if (mutator.isHook) {
-			const ret = `${override.query.shouldExportMutatorHooks ? "export " : ""}const use${pascal(operationName)}Hook = () => {
-        const ${operationName} = ${mutator.name}<${response.definition.success || "unknown"}>();
-
-        return useCallback((\n    ${propsImplementation}\n ${isRequestOptions && mutator.hasSecondArg ? `options${context.output.optionsParamRequired ? "" : "?"}: SecondParameter<ReturnType<typeof ${mutator.name}>>,` : ""}${getSignalDefinition({
+			const callback = `(\n    ${propsImplementation}\n ${isRequestOptions && mutator.hasSecondArg ? `options${context.output.optionsParamRequired ? "" : "?"}: SecondParameter<ReturnType<typeof ${mutator.name}>>,` : ""}${getSignalDefinition({
 				hasSignal,
 				hasSignalParam
-			})}) => {${bodyForm}
+			})}) => {
+        ${unrefStatements}
+        ${bodyForm}
         return ${operationName}(
           ${mutatorConfig},
           ${requestOptions});
-        }, [${operationName}])
-      }
-    `;
-			const vueRet = `${override.query.shouldExportMutatorHooks ? "export " : ""}const use${pascal(operationName)}Hook = () => {
+        }`;
+			return `${override.query.shouldExportMutatorHooks ? "export " : ""}const use${pascal(operationName)}Hook = () => {
         const ${operationName} = ${mutator.name}<${response.definition.success || "unknown"}>();
 
-        return (\n    ${propsImplementation}\n ${isRequestOptions && mutator.hasSecondArg ? `options${context.output.optionsParamRequired ? "" : "?"}: SecondParameter<ReturnType<typeof ${mutator.name}>>,` : ""}${getSignalDefinition({
-				hasSignal,
-				hasSignalParam
-			})}) => {${bodyForm}
-        return ${operationName}(
-          ${mutatorConfig},
-          ${requestOptions});
-        }
+        return ${adapter.wrapHookMutatorCallback(callback, operationName)}
       }
     `;
-			return isVue ? vueRet : ret;
 		}
 		return `${override.query.shouldExportHttpClient ? "export " : ""}const ${operationName} = (\n    ${propsImplementation}\n ${isRequestOptions && mutator.hasSecondArg ? `options${context.output.optionsParamRequired ? "" : "?"}: SecondParameter<typeof ${mutator.name}>,` : ""}${getSignalDefinition({
 			hasSignal,
 			hasSignalParam
 		})}) => {
-      ${isVue ? vueUnRefParams(props) : ""}
+      ${unrefStatements}
       ${bodyForm}
       return ${mutator.name}<${response.definition.success || "unknown"}>(
       ${mutatorConfig},
@@ -320,8 +289,7 @@ const generateAxiosRequestFunction = ({ headers, queryParams, operationName, res
 		paramsSerializerOptions: override.paramsSerializerOptions,
 		isExactOptionalPropertyTypes,
 		hasSignal,
-		hasSignalParam,
-		isVue
+		hasSignalParam
 	});
 	const optionsArgs = generateRequestOptionsArguments({
 		isRequestOptions,
@@ -330,7 +298,7 @@ const generateAxiosRequestFunction = ({ headers, queryParams, operationName, res
 	});
 	const queryProps = toObjectString(props, "implementation");
 	return `${override.query.shouldExportHttpClient ? "export " : ""}const ${operationName} = (\n    ${queryProps} ${optionsArgs} ): Promise<AxiosResponse<${response.definition.success || "unknown"}>> => {
-    ${isVue ? vueUnRefParams(props) : ""}
+    ${unrefStatements}
     ${bodyForm}
     return axios${isSyntheticDefaultImportsAllowed ? "" : ".default"}.${verb}(${options});
   }
@@ -420,7 +388,7 @@ const getMutationRequestArgs = (isRequestOptions, httpClient, mutator, useRuntim
 };
 const getQueryHeader = (params) => {
 	if (params.output.httpClient === OutputHttpClient.FETCH) return generateFetchHeader(params);
-	if (params.output.httpClient === OutputHttpClient.ANGULAR) return (params.tag ? Object.values(params.verbOptions).filter((verbOption) => kebab(verbOption.tags[0] ?? "default") === params.tag) : Object.values(params.verbOptions)).some((v) => v.queryParams) ? getAngularFilteredParamsHelperBody() : "";
+	if (params.output.httpClient === OutputHttpClient.ANGULAR) return Object.values(params.verbOptions).filter((verbOption) => isOperationInTagBucket(verbOption, params.tag)).some((v) => v.queryParams) ? getAngularFilteredParamsHelperBody() : "";
 	return "";
 };
 //#endregion
@@ -702,15 +670,20 @@ const VUE_QUERY_DEPENDENCIES = [{
 	dependency: "@tanstack/vue-query"
 }, {
 	exports: [
+		{
+			name: "computed",
+			values: true
+		},
 		{
 			name: "unref",
 			values: true
 		},
-		{ name: "MaybeRef" },
 		{
-			name: "computed",
+			name: "toValue",
 			values: true
-		}
+		},
+		{ name: "MaybeRef" },
+		{ name: "MaybeRefOrGetter" }
 	],
 	dependency: "vue"
 }];
@@ -1140,9 +1113,6 @@ const createReactAdapter = ({ hasQueryV5, hasQueryV5WithDataTagError, hasQueryV5
 	},
 	generateMutationHookBody({ operationPrefix, mutationImplementation, hasInvalidation, optionalQueryClientArgument }) {
 		return `      ${hasInvalidation ? `const backupQueryClient = useQueryClient();\n      ` : ""}return ${operationPrefix}Mutation(${mutationImplementation}${optionalQueryClientArgument ? `, queryClient` : ""});`;
-	},
-	generateRequestFunction(verbOptions, options) {
-		return options.context.output.httpClient === OutputHttpClient.AXIOS ? generateAxiosRequestFunction(verbOptions, options, false) : generateRequestFunction(verbOptions, options);
 	}
 });
 //#endregion
@@ -1210,9 +1180,6 @@ const createSolidAdapter = ({ hasQueryV5, hasQueryV5WithDataTagError, hasQueryV5
 	},
 	getOptionalQueryClientArgument() {
 		return ", queryClient?: () => QueryClient";
-	},
-	generateRequestFunction(verbOptions, options) {
-		return options.context.output.httpClient === OutputHttpClient.AXIOS ? generateAxiosRequestFunction(verbOptions, options, false) : generateRequestFunction(verbOptions, options);
 	}
 });
 //#endregion
@@ -1309,14 +1276,38 @@ const createSvelteAdapter = ({ hasSvelteQueryV4, hasSvelteQueryV6, hasQueryV5, h
 		getQueryType(type) {
 			if (hasSvelteQueryV4) return getQueryTypeForFramework(type);
 			return type;
-		},
-		generateRequestFunction(verbOptions, options) {
-			return options.context.output.httpClient === OutputHttpClient.AXIOS ? generateAxiosRequestFunction(verbOptions, options, false) : generateRequestFunction(verbOptions, options);
 		}
 	};
 };
 //#endregion
 //#region src/frameworks/vue.ts
+const getVueReactivity = (hasQueryV5) => hasQueryV5 ? {
+	wrapper: "MaybeRefOrGetter",
+	resolve: "toValue"
+} : {
+	wrapper: "MaybeRef",
+	resolve: "unref"
+};
+function vueWrapTypeWithMaybeRef(props, hasQueryV5) {
+	const { wrapper } = getVueReactivity(hasQueryV5);
+	return props.map((prop) => {
+		const [paramName, paramType] = prop.implementation.split(":");
+		if (!paramType) return prop;
+		const name = prop.type === GetterPropType.NAMED_PATH_PARAMS ? prop.name : paramName;
+		const [type, defaultValue] = paramType.split("=");
+		return {
+			...prop,
+			implementation: `${name}: ${wrapper}<${type.trim()}>${defaultValue ? ` = ${defaultValue}` : ""}`
+		};
+	});
+}
+const vueUnRefParams = (props, hasQueryV5) => {
+	const { resolve } = getVueReactivity(hasQueryV5);
+	return props.map((prop) => {
+		if (prop.type === GetterPropType.NAMED_PATH_PARAMS) return `const ${prop.destructured} = ${resolve}(${prop.name});`;
+		return `${prop.name} = ${resolve}(${prop.name});`;
+	}).join("\n");
+};
 const createVueAdapter = ({ hasVueQueryV4, hasQueryV5, hasQueryV5WithDataTagError, hasQueryV5WithInfiniteQueryOptionsError, hasQueryV5WithMutationContextOnSuccess, hasQueryV5WithRequiredContextOnSuccess }) => ({
 	outputClient: OutputClient.VUE_QUERY,
 	hookPrefix: "use",
@@ -1326,19 +1317,23 @@ const createVueAdapter = ({ hasVueQueryV4, hasQueryV5, hasQueryV5WithDataTagErro
 	hasQueryV5WithMutationContextOnSuccess,
 	hasQueryV5WithRequiredContextOnSuccess,
 	transformProps(props) {
-		return vueWrapTypeWithMaybeRef(props);
+		return vueWrapTypeWithMaybeRef(props, hasQueryV5);
 	},
 	shouldDestructureNamedPathParams() {
 		return false;
 	},
 	getHttpFunctionQueryProps(queryProperties, httpClient) {
-		if (httpClient === OutputHttpClient.FETCH && queryProperties) return queryProperties.split(",").map((prop) => `unref(${prop})`).join(",");
+		if (httpClient === OutputHttpClient.FETCH && queryProperties) {
+			const { resolve } = getVueReactivity(hasQueryV5);
+			return queryProperties.split(",").map((prop) => `${resolve}(${prop})`).join(",");
+		}
 		return queryProperties;
 	},
 	getInfiniteQueryHttpProps(props, queryParam, httpClient) {
+		const { resolve } = getVueReactivity(hasQueryV5);
 		return props.map((param) => {
-			if (param.name === "params") return `{...unref(params), '${queryParam}': pageParam ?? unref(params)?.['${queryParam}']}`;
-			return httpClient === OutputHttpClient.FETCH ? `unref(${param.name})` : param.name;
+			if (param.name === "params") return `{...${resolve}(params), '${queryParam}': pageParam ?? ${resolve}(params)?.['${queryParam}']}`;
+			return httpClient === OutputHttpClient.FETCH ? `${resolve}(${param.name})` : param.name;
 		}).join(",");
 	},
 	getQueryReturnType({ type }) {
@@ -1365,12 +1360,21 @@ const createVueAdapter = ({ hasVueQueryV4, hasQueryV5, hasQueryV5WithDataTagErro
 	shouldAnnotateQueryKey() {
 		return false;
 	},
-	getUnrefStatements(props) {
-		return vueUnRefParams(props.filter((prop) => prop.type === GetterPropType.NAMED_PATH_PARAMS));
+	getRequestUnrefStatements(props) {
+		return vueUnRefParams(props, hasQueryV5);
+	},
+	getQueryOptionsUnrefStatements(props) {
+		return vueUnRefParams(props.filter((prop) => prop.type === GetterPropType.NAMED_PATH_PARAMS), hasQueryV5);
+	},
+	wrapHookMutatorCallback(callback) {
+		return callback;
 	},
 	generateEnabledOption(params, options) {
 		if (params.length === 0) return "";
-		if (!isObject(options) || !Object.hasOwn(options, "enabled")) return `enabled: computed(() => ${params.map(({ name }) => `unref(${name}) !== null && unref(${name}) !== undefined`).join(" && ")}),`;
+		if (!isObject(options) || !Object.hasOwn(options, "enabled")) {
+			const { resolve } = getVueReactivity(hasQueryV5);
+			return `enabled: computed(() => ${params.map(({ name }) => `${resolve}(${name}) !== null && ${resolve}(${name}) !== undefined`).join(" && ")}),`;
+		}
 		return "";
 	},
 	getQueryKeyPrefix() {
@@ -1410,9 +1414,6 @@ const createVueAdapter = ({ hasVueQueryV4, hasQueryV5, hasQueryV5WithDataTagErro
 	generateMutationHookBody({ operationPrefix, mutationImplementation, hasInvalidation, optionalQueryClientArgument }) {
 		return `      ${hasInvalidation ? `const backupQueryClient = useQueryClient();\n      ` : ""}return ${operationPrefix}Mutation(${mutationImplementation}${optionalQueryClientArgument ? `, queryClient` : ""});`;
 	},
-	generateRequestFunction(verbOptions, options) {
-		return options.context.output.httpClient === OutputHttpClient.AXIOS ? generateAxiosRequestFunction(verbOptions, options, true) : generateRequestFunction(verbOptions, options);
-	},
 	getQueryPropertyForProp(prop, body) {
 		return prop.type === GetterPropType.BODY ? body.implementation : prop.name;
 	}
@@ -1420,100 +1421,108 @@ const createVueAdapter = ({ hasVueQueryV4, hasQueryV5, hasQueryV5WithDataTagErro
 //#endregion
 //#region src/frameworks/index.ts
 /** Fill in defaults for fields that most adapters leave empty or share a common implementation. */
-const withDefaults = (adapter) => ({
-	isAngularHttp: false,
-	getHttpFirstParam: () => "",
-	getMutationHttpPrefix: () => "",
-	getUnrefStatements: () => "",
-	getQueryInvocationSuffix: () => "",
-	transformProps: (props) => props,
-	getHttpFunctionQueryProps: (qp) => qp,
-	getQueryType: (type) => type,
-	shouldDestructureNamedPathParams: () => true,
-	shouldAnnotateQueryKey: () => true,
-	shouldGenerateOverrideTypes: () => false,
-	shouldCastQueryResult: () => true,
-	shouldCastQueryOptions: () => true,
-	getQueryKeyPrefix: () => "queryOptions?.queryKey ?? ",
-	getQueryOptionsDefinitionPrefix: () => "Use",
-	getHookPropsDefinitions: (props) => toObjectString(props, "implementation"),
-	getQueryKeyRouteString(route, shouldSplitQueryKey) {
-		if (shouldSplitQueryKey) return getRouteAsArray(route);
-		return `\`${route}\``;
-	},
-	generateEnabledOption(params, options) {
-		if (params.length === 0) return "";
-		if (!isObject(options) || !Object.hasOwn(options, "enabled")) return `enabled: ${params.map(({ name }) => `${name} !== null && ${name} !== undefined`).join(" && ")},`;
-		return "";
-	},
-	getQueryPropertyForProp(prop, body) {
-		if (prop.type === GetterPropType.NAMED_PATH_PARAMS) return prop.destructured;
-		return prop.type === GetterPropType.BODY ? body.implementation : prop.name;
-	},
-	getInfiniteQueryHttpProps(props, queryParam) {
-		return props.map((param) => {
-			if (param.type === GetterPropType.NAMED_PATH_PARAMS) return param.destructured;
-			return param.name === "params" ? `{...params, '${queryParam}': pageParam ?? params?.['${queryParam}']}` : param.name;
-		}).join(",");
-	},
-	generateQueryInit({ queryOptionsFnName, queryProperties, isRequestOptions }) {
-		return `const ${isRequestOptions ? "queryOptions" : "options"} = ${queryOptionsFnName}(${queryProperties}${queryProperties ? "," : ""}${isRequestOptions ? "options" : "queryOptions"})`;
-	},
-	generateQueryInvocationArgs({ queryOptionsVarName, optionalQueryClientArgument }) {
-		return `${queryOptionsVarName}${optionalQueryClientArgument ? ", queryClient" : ""}`;
-	},
-	getOptionalQueryClientArgument() {
-		return adapter.hasQueryV5 ? ", queryClient?: QueryClient" : "";
-	},
-	generateQueryArguments({ operationName, definitions, mutator, isRequestOptions, type, queryParams, queryParam, initialData, httpClient, hasInvalidation, useRuntimeFetcher }) {
-		const definition = getQueryOptionsDefinition({
-			operationName,
-			mutator,
-			definitions,
-			type,
-			prefix: adapter.getQueryOptionsDefinitionPrefix?.() ?? "Use",
-			hasQueryV5: adapter.hasQueryV5,
-			hasQueryV5WithInfiniteQueryOptionsError: adapter.hasQueryV5WithInfiniteQueryOptionsError,
-			queryParams,
-			queryParam,
-			isReturnType: false,
-			initialData,
-			adapter
-		});
-		if (!isRequestOptions) return `${type ? "queryOptions" : "mutationOptions"}${initialData === "defined" ? "" : "?"}: ${definition}`;
-		const requestType = getQueryArgumentsRequestType(httpClient, mutator, useRuntimeFetcher);
-		const isQueryRequired = initialData === "defined";
-		const optionsType = `{ ${type ? "query" : "mutation"}${isQueryRequired ? "" : "?"}:${definition}, ${!type && hasInvalidation ? "skipInvalidation?: boolean, " : ""}${requestType}}`;
-		return `options${isQueryRequired ? "" : "?"}: ${optionsType}\n`;
-	},
-	generateMutationOnSuccess({ operationName, definitions, isRequestOptions, generateInvalidateCall, uniqueInvalidates }) {
-		const invalidateCalls = uniqueInvalidates.map((t) => generateInvalidateCall(t)).join("\n");
-		if (adapter.hasQueryV5WithMutationContextOnSuccess) {
-			if (isRequestOptions) return `  const onSuccess = (data: Awaited<ReturnType<typeof ${operationName}>>, variables: ${definitions ? `{${definitions}}` : "void"}, onMutateResult: TContext, context: MutationFunctionContext) => {
+const withDefaults = (adapter) => {
+	const composed = {
+		isAngularHttp: false,
+		getHttpFirstParam: () => "",
+		getMutationHttpPrefix: () => "",
+		getRequestUnrefStatements: () => "",
+		getQueryOptionsUnrefStatements: () => "",
+		wrapHookMutatorCallback: (callback, operationName) => `useCallback(${callback}, [${operationName}])`,
+		getQueryInvocationSuffix: () => "",
+		transformProps: (props) => props,
+		getHttpFunctionQueryProps: (qp) => qp,
+		getQueryType: (type) => type,
+		shouldDestructureNamedPathParams: () => true,
+		shouldAnnotateQueryKey: () => true,
+		shouldGenerateOverrideTypes: () => false,
+		shouldCastQueryResult: () => true,
+		shouldCastQueryOptions: () => true,
+		getQueryKeyPrefix: () => "queryOptions?.queryKey ?? ",
+		getQueryOptionsDefinitionPrefix: () => "Use",
+		getHookPropsDefinitions: (props) => toObjectString(props, "implementation"),
+		getQueryKeyRouteString(route, shouldSplitQueryKey) {
+			if (shouldSplitQueryKey) return getRouteAsArray(route);
+			return `\`${route}\``;
+		},
+		generateEnabledOption(params, options) {
+			if (params.length === 0) return "";
+			if (!isObject(options) || !Object.hasOwn(options, "enabled")) return `enabled: ${params.map(({ name }) => `${name} !== null && ${name} !== undefined`).join(" && ")},`;
+			return "";
+		},
+		getQueryPropertyForProp(prop, body) {
+			if (prop.type === GetterPropType.NAMED_PATH_PARAMS) return prop.destructured;
+			return prop.type === GetterPropType.BODY ? body.implementation : prop.name;
+		},
+		generateRequestFunction(verbOptions, options) {
+			return options.context.output.httpClient === OutputHttpClient.AXIOS ? generateAxiosRequestFunction(verbOptions, options, composed) : generateRequestFunction(verbOptions, options);
+		},
+		getInfiniteQueryHttpProps(props, queryParam) {
+			return props.map((param) => {
+				if (param.type === GetterPropType.NAMED_PATH_PARAMS) return param.destructured;
+				return param.name === "params" ? `{...params, '${queryParam}': pageParam ?? params?.['${queryParam}']}` : param.name;
+			}).join(",");
+		},
+		generateQueryInit({ queryOptionsFnName, queryProperties, isRequestOptions }) {
+			return `const ${isRequestOptions ? "queryOptions" : "options"} = ${queryOptionsFnName}(${queryProperties}${queryProperties ? "," : ""}${isRequestOptions ? "options" : "queryOptions"})`;
+		},
+		generateQueryInvocationArgs({ queryOptionsVarName, optionalQueryClientArgument }) {
+			return `${queryOptionsVarName}${optionalQueryClientArgument ? ", queryClient" : ""}`;
+		},
+		getOptionalQueryClientArgument() {
+			return composed.hasQueryV5 ? ", queryClient?: QueryClient" : "";
+		},
+		generateQueryArguments({ operationName, definitions, mutator, isRequestOptions, type, queryParams, queryParam, initialData, httpClient, hasInvalidation, useRuntimeFetcher }) {
+			const definition = getQueryOptionsDefinition({
+				operationName,
+				mutator,
+				definitions,
+				type,
+				prefix: composed.getQueryOptionsDefinitionPrefix(),
+				hasQueryV5: composed.hasQueryV5,
+				hasQueryV5WithInfiniteQueryOptionsError: composed.hasQueryV5WithInfiniteQueryOptionsError,
+				queryParams,
+				queryParam,
+				isReturnType: false,
+				initialData,
+				adapter: composed
+			});
+			if (!isRequestOptions) return `${type ? "queryOptions" : "mutationOptions"}${initialData === "defined" ? "" : "?"}: ${definition}`;
+			const requestType = getQueryArgumentsRequestType(httpClient, mutator, useRuntimeFetcher);
+			const isQueryRequired = initialData === "defined";
+			const optionsType = `{ ${type ? "query" : "mutation"}${isQueryRequired ? "" : "?"}:${definition}, ${!type && hasInvalidation ? "skipInvalidation?: boolean, " : ""}${requestType}}`;
+			return `options${isQueryRequired ? "" : "?"}: ${optionsType}\n`;
+		},
+		generateMutationOnSuccess({ operationName, definitions, isRequestOptions, generateInvalidateCall, uniqueInvalidates }) {
+			const invalidateCalls = uniqueInvalidates.map((t) => generateInvalidateCall(t)).join("\n");
+			if (composed.hasQueryV5WithMutationContextOnSuccess) {
+				if (isRequestOptions) return `  const onSuccess = (data: Awaited<ReturnType<typeof ${operationName}>>, variables: ${definitions ? `{${definitions}}` : "void"}, onMutateResult: TContext, context: MutationFunctionContext) => {
         if (!options?.skipInvalidation) {
     ${invalidateCalls}
         }
         mutationOptions?.onSuccess?.(data, variables, onMutateResult, context);
       };`;
-			return `  const onSuccess = (data: Awaited<ReturnType<typeof ${operationName}>>, variables: ${definitions ? `{${definitions}}` : "void"}, onMutateResult: TContext, context: MutationFunctionContext) => {
+				return `  const onSuccess = (data: Awaited<ReturnType<typeof ${operationName}>>, variables: ${definitions ? `{${definitions}}` : "void"}, onMutateResult: TContext, context: MutationFunctionContext) => {
     ${invalidateCalls}
         mutationOptions?.onSuccess?.(data, variables, onMutateResult, context);
       };`;
-		} else {
-			if (isRequestOptions) return `  const onSuccess = (data: Awaited<ReturnType<typeof ${operationName}>>, variables: ${definitions ? `{${definitions}}` : "void"}, context: TContext${adapter.hasQueryV5WithRequiredContextOnSuccess ? "" : " | undefined"}) => {
+			} else {
+				if (isRequestOptions) return `  const onSuccess = (data: Awaited<ReturnType<typeof ${operationName}>>, variables: ${definitions ? `{${definitions}}` : "void"}, context: TContext${composed.hasQueryV5WithRequiredContextOnSuccess ? "" : " | undefined"}) => {
         if (!options?.skipInvalidation) {
     ${invalidateCalls}
         }
         mutationOptions?.onSuccess?.(data, variables, context);
       };`;
-			return `  const onSuccess = (data: Awaited<ReturnType<typeof ${operationName}>>, variables: ${definitions ? `{${definitions}}` : "void"}, context: TContext${adapter.hasQueryV5WithRequiredContextOnSuccess ? "" : " | undefined"}) => {
+				return `  const onSuccess = (data: Awaited<ReturnType<typeof ${operationName}>>, variables: ${definitions ? `{${definitions}}` : "void"}, context: TContext${composed.hasQueryV5WithRequiredContextOnSuccess ? "" : " | undefined"}) => {
     ${invalidateCalls}
         mutationOptions?.onSuccess?.(data, variables, context);
       };`;
-		}
-	},
-	...adapter
-});
+			}
+		},
+		...adapter
+	};
+	return composed;
+};
 /**
 * Create a FrameworkAdapter for the given output client, resolving version flags
 * from the packageJson and query config.
@@ -1594,6 +1603,33 @@ const HTTP_METHODS = [
 	"head",
 	"trace"
 ];
+const MUTATION_OPERATION_LOCAL_NAMES = new Set([
+	"backupQueryClient",
+	"context",
+	"customOptions",
+	"data",
+	"fetchOptions",
+	"http",
+	"mutationFn",
+	"mutationKey",
+	"mutationOptions",
+	"onMutateResult",
+	"onSuccess",
+	"options",
+	"props",
+	"queryClient",
+	"variables"
+]);
+const getMutationOperationReferenceName = (operationName, localNames) => {
+	if (!localNames.has(operationName)) return operationName;
+	let candidate = camel(`${operationName}-request-fn`);
+	let index = 2;
+	while (localNames.has(candidate)) {
+		candidate = camel(`${operationName}-request-fn-${index}`);
+		index += 1;
+	}
+	return candidate;
+};
 /**
 * Look up an operation's route and path-parameter metadata from the OpenAPI
 * spec. Matches against both the raw `operationId` and its camelCase form
@@ -1739,10 +1775,14 @@ const generateMutationHook = async ({ verbOptions, options, isRequestOptions, ht
 	const bodyOptionalMark = body.isOptional ? "?" : "";
 	const definitions = props.map(({ definition, type }) => type === GetterPropType.BODY ? mutator?.bodyTypeName ? `data${bodyOptionalMark}: ${mutator.bodyTypeName}<${body.definition}>` : `data${bodyOptionalMark}: ${body.definition}` : definition).join(";");
 	const properties = props.map(({ name, type }) => type === GetterPropType.BODY ? "data" : name).join(",");
+	const operationLocalNames = new Set(MUTATION_OPERATION_LOCAL_NAMES);
+	for (const { name, type } of props) operationLocalNames.add(type === GetterPropType.BODY ? "data" : name);
 	const errorType = getQueryErrorType(operationName, response, httpClient, mutator, override.fetch.forceSuccessResponse);
-	const dataType = mutator?.isHook ? `ReturnType<typeof use${pascal(operationName)}Hook>` : `typeof ${operationName}`;
+	const operationReferenceName = getMutationOperationReferenceName(operationName, operationLocalNames);
+	const dataType = mutator?.isHook ? `ReturnType<typeof use${pascal(operationName)}Hook>` : `typeof ${operationReferenceName}`;
+	const operationTypeReferenceName = mutator?.isHook ? operationName : operationReferenceName;
 	const mutationOptionFnReturnType = getQueryOptionsDefinition({
-		operationName,
+		operationName: operationTypeReferenceName,
 		mutator,
 		definitions,
 		prefix: adapter.getQueryOptionsDefinitionPrefix(),
@@ -1762,7 +1802,7 @@ const generateMutationHook = async ({ verbOptions, options, isRequestOptions, ht
 	const hasInvalidation = uniqueInvalidates.length > 0 && adapter.supportsMutationInvalidation();
 	const useRuntimeFetcher = override.fetch.useRuntimeFetcher;
 	const mutationArguments = adapter.generateQueryArguments({
-		operationName,
+		operationName: operationTypeReferenceName,
 		definitions,
 		mutator,
 		isRequestOptions,
@@ -1771,7 +1811,7 @@ const generateMutationHook = async ({ verbOptions, options, isRequestOptions, ht
 		useRuntimeFetcher
 	});
 	const mutationArgumentsForOptions = adapter.generateQueryArguments({
-		operationName,
+		operationName: operationTypeReferenceName,
 		definitions,
 		mutator,
 		isRequestOptions,
@@ -1787,13 +1827,13 @@ const generateMutationHook = async ({ verbOptions, options, isRequestOptions, ht
 
 ${hooksOptionImplementation}
 
-      ${mutator?.isHook ? `const ${operationName} =  use${pascal(operationName)}Hook()` : ""}
+      ${mutator?.isHook ? `const ${operationReferenceName} =  use${pascal(operationName)}Hook()` : ""}
 
 
       const mutationFn: MutationFunction<Awaited<ReturnType<${dataType}>>, ${definitions ? `{${definitions}}` : "void"}> = (${properties ? "props" : ""}) => {
           ${properties ? `const {${properties}} = props ?? {};` : ""}
 
-          return  ${operationName}(${adapter.getMutationHttpPrefix(mutator)}${properties}${properties ? "," : ""}${getMutationRequestArgs(isRequestOptions, httpClient, mutator, useRuntimeFetcher)})
+          return  ${operationReferenceName}(${adapter.getMutationHttpPrefix(mutator)}${properties}${properties ? "," : ""}${getMutationRequestArgs(isRequestOptions, httpClient, mutator, useRuntimeFetcher)})
         }
 
 ${hasInvalidation ? adapter.generateMutationOnSuccess({
@@ -1832,6 +1872,7 @@ ${hasInvalidation ? adapter.generateMutationOnSuccess({
 	});
 	return {
 		implementation: `
+${!mutator?.isHook && operationReferenceName !== operationName ? `const ${operationReferenceName} = ${operationName};` : ""}
 ${mutationOptionsFn}
 
     export type ${pascal(operationName)}MutationResult = NonNullable<Awaited<ReturnType<${dataType}>>>
@@ -2154,7 +2195,7 @@ ${hookOptions}
 
     const queryFn: QueryFunction<Awaited<ReturnType<${mutator?.isHook ? `ReturnType<typeof use${pascal(operationName)}Hook>` : `typeof ${operationName}`}>>${hasQueryV5 && hasInfiniteQueryParam ? `, QueryKey, ${infiniteQueryParamType}` : ""}> = (${queryFnArguments}) => ${operationName}(${httpFunctionProps}${httpFunctionProps ? ", " : ""}${queryOptions});
 
-      ${adapter.getUnrefStatements(props)}
+      ${adapter.getQueryOptionsUnrefStatements(props)}
 
       ${queryOptionsMutator ? `const customOptions = ${queryOptionsMutator.name}({ queryKey, queryFn, ${queryOptionsImp}}${queryOptionsMutator.hasSecondArg ? `, { ${queryProperties} }` : ""}${queryOptionsMutator.hasThirdArg ? `, { url: \`${route}\`, operationId: '${operationId}', operationName: '${operationName}' }` : ""});` : ""}
 
@@ -2467,11 +2508,19 @@ const WITH_QUERY_KEY_HELPER = `const withQueryKey = <T extends object, K>(query:
 };`;
 const generateQueryHeader = (params) => {
 	const needsWithQueryKey = params.clientImplementation.includes("withQueryKey(");
-	return `${params.hasAwaitedType ? "" : `type AwaitedInput<T> = PromiseLike<T> | T;\n
+	const innerHeader = getQueryHeader(params);
+	const innerImpl = typeof innerHeader === "string" ? innerHeader : innerHeader.implementation;
+	const innerSharedTypes = typeof innerHeader === "string" ? void 0 : innerHeader.sharedTypes;
+	const ownImplementation = `${params.hasAwaitedType ? "" : `type AwaitedInput<T> = PromiseLike<T> | T;\n
       type Awaited<O> = O extends AwaitedInput<infer T> ? T : never;\n\n`}
 ${params.isRequestOptions && params.isMutator ? `type SecondParameter<T extends (...args: never) => unknown> = Parameters<T>[1];\n\n` : ""}
-${getQueryHeader(params)}
+${innerImpl}
 ${needsWithQueryKey ? `${WITH_QUERY_KEY_HELPER}\n\n` : ""}`;
+	if (innerSharedTypes && innerSharedTypes.length > 0) return {
+		implementation: ownImplementation,
+		sharedTypes: innerSharedTypes
+	};
+	return ownImplementation;
 };
 const generateQuery = async (verbOptions, options, outputClient) => {
 	const isZodOutput = typeof options.context.output.schemas === "object" && options.context.output.schemas.type === "zod";