@orval/query 8.6.2 → 8.8.0

package/dist/index.mjs

@@ -9,6 +9,8 @@ const normalizeQueryOptions = (queryOptions = {}, outputWorkspace) => {
 	return {
 		...queryOptions.usePrefetch ? { usePrefetch: true } : {},
 		...queryOptions.useInvalidate ? { useInvalidate: true } : {},
+		...queryOptions.useSetQueryData ? { useSetQueryData: true } : {},
+		...queryOptions.useGetQueryData ? { useGetQueryData: true } : {},
 		...queryOptions.useQuery ? { useQuery: true } : {},
 		...queryOptions.useInfinite ? { useInfinite: true } : {},
 		...queryOptions.useInfiniteQueryParam ? { useInfiniteQueryParam: queryOptions.useInfiniteQueryParam } : {},
@@ -340,19 +342,24 @@ const getSignalDefinition = ({ hasSignal, hasSignalParam = false }) => {
 	if (!hasSignal) return "";
 	return `${hasSignalParam ? "querySignal" : "signal"}?: AbortSignal\n`;
 };
-const getQueryArgumentsRequestType = (httpClient, mutator) => {
-	if (!mutator) return httpClient === OutputHttpClient.AXIOS ? `axios?: AxiosRequestConfig` : "fetch?: RequestInit";
+const getQueryArgumentsRequestType = (httpClient, mutator, useRuntimeFetcher) => {
+	if (!mutator) {
+		if (httpClient === OutputHttpClient.AXIOS) return `axios?: AxiosRequestConfig`;
+		if (httpClient === OutputHttpClient.FETCH && useRuntimeFetcher) return "fetch?: RequestInit, fetcher?: typeof globalThis.fetch";
+		return "fetch?: RequestInit";
+	}
 	if (mutator.hasSecondArg && !mutator.isHook) return `request?: SecondParameter<typeof ${mutator.name}>`;
 	if (mutator.hasSecondArg && mutator.isHook) return `request?: SecondParameter<ReturnType<typeof ${mutator.name}>>`;
 	return "";
 };
-const getQueryOptions = ({ isRequestOptions, mutator, isExactOptionalPropertyTypes, hasSignal, httpClient, hasSignalParam = false }) => {
+const getQueryOptions = ({ isRequestOptions, mutator, isExactOptionalPropertyTypes, hasSignal, httpClient, hasSignalParam = false, useRuntimeFetcher = false }) => {
 	const signalVar = hasSignalParam ? "querySignal" : "signal";
 	const signalProp = hasSignalParam ? `signal: ${signalVar}` : "signal";
 	if (!mutator && isRequestOptions) {
 		const options = httpClient === OutputHttpClient.AXIOS ? "axiosOptions" : "fetchOptions";
-		if (!hasSignal) return options;
-		return `{ ${isExactOptionalPropertyTypes ? `...(${signalVar} ? { ${signalProp} } : {})` : signalProp}, ...${options} }`;
+		const fetcherArg = httpClient === OutputHttpClient.FETCH && useRuntimeFetcher ? ", fetcherFn" : "";
+		if (!hasSignal) return `${options}${fetcherArg}`;
+		return `{ ${isExactOptionalPropertyTypes ? `...(${signalVar} ? { ${signalProp} } : {})` : signalProp}, ...${options} }${fetcherArg}`;
 	}
 	if (mutator?.hasSecondArg && httpClient === OutputHttpClient.ANGULAR) {
 		if (!hasSignal) return "http";
@@ -369,13 +376,12 @@ const getQueryOptions = ({ isRequestOptions, mutator, isExactOptionalPropertyTyp
 	}
 	return "";
 };
-const getHookOptions = ({ isRequestOptions, httpClient, mutator }) => {
+const getHookOptions = ({ isRequestOptions, httpClient, mutator, useRuntimeFetcher = false }) => {
 	if (!isRequestOptions) return "";
 	let value = "const {query: queryOptions";
-	if (!mutator) {
-		const options = httpClient === OutputHttpClient.AXIOS ? ", axios: axiosOptions" : ", fetch: fetchOptions";
-		value += options;
-	}
+	if (!mutator) if (httpClient === OutputHttpClient.AXIOS) value += ", axios: axiosOptions";
+	else if (httpClient === OutputHttpClient.FETCH && useRuntimeFetcher) value += ", fetch: fetchOptions, fetcher: fetcherFn";
+	else value += ", fetch: fetchOptions";
 	if (mutator?.hasSecondArg) value += ", request: requestOptions";
 	value += "} = options ?? {};";
 	return value;
@@ -389,8 +395,9 @@ const getQueryErrorType = (operationName, response, httpClient, mutator) => {
 	if (mutator) return mutator.hasErrorType ? `${mutator.default ? pascal(operationName) : ""}ErrorType<${errorsType}>` : errorsType;
 	else return httpClient === OutputHttpClient.AXIOS ? `AxiosError<${errorsType}>` : errorsType;
 };
-const getHooksOptionImplementation = (isRequestOptions, httpClient, operationName, mutator) => {
-	const options = httpClient === OutputHttpClient.AXIOS ? ", axios: axiosOptions" : ", fetch: fetchOptions";
+const getHooksOptionImplementation = (isRequestOptions, httpClient, operationName, mutator, useRuntimeFetcher) => {
+	const fetcherOption = httpClient === OutputHttpClient.FETCH && useRuntimeFetcher ? ", fetcher: fetcherFn" : "";
+	const options = httpClient === OutputHttpClient.AXIOS ? ", axios: axiosOptions" : `, fetch: fetchOptions${fetcherOption}`;
 	return isRequestOptions ? `const mutationKey = ['${operationName}'];
 const {mutation: mutationOptions${mutator ? mutator.hasSecondArg ? ", request: requestOptions" : "" : options}} = options ?
       options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
@@ -398,10 +405,11 @@ const {mutation: mutationOptions${mutator ? mutator.hasSecondArg ? ", request: r
       : {...options, mutation: {...options.mutation, mutationKey}}
       : {mutation: { mutationKey, }${mutator?.hasSecondArg ? ", request: undefined" : ""}${mutator ? "" : httpClient === OutputHttpClient.AXIOS ? ", axios: undefined" : ", fetch: undefined"}};` : "";
 };
-const getMutationRequestArgs = (isRequestOptions, httpClient, mutator) => {
+const getMutationRequestArgs = (isRequestOptions, httpClient, mutator, useRuntimeFetcher) => {
 	const options = httpClient === OutputHttpClient.AXIOS ? "axiosOptions" : "fetchOptions";
+	const fetcherArg = httpClient === OutputHttpClient.FETCH && useRuntimeFetcher ? ", fetcherFn" : "";
 	if (mutator?.hasSecondArg && httpClient === OutputHttpClient.ANGULAR) return "http";
-	return isRequestOptions ? mutator ? mutator.hasSecondArg ? "requestOptions" : "" : options : "";
+	return isRequestOptions ? mutator ? mutator.hasSecondArg ? "requestOptions" : "" : `${options}${fetcherArg}` : "";
 };
 const getQueryHeader = (params) => {
 	if (params.output.httpClient === OutputHttpClient.FETCH) return generateFetchHeader(params);
@@ -1000,7 +1008,7 @@ const createAngularAdapter = ({ hasQueryV5, hasQueryV5WithDataTagError, hasQuery
 		getQueryOptionsDefinitionPrefix() {
 			return prefix;
 		},
-		generateQueryArguments({ operationName, definitions, mutator, isRequestOptions, type, queryParams, queryParam, initialData, httpClient, forQueryOptions = false, hasInvalidation }) {
+		generateQueryArguments({ operationName, definitions, mutator, isRequestOptions, type, queryParams, queryParam, initialData, httpClient, forQueryOptions = false, hasInvalidation, useRuntimeFetcher }) {
 			const definition = getQueryOptionsDefinition({
 				operationName,
 				mutator,
@@ -1015,7 +1023,7 @@ const createAngularAdapter = ({ hasQueryV5, hasQueryV5WithDataTagError, hasQuery
 				initialData
 			});
 			if (!isRequestOptions) return `${type ? "queryOptions" : "mutationOptions"}${initialData === "defined" ? "" : "?"}: ${definition}`;
-			const requestType = getQueryArgumentsRequestType(httpClient, mutator);
+			const requestType = getQueryArgumentsRequestType(httpClient, mutator, useRuntimeFetcher);
 			const isQueryRequired = initialData === "defined";
 			const optionsType = `{ ${type ? "query" : "mutation"}${isQueryRequired ? "" : "?"}:${definition}, ${!type && hasInvalidation ? "skipInvalidation?: boolean, " : ""}${requestType}}`;
 			if (type !== void 0 && !forQueryOptions) return `options${isQueryRequired ? "" : "?"}: ${optionsType} | (() => ${optionsType})\n`;
@@ -1217,7 +1225,7 @@ const createSvelteAdapter = ({ hasSvelteQueryV4, hasSvelteQueryV6, hasQueryV5, h
 		getQueryOptionsDefinitionPrefix() {
 			return prefix;
 		},
-		generateQueryArguments({ operationName, definitions, mutator, isRequestOptions, type, queryParams, queryParam, initialData, httpClient, forQueryOptions = false, hasInvalidation }) {
+		generateQueryArguments({ operationName, definitions, mutator, isRequestOptions, type, queryParams, queryParam, initialData, httpClient, forQueryOptions = false, hasInvalidation, useRuntimeFetcher }) {
 			const definition = getQueryOptionsDefinition({
 				operationName,
 				mutator,
@@ -1232,7 +1240,7 @@ const createSvelteAdapter = ({ hasSvelteQueryV4, hasSvelteQueryV6, hasQueryV5, h
 				initialData
 			});
 			if (!isRequestOptions) return `${type ? "queryOptions" : "mutationOptions"}${initialData === "defined" ? "" : "?"}: ${definition}`;
-			const requestType = getQueryArgumentsRequestType(httpClient, mutator);
+			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 ? "" : "?"}: ${hasSvelteQueryV6 && !forQueryOptions ? "() => " : ""}${optionsType}\n`;
@@ -1384,7 +1392,7 @@ const withDefaults = (adapter) => ({
 	getOptionalQueryClientArgument() {
 		return adapter.hasQueryV5 ? ", queryClient?: QueryClient" : "";
 	},
-	generateQueryArguments({ operationName, definitions, mutator, isRequestOptions, type, queryParams, queryParam, initialData, httpClient, hasInvalidation }) {
+	generateQueryArguments({ operationName, definitions, mutator, isRequestOptions, type, queryParams, queryParam, initialData, httpClient, hasInvalidation, useRuntimeFetcher }) {
 		const definition = getQueryOptionsDefinition({
 			operationName,
 			mutator,
@@ -1399,7 +1407,7 @@ const withDefaults = (adapter) => ({
 			initialData
 		});
 		if (!isRequestOptions) return `${type ? "queryOptions" : "mutationOptions"}${initialData === "defined" ? "" : "?"}: ${definition}`;
-		const requestType = getQueryArgumentsRequestType(httpClient, mutator);
+		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`;
@@ -1502,6 +1510,72 @@ const serializeTarget = (target) => JSON.stringify({
 	invalidateMode: target.invalidateMode,
 	file: target.file ?? ""
 });
+const HTTP_METHODS = [
+	"get",
+	"post",
+	"put",
+	"delete",
+	"patch",
+	"options",
+	"head",
+	"trace"
+];
+/**
+* Look up an operation's route and path-parameter metadata from the OpenAPI
+* spec. Matches against both the raw `operationId` and its camelCase form
+* so that renamed/overridden operations are still found.
+*/
+const findOperationInfo = (spec, operationName) => {
+	const paths = spec?.paths;
+	if (!paths || typeof paths !== "object") return void 0;
+	for (const [routePath, rawPathItem] of Object.entries(paths)) {
+		if (!rawPathItem || typeof rawPathItem !== "object") continue;
+		const pathItem = rawPathItem;
+		for (const method of HTTP_METHODS) {
+			const operation = pathItem[method];
+			const opId = operation?.operationId;
+			if (!opId) continue;
+			if (opId !== operationName && camel(opId) !== operationName) continue;
+			if (!routePath.includes("{")) return {
+				route: routePath,
+				hasRequiredPathParams: false
+			};
+			return {
+				route: routePath,
+				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)
+			};
+		}
+	}
+};
+/**
+* Extract the static route prefix before the first path parameter.
+* e.g. "/pets/{petId}" → "/pets/", "/pets" → "/pets"
+*
+* Returns `undefined` when the prefix contains no meaningful literal
+* segments (e.g. "/{tenantId}/pets") to avoid overly-broad invalidation.
+*/
+const getStaticRoutePrefix = (route) => {
+	const idx = route.indexOf("{");
+	if (idx === -1) return route;
+	const prefix = route.slice(0, idx);
+	return prefix.split("/").some((segment) => segment.length > 0) ? prefix : void 0;
+};
+/**
+* Check whether the target invalidation needs to call the query key function.
+* Returns false when no params are specified and the route has required path
+* parameters (without defaults), meaning we should use predicate-based broad
+* invalidation instead of calling the function without the required arguments.
+*/
+const hasNonEmptyParams = (params) => {
+	if (!params) return false;
+	if (Array.isArray(params)) return params.length > 0;
+	return Object.keys(params).length > 0;
+};
+const needsQueryKeyFnCall = (target, spec) => {
+	if (hasNonEmptyParams(target.params)) return true;
+	if (findOperationInfo(spec, target.query)?.hasRequiredPathParams) return false;
+	return true;
+};
 const generateVariableRef = (varName) => {
 	const parts = varName.split(".");
 	if (parts.length === 1) return `variables.${varName}`;
@@ -1511,10 +1585,25 @@ const generateParamArgs = (params) => {
 	if (Array.isArray(params)) return params.map((v) => generateVariableRef(v)).join(", ");
 	return Object.values(params).map((v) => generateVariableRef(v)).join(", ");
 };
-const generateInvalidateCall = (target) => {
-	const queryKeyFn = camel(`get-${target.query}-query-key`);
-	const args = target.params ? generateParamArgs(target.params) : "";
-	return `    queryClient.${target.invalidateMode === "reset" ? "resetQueries" : "invalidateQueries"}({ queryKey: ${queryKeyFn}(${args}) });`;
+/**
+* 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) => {
+	return (target) => {
+		const method = target.invalidateMode === "reset" ? "resetQueries" : "invalidateQueries";
+		const queryKeyFn = camel(`get-${target.query}-query-key`);
+		if (hasNonEmptyParams(target.params)) return `    queryClient.${method}({ queryKey: ${queryKeyFn}(${generateParamArgs(target.params)}) });`;
+		const info = findOperationInfo(spec, target.query);
+		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(", ")}] });`;
+				return `    queryClient.${method}({ predicate: (query) => typeof query.queryKey[0] === 'string' && query.queryKey[0].startsWith('${prefix}') });`;
+			}
+		}
+		return `    queryClient.${method}({ queryKey: ${queryKeyFn}() });`;
+	};
 };
 const generateMutationHook = async ({ verbOptions, options, isRequestOptions, httpClient, doc, adapter }) => {
 	const { operationName, body, props, mutator, response, operationId, override } = verbOptions;
@@ -1550,13 +1639,15 @@ const generateMutationHook = async ({ verbOptions, options, isRequestOptions, ht
 		return true;
 	});
 	const hasInvalidation = uniqueInvalidates.length > 0 && adapter.supportsMutationInvalidation();
+	const useRuntimeFetcher = override.fetch.useRuntimeFetcher;
 	const mutationArguments = adapter.generateQueryArguments({
 		operationName,
 		definitions,
 		mutator,
 		isRequestOptions,
 		httpClient,
-		hasInvalidation
+		hasInvalidation,
+		useRuntimeFetcher
 	});
 	const mutationArgumentsForOptions = adapter.generateQueryArguments({
 		operationName,
@@ -1565,10 +1656,11 @@ const generateMutationHook = async ({ verbOptions, options, isRequestOptions, ht
 		isRequestOptions,
 		httpClient,
 		forQueryOptions: true,
-		hasInvalidation
+		hasInvalidation,
+		useRuntimeFetcher
 	});
 	const mutationOptionsFnName = camel(mutationOptionsMutator || mutator?.isHook ? `use-${operationName}-mutationOptions` : `get-${operationName}-mutationOptions`);
-	const hooksOptionImplementation = getHooksOptionImplementation(isRequestOptions, httpClient, camel(operationName), mutator);
+	const hooksOptionImplementation = getHooksOptionImplementation(isRequestOptions, httpClient, camel(operationName), mutator, useRuntimeFetcher);
 	const mutationOptionsFn = `export const ${mutationOptionsFnName} = <TError = ${errorType},
     TContext = unknown>(${adapter.getHttpFirstParam(mutator)}${hasInvalidation ? "queryClient: QueryClient, " : ""}${mutationArgumentsForOptions}): ${mutationOptionFnReturnType} => {
 
@@ -1580,14 +1672,14 @@ ${hooksOptionImplementation}
       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)})
+          return  ${operationName}(${adapter.getMutationHttpPrefix(mutator)}${properties}${properties ? "," : ""}${getMutationRequestArgs(isRequestOptions, httpClient, mutator, useRuntimeFetcher)})
         }
 
 ${hasInvalidation ? adapter.generateMutationOnSuccess({
 		operationName,
 		definitions,
 		isRequestOptions,
-		generateInvalidateCall,
+		generateInvalidateCall: createGenerateInvalidateCall(context.spec, !!query.shouldSplitQueryKey),
 		uniqueInvalidates
 	}) : ""}
 
@@ -1631,7 +1723,7 @@ ${mutationHookBody}
     }
     `,
 		mutators: mutationOptionsMutator ? [mutationOptionsMutator] : void 0,
-		imports: hasInvalidation ? uniqueInvalidates.filter((i) => !!i.file).map((i) => ({
+		imports: hasInvalidation ? uniqueInvalidates.filter((i) => !!i.file && needsQueryKeyFnCall(i, context.spec)).map((i) => ({
 			name: camel(`get-${i.query}-query-key`),
 			importPath: i.file,
 			values: true
@@ -1671,7 +1763,7 @@ 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, route, doc, usePrefetch, useQuery, useInfinite, useInvalidate, adapter }) => {
+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 { hasQueryV5, hasQueryV5WithDataTagError, hasQueryV5WithInfiniteQueryOptionsError } = adapter;
 	const hasSignalParam = props.some((prop) => prop.name === "signal");
 	const queryPropDefinitions = toObjectString(props, "definition");
@@ -1713,7 +1805,8 @@ const generateQueryImplementation = ({ queryOption: { name, queryParam, options,
 		queryParams,
 		queryParam,
 		initialData: "defined",
-		httpClient
+		httpClient,
+		useRuntimeFetcher
 	});
 	const undefinedInitialDataQueryArguments = adapter.generateQueryArguments({
 		operationName,
@@ -1724,7 +1817,8 @@ const generateQueryImplementation = ({ queryOption: { name, queryParam, options,
 		queryParams,
 		queryParam,
 		initialData: "undefined",
-		httpClient
+		httpClient,
+		useRuntimeFetcher
 	});
 	const queryArguments = adapter.generateQueryArguments({
 		operationName,
@@ -1734,7 +1828,8 @@ const generateQueryImplementation = ({ queryOption: { name, queryParam, options,
 		type,
 		queryParams,
 		queryParam,
-		httpClient
+		httpClient,
+		useRuntimeFetcher
 	});
 	const queryArgumentsForOptions = adapter.generateQueryArguments({
 		operationName,
@@ -1745,7 +1840,8 @@ const generateQueryImplementation = ({ queryOption: { name, queryParam, options,
 		queryParams,
 		queryParam,
 		httpClient,
-		forQueryOptions: true
+		forQueryOptions: true,
+		useRuntimeFetcher
 	});
 	const queryOptions = getQueryOptions({
 		isRequestOptions,
@@ -1753,12 +1849,14 @@ const generateQueryImplementation = ({ queryOption: { name, queryParam, options,
 		mutator,
 		hasSignal,
 		httpClient,
-		hasSignalParam
+		hasSignalParam,
+		useRuntimeFetcher
 	});
 	const hookOptions = getHookOptions({
 		isRequestOptions,
 		httpClient,
-		mutator
+		mutator,
+		useRuntimeFetcher
 	});
 	const queryFnArguments = getQueryFnArguments({
 		hasQueryParam: !!queryParam && props.some(({ type }) => type === "queryParam"),
@@ -1829,8 +1927,18 @@ export function ${queryHookName}<TData = ${TData}, TError = ${errorType}>(\n ${q
 		isRequestOptions,
 		doc
 	});
-	const shouldGenerateInvalidate = useInvalidate && (type === QueryType.QUERY || type === QueryType.INFINITE || type === QueryType.SUSPENSE_QUERY && !useQuery || type === QueryType.SUSPENSE_INFINITE && !useInfinite);
+	const isPrimaryQueryType = type === QueryType.QUERY || type === QueryType.INFINITE || type === QueryType.SUSPENSE_QUERY && !useQuery || type === QueryType.SUSPENSE_INFINITE && !useInfinite;
+	const shouldGenerateInvalidate = useInvalidate && isPrimaryQueryType;
 	const invalidateFnName = camel(`invalidate-${name}`);
+	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 shouldGenerateGetQueryData = useGetQueryData && isPrimaryQueryType;
+	const getQueryDataFnName = isReactQuery ? camel(`use-get-${name}-query-data`) : camel(`get-${name}-query-data`);
+	const getQueryDataKeyExpr = setQueryDataKeyExpr;
+	const getQueryDataProps = setQueryDataProps;
 	const queryInit = adapter.generateQueryInit({
 		queryOptionsFnName,
 		queryProperties,
@@ -1877,6 +1985,20 @@ ${shouldGenerateInvalidate ? `${doc}export const ${invalidateFnName} = async (\n
 
   return queryClient;
 }\n` : ""}
+${shouldGenerateSetQueryData ? isReactQuery ? `${doc}export const ${setQueryDataFnName} = () => {
+  const queryClient = useQueryClient();
+  return (${setQueryDataProps}updater: ${TData} | undefined | ((old: ${TData} | undefined) => ${TData} | undefined)) => {
+    queryClient.setQueryData(${setQueryDataKeyExpr}, updater);
+  };
+}\n` : `${doc}export const ${setQueryDataFnName} = (queryClient: QueryClient, ${setQueryDataProps}updater: ${TData} | undefined | ((old: ${TData} | undefined) => ${TData} | undefined)) => {
+  queryClient.setQueryData(${setQueryDataKeyExpr}, updater);
+}\n` : ""}
+${shouldGenerateGetQueryData ? isReactQuery ? `${doc}export const ${getQueryDataFnName} = () => {
+  const queryClient = useQueryClient();
+  return (${getQueryDataProps}) =>
+    queryClient.getQueryData<${TData}>(${getQueryDataKeyExpr});
+}\n` : `${doc}export const ${getQueryDataFnName} = (queryClient: QueryClient, ${getQueryDataProps}) =>
+  queryClient.getQueryData<${TData}>(${getQueryDataKeyExpr});\n` : ""}
 `;
 };
 const generateQueryHook = async (verbOptions, options, outputClient, adapter) => {
@@ -2004,6 +2126,7 @@ ${queryKeyFns}`;
 			httpClient,
 			isExactOptionalPropertyTypes,
 			hasSignal: getHasSignal({ overrideQuerySignal: override.query.signal }),
+			useRuntimeFetcher: override.fetch.useRuntimeFetcher,
 			queryOptionsMutator,
 			queryKeyMutator,
 			route,
@@ -2012,6 +2135,8 @@ ${queryKeyFns}`;
 			useQuery: query.useQuery,
 			useInfinite: query.useInfinite,
 			useInvalidate: query.useInvalidate,
+			useSetQueryData: operationQueryOptions?.useSetQueryData ?? query.useSetQueryData,
+			useGetQueryData: operationQueryOptions?.useGetQueryData ?? query.useGetQueryData,
 			adapter
 		});
 		implementation += `