@orval/query 8.9.0 → 8.10.0

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { GetterPropType, OutputClient, OutputHttpClient, TEMPLATE_TAG_REGEX, Verbs, camel, compareVersions, generateFormDataAndUrlEncodedFunction, generateMutator, generateMutatorConfig, generateMutatorRequestOptions, generateOptions, generateVerbImports, getAngularFilteredParamsCallExpression, getAngularFilteredParamsHelperBody, getRouteAsArray, getSuccessResponseType, isObject, isString, isSyntheticDefaultImportsAllow, jsDoc, kebab, mergeDeep, pascal, stringify, toObjectString } from "@orval/core";
+import { GetterPropType, OutputClient, OutputHttpClient, TEMPLATE_TAG_REGEX, Verbs, camel, compareVersions, generateFormDataAndUrlEncodedFunction, generateMutator, generateMutatorConfig, generateMutatorRequestOptions, generateOptions, generateVerbImports, getAngularFilteredParamsCallExpression, getAngularFilteredParamsHelperBody, getRouteAsArray, getSuccessResponseType, isObject, isString, isSyntheticDefaultImportsAllow, jsDoc, kebab, logWarning, mergeDeep, pascal, stringify, toObjectString } from "@orval/core";
 import { generateFetchHeader, generateRequestFunction } from "@orval/fetch";
 import nodePath from "node:path";
 import { styleText } from "node:util";
@@ -10,7 +10,10 @@ const normalizeQueryOptions = (queryOptions = {}, outputWorkspace) => {
 		...queryOptions.useInvalidate ? { useInvalidate: true } : {},
 		...queryOptions.useSetQueryData ? { useSetQueryData: true } : {},
 		...queryOptions.useGetQueryData ? { useGetQueryData: true } : {},
-		...queryOptions.useQuery ? { useQuery: true } : {},
+		...queryOptions.useQuery === void 0 ? {} : { useQuery: queryOptions.useQuery },
+		...queryOptions.useMutation === void 0 ? {} : { useMutation: queryOptions.useMutation },
+		...queryOptions.useSuspenseQuery ? { useSuspenseQuery: true } : {},
+		...queryOptions.useSuspenseInfiniteQuery ? { useSuspenseInfiniteQuery: true } : {},
 		...queryOptions.useInfinite ? { useInfinite: true } : {},
 		...queryOptions.useInfiniteQueryParam ? { useInfiniteQueryParam: queryOptions.useInfiniteQueryParam } : {},
 		...queryOptions.options ? { options: queryOptions.options } : {},
@@ -901,7 +904,7 @@ const generateQueryOptions = ({ params, options, type, adapter }) => {
 		if (options) return `${queryConfig} ...queryOptions`;
 		return "...queryOptions";
 	}
-	return `${adapter ? adapter.generateEnabledOption(params, options) : !isObject(options) || !Object.hasOwn(options, "enabled") ? `enabled: !!(${params.map(({ name }) => name).join(" && ")}),` : ""}${queryConfig} ...queryOptions`;
+	return `${adapter ? adapter.generateEnabledOption(params, options) : !isObject(options) || !Object.hasOwn(options, "enabled") ? `enabled: ${params.map(({ name }) => `${name} != null`).join(" && ")},` : ""}${queryConfig} ...queryOptions`;
 };
 const isSuspenseQuery = (type) => {
 	return [QueryType.SUSPENSE_INFINITE, QueryType.SUSPENSE_QUERY].includes(type);
@@ -1328,7 +1331,8 @@ const createVueAdapter = ({ hasVueQueryV4, hasQueryV5, hasQueryV5WithDataTagErro
 		return vueUnRefParams(props.filter((prop) => prop.type === GetterPropType.NAMED_PATH_PARAMS));
 	},
 	generateEnabledOption(params, options) {
-		if (!isObject(options) || !Object.hasOwn(options, "enabled")) return `enabled: computed(() => !!(${params.map(({ name }) => `unref(${name})`).join(" && ")})),`;
+		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(" && ")}),`;
 		return "";
 	},
 	getQueryKeyPrefix() {
@@ -1378,7 +1382,8 @@ const withDefaults = (adapter) => ({
 		return `\`${route}\``;
 	},
 	generateEnabledOption(params, options) {
-		if (!isObject(options) || !Object.hasOwn(options, "enabled")) return `enabled: !!(${params.map(({ name }) => name).join(" && ")}),`;
+		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) {
@@ -1545,10 +1550,12 @@ const findOperationInfo = (spec, operationName) => {
 			if (opId !== operationName && camel(opId) !== operationName) continue;
 			if (!routePath.includes("{")) return {
 				route: routePath,
+				method,
 				hasRequiredPathParams: false
 			};
 			return {
 				route: routePath,
+				method,
 				hasRequiredPathParams: [...Array.isArray(pathItem.parameters) ? pathItem.parameters : [], ...Array.isArray(operation.parameters) ? operation.parameters : []].filter((p) => p.in === "path").some((p) => p.schema?.default === void 0 && p.default === void 0)
 			};
 		}
@@ -1597,7 +1604,7 @@ const generateParamArgs = (params) => {
 * Create a generateInvalidateCall function that has access to the OpenAPI spec
 * for intelligent route-based invalidation when params are not specified.
 */
-const createGenerateInvalidateCall = (spec, shouldSplitQueryKey) => {
+const createGenerateInvalidateCall = (spec, shouldSplitQueryKey, useOperationIdAsQueryKey) => {
 	return (target) => {
 		const method = target.invalidateMode === "reset" ? "resetQueries" : "invalidateQueries";
 		const queryKeyFn = camel(`get-${target.query}-query-key`);
@@ -1606,7 +1613,15 @@ const createGenerateInvalidateCall = (spec, shouldSplitQueryKey) => {
 		if (info?.hasRequiredPathParams) {
 			const prefix = getStaticRoutePrefix(info.route);
 			if (prefix !== void 0) {
-				if (shouldSplitQueryKey) return `    queryClient.${method}({ queryKey: [${prefix.split("/").filter((s) => s !== "").map((s) => `'${s}'`).join(", ")}] });`;
+				const verbPrefix = getQueryKeyVerbPrefix({
+					verb: info.method,
+					useOperationIdAsQueryKey
+				});
+				if (shouldSplitQueryKey) {
+					const segments = prefix.split("/").filter((s) => s !== "").map((s) => `'${s}'`).join(", ");
+					return `    queryClient.${method}({ queryKey: ${verbPrefix ? `['${verbPrefix}', ${segments}]` : `[${segments}]`} });`;
+				}
+				if (verbPrefix) return `    queryClient.${method}({ predicate: (query) => query.queryKey[0] === '${verbPrefix}' && typeof query.queryKey[1] === 'string' && query.queryKey[1].startsWith('${prefix}') });`;
 				return `    queryClient.${method}({ predicate: (query) => typeof query.queryKey[0] === 'string' && query.queryKey[0].startsWith('${prefix}') });`;
 			}
 		}
@@ -1688,7 +1703,7 @@ ${hasInvalidation ? adapter.generateMutationOnSuccess({
 		operationName,
 		definitions,
 		isRequestOptions,
-		generateInvalidateCall: createGenerateInvalidateCall(context.spec, !!query.shouldSplitQueryKey),
+		generateInvalidateCall: createGenerateInvalidateCall(context.spec, !!query.shouldSplitQueryKey, !!query.useOperationIdAsQueryKey),
 		uniqueInvalidates
 	}) : ""}
 
@@ -1741,6 +1756,70 @@ ${mutationHookBody}
 };
 //#endregion
 //#region src/query-generator.ts
+/**
+* Decide whether the current operation's configuration conflicts with a
+* `mutationInvalidates` rule. The rule wires its invalidation through the
+* Mutation hook's `onSuccess`, so referencing an operation that is not
+* generated as a Mutation (either forced into a Query via per-operation
+* `useQuery: true`, or suppressed entirely) makes the rule a silent no-op.
+*
+* Returns the warning message when the conflict applies, or `undefined`
+* when the configuration is consistent.
+*/
+const getMutationInvalidatesConflictWarning = ({ operationName, isMutation, isQuery, mutationInvalidates }) => {
+	if (isMutation) return void 0;
+	if (!mutationInvalidates?.length) return void 0;
+	if (!mutationInvalidates.find((rule) => rule.onMutations.includes(operationName))) return void 0;
+	return `mutationInvalidates rule references '${operationName}', but that operation is generated as a ${isQuery ? "Query hook" : "plain function (no hook)"}, not a Mutation. The invalidation will not fire. Either remove '${operationName}' from the rule's onMutations list, or configure '${operationName}' so that it is generated as a Mutation hook.`;
+};
+const escapeRegExpMetaChars = (value) => value.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
+/**
+* Wraps the body parameter's type in a property string with the mutator's
+* `BodyType<T>` envelope so that user-facing Query helpers (hook signature,
+* `getXxxQueryOptions`, `getXxxQueryKey`, prefetch / invalidate / set+get
+* QueryData) match the request function's signature, which is already
+* wrapped by `client.ts`. Without this, callers that pass a plain body to
+* a non-GET Query hook (possible after #2376 routes non-GET verbs to
+* Query hooks) would hit a type mismatch against the underlying request
+* function.
+*
+* The pattern handles three prop shapes that the various
+* `toObjectString(props, ...)` callers can emit:
+*   - `name: T`                — required body
+*   - `name?: T`               — optional body
+*   - `name: undefined | T`    — `definedInitialData` overload transform
+*
+* `body.definition` is fully regex-escaped so types containing metachars
+* (e.g. `Pet[]`, `Foo | Bar`, anonymous object types) are matched
+* verbatim rather than reinterpreted as regex syntax.
+*
+* No-op when the operation has no body or the mutator does not export a
+* `BodyType<T>` wrapper, so existing GET-only Query keys are unchanged.
+*/
+const wrapPropsBodyWithMutatorBodyType = ({ propsString, body, mutator }) => {
+	if (!mutator?.bodyTypeName || !body.definition) return propsString;
+	const bodyDefinitionPattern = escapeRegExpMetaChars(body.definition);
+	return propsString.replace(new RegExp(String.raw`(\w+\??:\s*(?:undefined\s*\|\s*)?)${bodyDefinitionPattern}`), `$1${mutator.bodyTypeName}<${body.definition}>`);
+};
+/**
+* Computes a verb prefix segment for query keys when a non-GET operation is
+* routed to a Query hook. Without this prefix, two operations sharing a path
+* (e.g. `GET /pets` and `POST /pets`) would generate cache keys that both
+* begin with `'/pets'`, so TanStack Query would mix their cached data and
+* `invalidateQueries({ queryKey: ['/pets'] })` would match both.
+*
+* Skipped for GET (preserves existing keys) and when
+* `useOperationIdAsQueryKey` is enabled (operation IDs are already unique
+* across verb + path, so the prefix would be redundant).
+*
+* Returns the uppercased verb when a prefix should be inserted, or
+* `undefined` when no prefix is needed.
+*/
+const getQueryKeyVerbPrefix = ({ verb, useOperationIdAsQueryKey }) => {
+	if (useOperationIdAsQueryKey) return void 0;
+	if (verb === Verbs.GET) return void 0;
+	return verb.toUpperCase();
+};
 const getQueryFnArguments = ({ hasQueryParam, hasSignal, hasSignalParam = false }) => {
 	if (!hasQueryParam && !hasSignal) return "";
 	const signalDestructure = hasSignalParam ? "signal: querySignal" : "signal";
@@ -1771,20 +1850,32 @@ const generatePrefetch = ({ usePrefetch, type, useQuery, useInfinite, operationN
   return queryClient;
 }\n`;
 };
-const generateQueryImplementation = ({ queryOption: { name, queryParam, options, type, queryKeyFnName }, operationName, queryProperties, queryKeyProperties, queryParams, params, props, mutator, queryOptionsMutator, queryKeyMutator, isRequestOptions, response, httpClient, isExactOptionalPropertyTypes, hasSignal, useRuntimeFetcher, route, doc, usePrefetch, useQuery, useInfinite, useInvalidate, useSetQueryData, useGetQueryData, adapter }) => {
+const generateQueryImplementation = ({ queryOption: { name, queryParam, options, type, queryKeyFnName }, operationName, queryProperties, queryKeyProperties, queryParams, params, props, body, mutator, queryOptionsMutator, queryKeyMutator, isRequestOptions, response, httpClient, isExactOptionalPropertyTypes, hasSignal, useRuntimeFetcher, route, doc, usePrefetch, useQuery, useInfinite, useInvalidate, useSetQueryData, useGetQueryData, adapter }) => {
 	const { hasQueryV5, hasQueryV5WithDataTagError, hasQueryV5WithInfiniteQueryOptionsError } = adapter;
 	const hasSignalParam = props.some((prop) => prop.name === "signal");
-	const queryPropDefinitions = toObjectString(props, "definition");
-	const definedInitialDataQueryPropsDefinitions = toObjectString(props.map((prop) => {
-		const regex = new RegExp(String.raw`^${prop.name}\s*\?:`);
-		if (!regex.test(prop.definition)) return prop;
-		const definitionWithUndefined = prop.definition.replace(regex, `${prop.name}: undefined | `);
-		return {
-			...prop,
-			definition: definitionWithUndefined
-		};
-	}), "definition");
-	const queryProps = toObjectString(props, "implementation");
+	const queryPropDefinitions = wrapPropsBodyWithMutatorBodyType({
+		propsString: toObjectString(props, "definition"),
+		body,
+		mutator
+	});
+	const definedInitialDataQueryPropsDefinitions = wrapPropsBodyWithMutatorBodyType({
+		propsString: toObjectString(props.map((prop) => {
+			const regex = new RegExp(String.raw`^${prop.name}\s*\?:`);
+			if (!regex.test(prop.definition)) return prop;
+			const definitionWithUndefined = prop.definition.replace(regex, `${prop.name}: undefined | `);
+			return {
+				...prop,
+				definition: definitionWithUndefined
+			};
+		}), "definition"),
+		body,
+		mutator
+	});
+	const queryProps = wrapPropsBodyWithMutatorBodyType({
+		propsString: toObjectString(props, "implementation"),
+		body,
+		mutator
+	});
 	const hasInfiniteQueryParam = queryParam && queryParams?.schema.name;
 	const httpFunctionProps = queryParam ? adapter.getInfiniteQueryHttpProps(props, queryParam, !!mutator) : adapter.getHttpFunctionQueryProps(queryProperties, httpClient, !!mutator);
 	const definedInitialDataReturnType = adapter.getQueryReturnType({
@@ -1937,13 +2028,20 @@ export function ${queryHookName}<TData = ${TData}, TError = ${errorType}>(\n ${q
 	};
 	const prefetch = adapter.generatePrefetch ? adapter.generatePrefetch(prefetchContext) : generatePrefetch(prefetchContext);
 	const isPrimaryQueryType = type === QueryType.QUERY || type === QueryType.INFINITE || type === QueryType.SUSPENSE_QUERY && !useQuery || type === QueryType.SUSPENSE_INFINITE && !useInfinite;
+	const buildBaseQueryKeyExpr = () => queryKeyMutator ? `${queryKeyMutator.name}({ ${queryProperties} }${queryKeyMutator.hasSecondArg ? `, { url: \`${route}\` }` : ""})` : `${queryKeyFnName}(${queryKeyProperties})`;
+	const applyQueryOptionsMutator = (baseExpr) => queryOptionsMutator && !queryOptionsMutator.isHook ? `${queryOptionsMutator.name}({ queryKey: ${baseExpr} }${queryOptionsMutator.hasSecondArg ? `, { ${queryProperties} }` : ""}${queryOptionsMutator.hasThirdArg ? `, { url: \`${route}\` }` : ""}).queryKey` : baseExpr;
 	const shouldGenerateInvalidate = useInvalidate && isPrimaryQueryType;
 	const invalidateFnName = camel(`invalidate-${name}`);
+	const invalidateQueryKeyExpr = applyQueryOptionsMutator(buildBaseQueryKeyExpr());
 	const shouldGenerateSetQueryData = useSetQueryData && isPrimaryQueryType;
 	const isReactQuery = adapter.outputClient === OutputClient.REACT_QUERY;
 	const setQueryDataFnName = isReactQuery ? camel(`use-set-${name}-query-data`) : camel(`set-${name}-query-data`);
-	const setQueryDataKeyExpr = queryKeyMutator ? `${queryKeyMutator.name}({ ${queryProperties} }${queryKeyMutator.hasSecondArg ? `, { url: \`${route}\` }` : ""})` : `${queryKeyFnName}(${queryKeyProperties})`;
-	const setQueryDataProps = toObjectString(props.filter((prop) => prop.type !== GetterPropType.HEADER), "implementation").replaceAll("?:", ":");
+	const setQueryDataKeyExpr = buildBaseQueryKeyExpr();
+	const setQueryDataProps = wrapPropsBodyWithMutatorBodyType({
+		propsString: toObjectString(props.filter((prop) => prop.type !== GetterPropType.HEADER), "implementation").replaceAll("?:", ":"),
+		body,
+		mutator
+	});
 	const shouldGenerateGetQueryData = useGetQueryData && isPrimaryQueryType;
 	const getQueryDataFnName = isReactQuery ? camel(`use-get-${name}-query-data`) : camel(`get-${name}-query-data`);
 	const getQueryDataKeyExpr = setQueryDataKeyExpr;
@@ -1974,7 +2072,11 @@ export type ${pascal(name)}QueryError = ${errorType}
 
 ${adapter.shouldGenerateOverrideTypes() ? overrideTypes : ""}
 ${doc}
-export function ${queryHookName}<TData = ${TData}, TError = ${errorType}>(\n ${adapter.getHookPropsDefinitions(props)} ${queryArguments} ${optionalQueryClientArgument} \n ): ${returnType} {
+export function ${queryHookName}<TData = ${TData}, TError = ${errorType}>(\n ${wrapPropsBodyWithMutatorBodyType({
+		propsString: adapter.getHookPropsDefinitions(props),
+		body,
+		mutator
+	})} ${queryArguments} ${optionalQueryClientArgument} \n ): ${returnType} {
 
   ${queryInit}
 
@@ -1990,7 +2092,7 @@ export function ${queryHookName}<TData = ${TData}, TError = ${errorType}>(\n ${a
 ${prefetch}
 ${shouldGenerateInvalidate ? `${doc}export const ${invalidateFnName} = async (\n queryClient: QueryClient, ${queryProps} options?: InvalidateOptions\n  ): Promise<QueryClient> => {
 
-  await queryClient.invalidateQueries({ queryKey: ${queryKeyFnName}(${queryKeyProperties}) }, options);
+  await queryClient.invalidateQueries({ queryKey: ${invalidateQueryKeyExpr} }, options);
 
   return queryClient;
 }\n` : ""}
@@ -2026,22 +2128,23 @@ const generateQueryHook = async (verbOptions, options, outputClient, adapter) =>
 	});
 	let implementation = "";
 	let mutators;
-	const hasOperationQueryOption = [
-		operationQueryOptions?.useQuery,
-		operationQueryOptions?.useSuspenseQuery,
-		operationQueryOptions?.useInfinite,
-		operationQueryOptions?.useSuspenseInfiniteQuery
-	].some(Boolean);
-	let isQuery = Verbs.GET === verb && [
-		override.query.useQuery,
-		override.query.useSuspenseQuery,
-		override.query.useInfinite,
-		override.query.useSuspenseInfiniteQuery
-	].some(Boolean) || hasOperationQueryOption;
-	let isMutation = override.query.useMutation && verb !== Verbs.GET;
-	if (operationQueryOptions?.useMutation !== void 0) isMutation = operationQueryOptions.useMutation;
+	const effectiveUseQuery = operationQueryOptions?.useQuery ?? override.query.useQuery ?? verb === Verbs.GET;
+	const effectiveUseMutation = operationQueryOptions?.useMutation ?? override.query.useMutation ?? verb !== Verbs.GET;
+	const globalSuspenseOrInfiniteOnlyForGet = (flag) => flag === true && verb === Verbs.GET;
+	const effectiveUseSuspenseQuery = operationQueryOptions?.useSuspenseQuery ?? globalSuspenseOrInfiniteOnlyForGet(override.query.useSuspenseQuery);
+	const effectiveUseInfinite = operationQueryOptions?.useInfinite ?? globalSuspenseOrInfiniteOnlyForGet(override.query.useInfinite);
+	const effectiveUseSuspenseInfiniteQuery = operationQueryOptions?.useSuspenseInfiniteQuery ?? globalSuspenseOrInfiniteOnlyForGet(override.query.useSuspenseInfiniteQuery);
+	let isQuery = effectiveUseQuery || effectiveUseSuspenseQuery || effectiveUseInfinite || effectiveUseSuspenseInfiniteQuery;
+	let isMutation = effectiveUseMutation && verb !== Verbs.GET;
 	if (verb !== Verbs.GET && isQuery) isMutation = false;
 	if (verb === Verbs.GET && isMutation) isQuery = false;
+	const conflictWarning = getMutationInvalidatesConflictWarning({
+		operationName,
+		isMutation,
+		isQuery,
+		mutationInvalidates: override.query.mutationInvalidates
+	});
+	if (conflictWarning) logWarning(conflictWarning);
 	if (isQuery) {
 		const queryKeyMutator = query.queryKey ? await generateMutator({
 			output,
@@ -2064,26 +2167,26 @@ const generateQueryHook = async (verbOptions, options, outputClient, adapter) =>
 			return adapter.getQueryPropertyForProp(param, body);
 		}).join(",");
 		const queries = [
-			...query.useInfinite || operationQueryOptions?.useInfinite ? [{
+			...effectiveUseInfinite ? [{
 				name: camel(`${operationName}-infinite`),
 				options: query.options,
 				type: QueryType.INFINITE,
 				queryParam: query.useInfiniteQueryParam,
 				queryKeyFnName: camel(`get-${operationName}-infinite-query-key`)
 			}] : [],
-			...query.useQuery || operationQueryOptions?.useQuery ? [{
+			...effectiveUseQuery ? [{
 				name: operationName,
 				options: query.options,
 				type: QueryType.QUERY,
 				queryKeyFnName: camel(`get-${operationName}-query-key`)
 			}] : [],
-			...query.useSuspenseQuery || operationQueryOptions?.useSuspenseQuery ? [{
+			...effectiveUseSuspenseQuery ? [{
 				name: camel(`${operationName}-suspense`),
 				options: query.options,
 				type: QueryType.SUSPENSE_QUERY,
 				queryKeyFnName: camel(`get-${operationName}-query-key`)
 			}] : [],
-			...query.useSuspenseInfiniteQuery || operationQueryOptions?.useSuspenseInfiniteQuery ? [{
+			...effectiveUseSuspenseInfiniteQuery ? [{
 				name: camel(`${operationName}-suspense-infinite`),
 				options: query.options,
 				type: QueryType.SUSPENSE_INFINITE,
@@ -2098,18 +2201,27 @@ const generateQueryHook = async (verbOptions, options, outputClient, adapter) =>
 				if (impl.includes("=")) return impl;
 				return impl.replace(/^(\w+):\s*/, "$1?: ");
 			};
-			const queryKeyProps = toObjectString(props.filter((prop) => prop.type !== GetterPropType.HEADER).map((prop) => ({
-				...prop,
-				implementation: prop.type === GetterPropType.PARAM || prop.type === GetterPropType.NAMED_PATH_PARAMS ? prop.implementation : makeOptionalParam(prop.implementation)
-			})), "implementation");
+			const queryKeyProps = wrapPropsBodyWithMutatorBodyType({
+				propsString: toObjectString(props.filter((prop) => prop.type !== GetterPropType.HEADER).map((prop) => ({
+					...prop,
+					implementation: prop.type === GetterPropType.PARAM || prop.type === GetterPropType.NAMED_PATH_PARAMS ? prop.implementation : makeOptionalParam(prop.implementation)
+				})), "implementation"),
+				body,
+				mutator
+			});
 			const routeString = adapter.getQueryKeyRouteString(route, !!override.query.shouldSplitQueryKey);
 			const queryKeyIdentifier = override.query.useOperationIdAsQueryKey ? `"${operationName}"` : routeString;
 			const queryKeyParams = props.filter((p) => override.query.useOperationIdAsQueryKey ? true : p.type === GetterPropType.QUERY_PARAM).toSorted((a) => a.required ? -1 : 1).map((p) => `...(${p.name} ? [${p.name}] : [])`).join(", ");
+			const verbPrefix = getQueryKeyVerbPrefix({
+				verb,
+				useOperationIdAsQueryKey: override.query.useOperationIdAsQueryKey
+			});
 			queryKeyFns += `
 ${override.query.shouldExportQueryKey ? "export " : ""}const ${queryOption.queryKeyFnName} = (${queryKeyProps}) => {
     return [
     ${[
 				queryOption.type === QueryType.INFINITE || queryOption.type === QueryType.SUSPENSE_INFINITE ? `'infinite'` : "",
+				verbPrefix ? `'${verbPrefix}'` : "",
 				queryKeyIdentifier,
 				queryKeyParams,
 				body.implementation
@@ -2128,6 +2240,7 @@ ${queryKeyFns}`;
 			queryKeyProperties,
 			params,
 			props,
+			body,
 			mutator,
 			isRequestOptions,
 			queryParams,
@@ -2141,8 +2254,8 @@ ${queryKeyFns}`;
 			route,
 			doc,
 			usePrefetch: query.usePrefetch,
-			useQuery: query.useQuery,
-			useInfinite: query.useInfinite,
+			useQuery: effectiveUseQuery,
+			useInfinite: effectiveUseInfinite,
 			useInvalidate: query.useInvalidate,
 			useSetQueryData: operationQueryOptions?.useSetQueryData ?? query.useSetQueryData,
 			useGetQueryData: operationQueryOptions?.useGetQueryData ?? query.useGetQueryData,
@@ -2213,10 +2326,12 @@ const generateQuery = async (verbOptions, options, outputClient) => {
 	const imports = generateVerbImports(normalizedVerbOptions);
 	const functionImplementation = adapter.generateRequestFunction(normalizedVerbOptions, options);
 	const { implementation: hookImplementation, imports: hookImports, mutators } = await generateQueryHook(normalizedVerbOptions, options, outputClient, adapter);
+	const isFetchHttpClient = options.context.output.httpClient !== OutputHttpClient.AXIOS;
 	return {
 		implementation: `${functionImplementation}\n\n${hookImplementation}`,
 		imports: [...imports, ...hookImports],
-		mutators
+		mutators,
+		...isFetchHttpClient && { docComment: "" }
 	};
 };
 const dependenciesBuilder = {