@orval/query 8.23.0 → 8.25.0

package/dist/index.d.mts

@@ -1,5 +1,4 @@
 import { ClientBuilder, ClientDependenciesBuilder, ClientHeaderBuilder, NormalizedOutputOptions, QueryOptions } from "@orval/core";
-
 //#region src/dependencies.d.ts
 declare const getSvelteQueryDependencies: ClientDependenciesBuilder;
 declare const getReactQueryDependencies: ClientDependenciesBuilder;
@@ -10,11 +9,7 @@ declare const getAngularQueryDependencies: ClientDependenciesBuilder;
 //#region src/index.d.ts
 declare const generateQueryHeader: ClientHeaderBuilder;
 declare const generateQuery: ClientBuilder;
-declare const builder: ({
-  type,
-  options: queryOptions,
-  output
-}?: {
+declare const builder: ({ type, options: queryOptions, output }?: {
   type?: "react-query" | "vue-query" | "svelte-query" | "angular-query" | "solid-query";
   options?: QueryOptions;
   output?: NormalizedOutputOptions;

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { GetterPropType, OutputClient, OutputHttpClient, Verbs, camel, compareVersions, generateFormDataAndUrlEncodedFunction, generateMutator, generateMutatorConfig, generateMutatorRequestOptions, generateOptions, generateVerbImports, getAngularFilteredParamsCallExpression, getAngularFilteredParamsHelperBody, getFullRoute, getRoute, getRouteAsArray, getSuccessResponseType, isObject, isOperationInTagBucket, isString, isSyntheticDefaultImportsAllow, jsDoc, logWarning, makeRouteSafe, mergeDeep, pascal, stringify, toObjectString } from "@orval/core";
+import { GetterPropType, OutputClient, OutputHttpClient, Verbs, camel, compareVersions, generateFormDataAndUrlEncodedFunction, generateMutator, generateMutatorConfig, generateMutatorRequestOptions, generateOptions, generateResponseDateDeserializer, generateVerbImports, getAngularFilteredParamsCallExpression, getAngularFilteredParamsHelperBody, getFullRoute, getRoute, 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";
@@ -180,9 +180,7 @@ const generateAngularHttpRequestFunction = ({ headers, queryParams, operationNam
 		case "delete":
 			httpCall = bodyArg ? `http.${verb}${httpGeneric}(url, { ${httpOptions.length > 0 ? httpOptions.join(", ") + ", " : ""}body: ${bodyArg} })` : `http.${verb}${httpGeneric}(url${optionsStr})`;
 			break;
-		default:
-			httpCall = `http.${verb}${httpGeneric}(url, ${bodyArg || "undefined"}${optionsStr})`;
-			break;
+		default: httpCall = `http.${verb}${httpGeneric}(url, ${bodyArg || "undefined"}${optionsStr})`;
 	}
 	const responseType = response.definition.success;
 	const isPrimitiveType = [
@@ -227,6 +225,13 @@ const generateAxiosRequestFunction = ({ headers, queryParams, operationName, res
 		isFormData,
 		isFormUrlEncoded
 	});
+	const dateDeserializer = override.useDatesTransform ? generateResponseDateDeserializer({
+		operationName,
+		response,
+		context
+	}) : void 0;
+	const dateDeserializerImplementation = dateDeserializer ? `\n${dateDeserializer.implementation}` : "";
+	const thenDateDeserializer = dateDeserializer ? `.then(${dateDeserializer.name})` : "";
 	if (mutator) {
 		const mutatorConfig = generateMutatorConfig({
 			route,
@@ -253,14 +258,14 @@ const generateAxiosRequestFunction = ({ headers, queryParams, operationName, res
         ${bodyForm}
         return ${operationName}(
           ${mutatorConfig},
-          ${requestOptions});
+          ${requestOptions})${thenDateDeserializer};
         }`;
 			return `${override.query.shouldExportMutatorHooks ? "export " : ""}const use${pascal(operationName)}Hook = () => {
         const ${operationName} = ${mutator.name}<${response.definition.success || "unknown"}>();
 
         return ${adapter.wrapHookMutatorCallback(callback, operationName)}
       }
-    `;
+    ${dateDeserializerImplementation}`;
 		}
 		return `${override.query.shouldExportHttpClient ? "export " : ""}const ${operationName} = (\n    ${propsImplementation}\n ${isRequestOptions && mutator.hasSecondArg ? `options${context.output.optionsParamRequired ? "" : "?"}: SecondParameter<typeof ${mutator.name}>,` : ""}${getSignalDefinition({
 			hasSignal,
@@ -270,9 +275,9 @@ const generateAxiosRequestFunction = ({ headers, queryParams, operationName, res
       ${bodyForm}
       return ${mutator.name}<${response.definition.success || "unknown"}>(
       ${mutatorConfig},
-      ${requestOptions});
+      ${requestOptions})${thenDateDeserializer};
     }
-  `;
+  ${dateDeserializerImplementation}`;
 	}
 	const isSyntheticDefaultImportsAllowed = isSyntheticDefaultImportsAllow(context.output.tsconfig);
 	const options = generateOptions({
@@ -300,9 +305,9 @@ const generateAxiosRequestFunction = ({ headers, queryParams, operationName, res
 	return `${override.query.shouldExportHttpClient ? "export " : ""}const ${operationName} = (\n    ${queryProps} ${optionsArgs} ): Promise<AxiosResponse<${response.definition.success || "unknown"}>> => {
     ${unrefStatements}
     ${bodyForm}
-    return axios${isSyntheticDefaultImportsAllowed ? "" : ".default"}.${verb}(${options});
+    return axios${isSyntheticDefaultImportsAllowed ? "" : ".default"}.${verb}(${options})${dateDeserializer ? `.then((res) => { res.data = ${dateDeserializer.name}(res.data); return res; })` : ""};
   }
-`;
+${dateDeserializerImplementation}`;
 };
 const generateRequestOptionsArguments = ({ isRequestOptions, hasSignal, hasSignalParam = false }) => {
 	if (isRequestOptions) return "options?: AxiosRequestConfig\n";
@@ -352,9 +357,11 @@ const getQueryOptions = ({ isRequestOptions, mutator, isExactOptionalPropertyTyp
 const getHookOptions = ({ isRequestOptions, httpClient, mutator, useRuntimeFetcher = false }) => {
 	if (!isRequestOptions) return "";
 	let value = "const {query: queryOptions";
-	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) {
+		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;
@@ -715,6 +722,12 @@ const getSolidQueryImports = (prefix, hasRenamedOptionsTypes) => {
 			{ name: "MutationFunction" },
 			{ name: `${capitalized}QueryResult` },
 			{ name: `${capitalized}InfiniteQueryResult` },
+			{ name: `Defined${capitalized}QueryResult` },
+			{ name: `Defined${capitalized}InfiniteQueryResult` },
+			{ name: "DefinedInitialDataOptions" },
+			{ name: "UndefinedInitialDataOptions" },
+			{ name: "DefinedInitialDataInfiniteOptions" },
+			{ name: "UndefinedInitialDataInfiniteOptions" },
 			{ name: "QueryKey" },
 			{ name: "InfiniteData" },
 			{ name: `${capitalized}MutationResult` },
@@ -906,10 +919,16 @@ const QueryType = {
 	SUSPENSE_QUERY: "suspenseQuery",
 	SUSPENSE_INFINITE: "suspenseInfiniteQuery"
 };
-const INFINITE_QUERY_PROPERTIES = new Set(["getNextPageParam", "getPreviousPageParam"]);
+const INFINITE_QUERY_PROPERTIES = /* @__PURE__ */ new Set(["getNextPageParam", "getPreviousPageParam"]);
+/**
+* Whether a key from `override.query.options` reaches the emitted options
+* literal for this query type. Page-param callbacks are meaningless on a plain
+* query, so they are dropped there.
+*/
+const isConfiguredOptionEmitted = (key, type) => isInfiniteQuery(type) || !INFINITE_QUERY_PROPERTIES.has(key);
 const generateQueryOptions = ({ params, options, type, adapter }) => {
 	if (options === false) return "";
-	const queryConfig = isObject(options) ? ` ${stringify(omitBy(options, (_, key) => type !== QueryType.INFINITE && type !== QueryType.SUSPENSE_INFINITE && INFINITE_QUERY_PROPERTIES.has(key)))?.slice(1, -1)}` : "";
+	const queryConfig = isObject(options) ? ` ${stringify(omitBy(options, (_, key) => !isConfiguredOptionEmitted(key, type)))?.slice(1, -1)}` : "";
 	if (params.length === 0 || isSuspenseQuery(type)) {
 		if (options) return `${queryConfig} ...queryOptions`;
 		return "...queryOptions";
@@ -919,20 +938,66 @@ const generateQueryOptions = ({ params, options, type, adapter }) => {
 const isSuspenseQuery = (type) => {
 	return [QueryType.SUSPENSE_INFINITE, QueryType.SUSPENSE_QUERY].includes(type);
 };
-const getQueryOptionsDefinition = ({ operationName, mutator, definitions, type, prefix, hasQueryV5, hasQueryV5WithInfiniteQueryOptionsError, queryParams, queryParam, isReturnType, initialData, adapter }) => {
+const isInfiniteQuery = (type) => {
+	return [QueryType.INFINITE, QueryType.SUSPENSE_INFINITE].includes(type);
+};
+const getOptionsKind = (type) => isInfiniteQuery(type) ? "infiniteQuery" : "query";
+/**
+* Resolves the adapter's constraint together with the plain options type it has
+* to be rendered against. Both are optional on `FrameworkAdapter` and neither is
+* useful alone: without a type name there is nothing to `Pick` from, and without
+* required keys the caller has nothing to supply. Returning them as one value is
+* what stops the signature and the type disagreeing about whether `options` is
+* mandatory.
+*/
+const resolveUserQueryOptionsConstraint = (adapter, type, options) => {
+	const constraint = adapter?.getUserQueryOptionsConstraint?.(type);
+	if (!constraint) return;
+	const optionsTypeName = adapter?.getOptionsReturnTypeName?.(getOptionsKind(type));
+	if (!optionsTypeName) return;
+	const require = isObject(options) ? constraint.require?.filter((key) => !(isConfiguredOptionEmitted(key, type) && Object.hasOwn(options, key))) : constraint.require;
+	return {
+		...constraint,
+		require,
+		optionsTypeName
+	};
+};
+/**
+* Whether the caller must supply options the generator cannot infer, which is
+* what makes the whole `options` parameter mandatory. An `exclude`-only
+* constraint reshapes the type without requiring anything, so it does not count.
+*/
+const requiresUserSuppliedQueryOptions = (adapter, type, options) => !!type && !!resolveUserQueryOptionsConstraint(adapter, type, options)?.require?.length;
+const getQueryOptionsDefinition = ({ operationName, mutator, definitions, type, prefix, hasQueryV5, hasQueryV5WithInfiniteQueryOptionsError, queryParams, queryParam, isReturnType, initialData, adapter, options }) => {
 	const isMutatorHook = mutator?.isHook;
 	const partialOptions = !isReturnType && hasQueryV5;
 	if (type) {
 		const funcReturnType = `Awaited<ReturnType<${isMutatorHook ? `ReturnType<typeof use${pascal(operationName)}Hook>` : `typeof ${operationName}`}>>`;
-		const optionTypeInitialDataPostfix = initialData && !isSuspenseQuery(type) ? ` & Pick<
-        ${pascal(initialData)}InitialDataOptions<
+		const isInfiniteType = isInfiniteQuery(type);
+		const infiniteTypeArgs = hasQueryV5 && isInfiniteType && queryParam && queryParams ? `, QueryKey, ${queryParams.schema.name}['${queryParam}']` : "";
+		const initialDataOptionsType = initialData && adapter?.getInitialDataOptionsType ? adapter.getInitialDataOptionsType({
+			initialData,
+			isInfinite: isInfiniteType,
+			funcReturnType,
+			infiniteTypeArgs
+		}) : `${pascal(initialData ?? "")}InitialDataOptions<
           ${funcReturnType},
           TError,
-          ${funcReturnType}${hasQueryV5 && (type === QueryType.INFINITE || type === QueryType.SUSPENSE_INFINITE) && queryParam && queryParams ? `, QueryKey` : ""}
-        > , 'initialData'
+          ${funcReturnType}${hasQueryV5 && isInfiniteType && queryParam && queryParams ? `, QueryKey` : ""}
+        >`;
+		const optionTypeInitialDataPostfix = initialData && !isSuspenseQuery(type) ? ` & Pick<
+        ${initialDataOptionsType} , 'initialData'
       >` : "";
-		const optionsTypeName = isReturnType && adapter?.getOptionsReturnTypeName ? adapter.getOptionsReturnTypeName(type === QueryType.INFINITE || type === QueryType.SUSPENSE_INFINITE ? "infiniteQuery" : "query") : void 0;
-		const optionType = optionsTypeName ? `${optionsTypeName}<${funcReturnType}, TError, TData${hasQueryV5 && (type === QueryType.INFINITE || type === QueryType.SUSPENSE_INFINITE) && queryParam && queryParams ? `, QueryKey, ${queryParams.schema.name}['${queryParam}']` : ""}>` : `${prefix}${pascal(type)}Options<${funcReturnType}, TError, TData${hasQueryV5 && (type === QueryType.INFINITE || type === QueryType.SUSPENSE_INFINITE) && queryParam && queryParams ? hasQueryV5WithInfiniteQueryOptionsError ? `, QueryKey, ${queryParams.schema.name}['${queryParam}']` : `, ${funcReturnType}, QueryKey, ${queryParams.schema.name}['${queryParam}']` : ""}>`;
+		const userOptionsConstraint = isReturnType ? void 0 : resolveUserQueryOptionsConstraint(adapter, type, options);
+		if (userOptionsConstraint) {
+			const { optionsTypeName, require = [], exclude = [] } = userOptionsConstraint;
+			const plainOptionsType = `${optionsTypeName}<${funcReturnType}, TError, TData${infiniteTypeArgs}>`;
+			const quoteKeys = (keys) => keys.map((key) => `'${key}'`).join(" | ");
+			const omitted = [...require, ...exclude];
+			return `${omitted.length ? `Omit<Partial<${plainOptionsType}>, ${quoteKeys(omitted)}>` : `Partial<${plainOptionsType}>`}${require.length ? ` & Pick<${plainOptionsType}, ${quoteKeys(require)}>` : ""}${optionTypeInitialDataPostfix}`;
+		}
+		const optionsTypeName = isReturnType ? adapter?.getOptionsReturnTypeName?.(getOptionsKind(type)) : void 0;
+		const optionType = optionsTypeName ? `${optionsTypeName}<${funcReturnType}, TError, TData${infiniteTypeArgs}>` : `${prefix}${pascal(type)}Options<${funcReturnType}, TError, TData${hasQueryV5 && isInfiniteType && queryParam && queryParams ? hasQueryV5WithInfiniteQueryOptionsError ? `, QueryKey, ${queryParams.schema.name}['${queryParam}']` : `, ${funcReturnType}, QueryKey, ${queryParams.schema.name}['${queryParam}']` : ""}>`;
 		return `${partialOptions ? "Partial<" : ""}${optionType}${partialOptions ? ">" : ""}${optionTypeInitialDataPostfix}`;
 	}
 	const mutationOptionsTypeName = adapter?.getOptionsReturnTypeName ? adapter.getOptionsReturnTypeName("mutation") : void 0;
@@ -1117,6 +1182,11 @@ const createReactAdapter = ({ hasQueryV5, hasQueryV5WithDataTagError, hasQueryV5
 });
 //#endregion
 //#region src/frameworks/solid.ts
+const QUERY_OPTIONS_CONSTRAINT = { exclude: ["initialData"] };
+const INFINITE_QUERY_OPTIONS_CONSTRAINT = {
+	require: ["initialPageParam", "getNextPageParam"],
+	exclude: ["initialData"]
+};
 const createSolidAdapter = ({ hasQueryV5, hasQueryV5WithDataTagError, hasQueryV5WithInfiniteQueryOptionsError, hasQueryV5WithMutationContextOnSuccess, hasQueryV5WithRequiredContextOnSuccess, hasSolidQueryUsePrefix, hasSolidQueryRenamedOptionsTypes }) => ({
 	outputClient: OutputClient.SOLID_QUERY,
 	hookPrefix: hasSolidQueryUsePrefix ? "use" : "create",
@@ -1145,11 +1215,25 @@ const createSolidAdapter = ({ hasQueryV5, hasQueryV5WithDataTagError, hasQueryV5
 	shouldCastQueryOptions() {
 		return false;
 	},
-	getQueryReturnType({ type }) {
+	getUserQueryOptionsConstraint(type) {
+		if (!hasQueryV5) return;
+		if (isInfiniteQuery(type)) return INFINITE_QUERY_OPTIONS_CONSTRAINT;
+		return hasSolidQueryUsePrefix ? QUERY_OPTIONS_CONSTRAINT : void 0;
+	},
+	getQueryType(type) {
+		return getQueryTypeForFramework(type);
+	},
+	shouldGenerateOverrideTypes() {
+		return hasQueryV5 && hasSolidQueryUsePrefix;
+	},
+	getInitialDataOptionsType({ initialData, isInfinite, funcReturnType, infiniteTypeArgs }) {
+		return `ReturnType<${`${pascal(initialData)}InitialData${isInfinite ? "Infinite" : ""}Options`}<${funcReturnType}, TError, TData${infiniteTypeArgs}>>`;
+	},
+	getQueryReturnType({ type, isInitialDataDefined }) {
 		const prefix = hasSolidQueryUsePrefix ? "Use" : "Create";
 		const queryKeyType = hasQueryV5 ? `DataTag<QueryKey, TData${hasQueryV5WithDataTagError ? ", TError" : ""}>` : "QueryKey";
-		if (type !== QueryType.INFINITE && type !== QueryType.SUSPENSE_INFINITE) return `${prefix}QueryResult<TData, TError> & { queryKey: ${queryKeyType} }`;
-		return `${prefix}InfiniteQueryResult<TData, TError> & { queryKey: ${queryKeyType} }`;
+		const resultName = isInfiniteQuery(type) ? "InfiniteQueryResult" : "QueryResult";
+		return `${isInitialDataDefined ? "Defined" : ""}${prefix}${resultName}<TData, TError> & { queryKey: ${queryKeyType} }`;
 	},
 	getMutationReturnType({ dataType, variableType }) {
 		return `: ${hasSolidQueryUsePrefix ? "Use" : "Create"}MutationResult<
@@ -1472,24 +1556,27 @@ const withDefaults = (adapter) => {
 		getOptionalQueryClientArgument() {
 			return composed.hasQueryV5 ? ", queryClient?: QueryClient" : "";
 		},
-		generateQueryArguments({ operationName, definitions, mutator, isRequestOptions, type, queryParams, queryParam, initialData, httpClient, hasInvalidation, useRuntimeFetcher }) {
+		generateQueryArguments({ operationName, definitions, mutator, isRequestOptions, type, queryParams, queryParam, initialData, httpClient, hasInvalidation, useRuntimeFetcher, options }) {
+			const prefix = composed.getQueryOptionsDefinitionPrefix();
 			const definition = getQueryOptionsDefinition({
 				operationName,
 				mutator,
 				definitions,
 				type,
-				prefix: composed.getQueryOptionsDefinitionPrefix(),
+				prefix,
 				hasQueryV5: composed.hasQueryV5,
 				hasQueryV5WithInfiniteQueryOptionsError: composed.hasQueryV5WithInfiniteQueryOptionsError,
 				queryParams,
 				queryParam,
 				isReturnType: false,
 				initialData,
-				adapter: composed
+				adapter: composed,
+				options
 			});
-			if (!isRequestOptions) return `${type ? "queryOptions" : "mutationOptions"}${initialData === "defined" ? "" : "?"}: ${definition}`;
+			const requiresUserQueryOptions = requiresUserSuppliedQueryOptions(composed, type, options);
+			if (!isRequestOptions) return `${type ? "queryOptions" : "mutationOptions"}${initialData === "defined" || requiresUserQueryOptions ? "" : "?"}: ${definition}`;
 			const requestType = getQueryArgumentsRequestType(httpClient, mutator, useRuntimeFetcher);
-			const isQueryRequired = initialData === "defined";
+			const isQueryRequired = initialData === "defined" || requiresUserQueryOptions;
 			const optionsType = `{ ${type ? "query" : "mutation"}${isQueryRequired ? "" : "?"}:${definition}, ${!type && hasInvalidation ? "skipInvalidation?: boolean, " : ""}${requestType}}`;
 			return `options${isQueryRequired ? "" : "?"}: ${optionsType}\n`;
 		},
@@ -1535,23 +1622,30 @@ const createFrameworkAdapter = ({ outputClient, packageJson, queryVersion }) =>
 	const _hasQueryV5WithMutationContextOnSuccess = isQueryV5WithMutationContextOnSuccess(packageJson, clientType);
 	const _hasQueryV5WithRequiredContextOnSuccess = isQueryV5WithRequiredContextOnSuccess(packageJson, clientType);
 	switch (outputClient) {
-		case OutputClient.VUE_QUERY: return withDefaults(createVueAdapter({
-			hasVueQueryV4: !isVueQueryV3(packageJson) || queryVersion === 4,
-			hasQueryV5: _hasQueryV5,
-			hasQueryV5WithDataTagError: _hasQueryV5WithDataTagError,
-			hasQueryV5WithInfiniteQueryOptionsError: _hasQueryV5WithInfiniteQueryOptionsError,
-			hasQueryV5WithMutationContextOnSuccess: _hasQueryV5WithMutationContextOnSuccess,
-			hasQueryV5WithRequiredContextOnSuccess: _hasQueryV5WithRequiredContextOnSuccess
-		}));
-		case OutputClient.SVELTE_QUERY: return withDefaults(createSvelteAdapter({
-			hasSvelteQueryV4: !isSvelteQueryV3(packageJson) || queryVersion === 4,
-			hasSvelteQueryV6: isSvelteQueryV6(packageJson),
-			hasQueryV5: _hasQueryV5,
-			hasQueryV5WithDataTagError: _hasQueryV5WithDataTagError,
-			hasQueryV5WithInfiniteQueryOptionsError: _hasQueryV5WithInfiniteQueryOptionsError,
-			hasQueryV5WithMutationContextOnSuccess: _hasQueryV5WithMutationContextOnSuccess,
-			hasQueryV5WithRequiredContextOnSuccess: _hasQueryV5WithRequiredContextOnSuccess
-		}));
+		case OutputClient.VUE_QUERY: {
+			const hasVueQueryV4 = !isVueQueryV3(packageJson) || queryVersion === 4;
+			return withDefaults(createVueAdapter({
+				hasVueQueryV4,
+				hasQueryV5: _hasQueryV5,
+				hasQueryV5WithDataTagError: _hasQueryV5WithDataTagError,
+				hasQueryV5WithInfiniteQueryOptionsError: _hasQueryV5WithInfiniteQueryOptionsError,
+				hasQueryV5WithMutationContextOnSuccess: _hasQueryV5WithMutationContextOnSuccess,
+				hasQueryV5WithRequiredContextOnSuccess: _hasQueryV5WithRequiredContextOnSuccess
+			}));
+		}
+		case OutputClient.SVELTE_QUERY: {
+			const hasSvelteQueryV4 = !isSvelteQueryV3(packageJson) || queryVersion === 4;
+			const _hasSvelteQueryV6 = isSvelteQueryV6(packageJson);
+			return withDefaults(createSvelteAdapter({
+				hasSvelteQueryV4,
+				hasSvelteQueryV6: _hasSvelteQueryV6,
+				hasQueryV5: _hasQueryV5,
+				hasQueryV5WithDataTagError: _hasQueryV5WithDataTagError,
+				hasQueryV5WithInfiniteQueryOptionsError: _hasQueryV5WithInfiniteQueryOptionsError,
+				hasQueryV5WithMutationContextOnSuccess: _hasQueryV5WithMutationContextOnSuccess,
+				hasQueryV5WithRequiredContextOnSuccess: _hasQueryV5WithRequiredContextOnSuccess
+			}));
+		}
 		case OutputClient.ANGULAR_QUERY: return withDefaults(createAngularAdapter({
 			hasQueryV5: _hasQueryV5,
 			hasQueryV5WithDataTagError: _hasQueryV5WithDataTagError,
@@ -1559,15 +1653,19 @@ const createFrameworkAdapter = ({ outputClient, packageJson, queryVersion }) =>
 			hasQueryV5WithMutationContextOnSuccess: _hasQueryV5WithMutationContextOnSuccess,
 			hasQueryV5WithRequiredContextOnSuccess: _hasQueryV5WithRequiredContextOnSuccess
 		}));
-		case OutputClient.SOLID_QUERY: return withDefaults(createSolidAdapter({
-			hasQueryV5: _hasQueryV5,
-			hasQueryV5WithDataTagError: _hasQueryV5WithDataTagError,
-			hasQueryV5WithInfiniteQueryOptionsError: _hasQueryV5WithInfiniteQueryOptionsError,
-			hasQueryV5WithMutationContextOnSuccess: _hasQueryV5WithMutationContextOnSuccess,
-			hasQueryV5WithRequiredContextOnSuccess: _hasQueryV5WithRequiredContextOnSuccess,
-			hasSolidQueryUsePrefix: isSolidQueryWithUsePrefix(packageJson),
-			hasSolidQueryRenamedOptionsTypes: isSolidQueryWithRenamedOptionsTypes(packageJson)
-		}));
+		case OutputClient.SOLID_QUERY: {
+			const hasSolidQueryWithUsePrefix = isSolidQueryWithUsePrefix(packageJson);
+			const hasSolidQueryWithRenamedOptionsTypes = isSolidQueryWithRenamedOptionsTypes(packageJson);
+			return withDefaults(createSolidAdapter({
+				hasQueryV5: _hasQueryV5,
+				hasQueryV5WithDataTagError: _hasQueryV5WithDataTagError,
+				hasQueryV5WithInfiniteQueryOptionsError: _hasQueryV5WithInfiniteQueryOptionsError,
+				hasQueryV5WithMutationContextOnSuccess: _hasQueryV5WithMutationContextOnSuccess,
+				hasQueryV5WithRequiredContextOnSuccess: _hasQueryV5WithRequiredContextOnSuccess,
+				hasSolidQueryUsePrefix: hasSolidQueryWithUsePrefix,
+				hasSolidQueryRenamedOptionsTypes: hasSolidQueryWithRenamedOptionsTypes
+			}));
+		}
 		default: return withDefaults(createReactAdapter({
 			hasQueryV5: _hasQueryV5,
 			hasQueryV5WithDataTagError: _hasQueryV5WithDataTagError,
@@ -1603,7 +1701,7 @@ const HTTP_METHODS = [
 	"head",
 	"trace"
 ];
-const MUTATION_OPERATION_LOCAL_NAMES = new Set([
+const MUTATION_OPERATION_LOCAL_NAMES = /* @__PURE__ */ new Set([
 	"backupQueryClient",
 	"context",
 	"customOptions",
@@ -1914,6 +2012,24 @@ const hasQueryParam = (queryParams, queryParam) => {
 	if (!queryParam || !queryParams) return false;
 	return queryParams.paramNames?.includes(queryParam) ?? true;
 };
+/**
+* When nothing is configured, infinite hooks stay allowed, just without a
+* page param. When candidates are configured but the operation declares none
+* of them, the infinite hook is suppressed so orval does not emit a useless
+* one for a non-paginated `GET`.
+*/
+const resolveInfiniteQueryParam = (queryParams, useInfiniteQueryParam) => {
+	const candidates = (Array.isArray(useInfiniteQueryParam) ? useInfiniteQueryParam : [useInfiniteQueryParam]).filter((name) => !!name);
+	if (candidates.length === 0) return {
+		queryParam: void 0,
+		infiniteHookAllowed: true
+	};
+	const queryParam = candidates.find((name) => hasQueryParam(queryParams, name));
+	return {
+		queryParam,
+		infiniteHookAllowed: queryParam !== void 0
+	};
+};
 const escapeRegExpMetaChars = (value) => value.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
 /**
 * Wraps the body parameter's type in a property string with the mutator's
@@ -1982,8 +2098,29 @@ const renderSetQueryDataHelper = ({ doc, isReactQuery, fnName, propsSig, body })
 }\n`;
 };
 /**
+* Rewrites `name?: T` to `name: undefined | T` so a required parameter can follow
+* it (TS1016).
+*
+* Keep `undefined` first. `wrapPropsBodyWithMutatorBodyType` matches an optional
+* `undefined\s*\|\s*` prefix when it swaps in a mutator body type, and misses the
+* `T | undefined` form that `allowUndefinedParam` emits.
+*/
+const widenOptionalPropsToUndefined = (props, field) => props.map((prop) => {
+	const regex = new RegExp(String.raw`^${escapeRegExpMetaChars(prop.name)}\s*\?:`);
+	if (!regex.test(prop[field])) return prop;
+	const widened = prop[field].replace(regex, `${prop.name}: undefined | `);
+	return field === "definition" ? {
+		...prop,
+		definition: widened
+	} : {
+		...prop,
+		implementation: widened
+	};
+});
+/**
 * Renders the prop list shared by `getXxxQueryKey`, `setXxxQueryData` and
-* `getXxxQueryData` helpers: headers are dropped, path params stay required,
+* `getXxxQueryData` helpers: headers are dropped (unless `includeHeaders`
+* is set — key-mutator factories need them), path params stay required,
 * non-path params (query params, body) are passed through `widenNonPath`
 * (defaults to identity — pass `makeOptionalParam` or `allowUndefinedParam`
 * to relax the signature).
@@ -1991,8 +2128,8 @@ const renderSetQueryDataHelper = ({ doc, isReactQuery, fnName, propsSig, body })
 * Centralising this prevents the three call sites from drifting apart on
 * how they treat the same props.
 */
-const buildKeyShapedProps = ({ props, body, mutator, widenNonPath = (impl) => impl }) => wrapPropsBodyWithMutatorBodyType({
-	propsString: toObjectString(props.filter((prop) => prop.type !== GetterPropType.HEADER).map((prop) => ({
+const buildKeyShapedProps = ({ props, body, mutator, widenNonPath = (impl) => impl, includeHeaders = false }) => wrapPropsBodyWithMutatorBodyType({
+	propsString: toObjectString(props.filter((prop) => includeHeaders || prop.type !== GetterPropType.HEADER).map((prop) => ({
 		...prop,
 		implementation: prop.type === GetterPropType.PARAM || prop.type === GetterPropType.NAMED_PATH_PARAMS ? prop.implementation : widenNonPath(prop.implementation)
 	})), "implementation"),
@@ -2051,21 +2188,15 @@ const generatePrefetch = ({ usePrefetch, type, useQuery, useInfinite, operationN
 const generateQueryImplementation = ({ queryOption: { name, typeName: optionTypeName, queryParam, options, type, queryKeyFnName }, operationId, operationName, typeName, queryProperties, queryKeyProperties, queryParams, params, props, body, mutator, queryOptionsMutator, queryKeyMutator, isRequestOptions, response, httpClient, isExactOptionalPropertyTypes, hasSignal, useRuntimeFetcher, forceSuccessResponse, route, doc, usePrefetch, useQuery, useInfinite, useInvalidate, useSetQueryData, useGetQueryData, adapter }) => {
 	const { hasQueryV5, hasQueryV5WithDataTagError, hasQueryV5WithInfiniteQueryOptionsError } = adapter;
 	const hasSignalParam = props.some((prop) => prop.name === "signal");
+	const requiresUserQueryOptions = requiresUserSuppliedQueryOptions(adapter, type, options);
+	const signatureProps = requiresUserQueryOptions ? widenOptionalPropsToUndefined(props, "implementation") : props;
 	const queryPropDefinitions = wrapPropsBodyWithMutatorBodyType({
-		propsString: toObjectString(props, "definition"),
+		propsString: toObjectString(requiresUserQueryOptions ? widenOptionalPropsToUndefined(props, "definition") : 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"),
+		propsString: toObjectString(widenOptionalPropsToUndefined(props, "definition"), "definition"),
 		body,
 		mutator
 	});
@@ -2074,6 +2205,11 @@ const generateQueryImplementation = ({ queryOption: { name, typeName: optionType
 		body,
 		mutator
 	});
+	const queryPropsBeforeRequiredOptions = requiresUserQueryOptions ? wrapPropsBodyWithMutatorBodyType({
+		propsString: toObjectString(signatureProps, "implementation"),
+		body,
+		mutator
+	}) : queryProps;
 	const infiniteQueryParamType = hasQueryParam(queryParams, queryParam) && queryParams && queryParam ? `${queryParams.schema.name}['${queryParam}']` : "";
 	const hasInfiniteQueryParam = !!infiniteQueryParamType;
 	const httpFunctionProps = queryParam ? adapter.getInfiniteQueryHttpProps(props, queryParam, httpClient, !!mutator) : adapter.getHttpFunctionQueryProps(queryProperties, httpClient, !!mutator);
@@ -2104,7 +2240,8 @@ const generateQueryImplementation = ({ queryOption: { name, typeName: optionType
 		queryParam,
 		initialData: "defined",
 		httpClient,
-		useRuntimeFetcher
+		useRuntimeFetcher,
+		options
 	});
 	const undefinedInitialDataQueryArguments = adapter.generateQueryArguments({
 		operationName,
@@ -2116,7 +2253,8 @@ const generateQueryImplementation = ({ queryOption: { name, typeName: optionType
 		queryParam,
 		initialData: "undefined",
 		httpClient,
-		useRuntimeFetcher
+		useRuntimeFetcher,
+		options
 	});
 	const queryArguments = adapter.generateQueryArguments({
 		operationName,
@@ -2127,7 +2265,8 @@ const generateQueryImplementation = ({ queryOption: { name, typeName: optionType
 		queryParams,
 		queryParam,
 		httpClient,
-		useRuntimeFetcher
+		useRuntimeFetcher,
+		options
 	});
 	const queryArgumentsForOptions = adapter.generateQueryArguments({
 		operationName,
@@ -2139,7 +2278,8 @@ const generateQueryImplementation = ({ queryOption: { name, typeName: optionType
 		queryParam,
 		httpClient,
 		forQueryOptions: true,
-		useRuntimeFetcher
+		useRuntimeFetcher,
+		options
 	});
 	const queryOptions = getQueryOptions({
 		isRequestOptions,
@@ -2185,7 +2325,7 @@ const generateQueryImplementation = ({ queryOption: { name, typeName: optionType
 	const queryResultVarName = props.some((prop) => prop.name === "query") ? "_query" : "query";
 	const infiniteParam = infiniteQueryParamType ? `, ${infiniteQueryParamType}` : "";
 	const TData = hasQueryV5 && (type === QueryType.INFINITE || type === QueryType.SUSPENSE_INFINITE) ? `InfiniteData<Awaited<ReturnType<${dataType}>>${infiniteParam}>` : `Awaited<ReturnType<${dataType}>>`;
-	const queryOptionsFn = `export const ${queryOptionsFnName} = <TData = ${TData}, TError = ${errorType}>(${adapter.getHttpFirstParam(mutator)}${queryProps} ${queryArgumentsForOptions}) => {
+	const queryOptionsFn = `export const ${queryOptionsFnName} = <TData = ${TData}, TError = ${errorType}>(${adapter.getHttpFirstParam(mutator)}${queryPropsBeforeRequiredOptions} ${queryArgumentsForOptions}) => {
 
 ${hookOptions}
 
@@ -2193,7 +2333,7 @@ ${hookOptions}
 
   ${mutator?.isHook ? `const ${operationName} =  use${pascal(operationName)}Hook();` : ""}
 
-    const queryFn: QueryFunction<Awaited<ReturnType<${mutator?.isHook ? `ReturnType<typeof use${pascal(operationName)}Hook>` : `typeof ${operationName}`}>>${hasQueryV5 && hasInfiniteQueryParam ? `, QueryKey, ${infiniteQueryParamType}` : ""}> = (${queryFnArguments}) => ${operationName}(${httpFunctionProps}${httpFunctionProps ? ", " : ""}${queryOptions});
+    const queryFn: QueryFunction<Awaited<ReturnType<${mutator?.isHook ? `ReturnType<typeof use${pascal(operationName)}Hook>` : `typeof ${operationName}`}>>${hasQueryV5 && hasInfiniteQueryParam ? `, QueryKey, ${infiniteQueryParamType}` : hasQueryV5 && isInfiniteQuery(type) && adapter.shouldCastQueryOptions?.() === false ? `, QueryKey, unknown` : ""}> = (${queryFnArguments}) => ${operationName}(${httpFunctionProps}${httpFunctionProps ? ", " : ""}${queryOptions});
 
       ${adapter.getQueryOptionsUnrefStatements(props)}
 
@@ -2215,7 +2355,7 @@ export function ${queryHookName}<TData = ${TData}, TError = ${errorType}>(\n ${q
 		useInfinite,
 		operationName,
 		mutator,
-		queryProps,
+		queryProps: queryPropsBeforeRequiredOptions,
 		dataType,
 		errorType,
 		queryArguments: queryArgumentsForOptions,
@@ -2278,7 +2418,7 @@ export type ${pascal(optionTypeName)}QueryError = ${errorType}
 ${adapter.shouldGenerateOverrideTypes() ? overrideTypes : ""}
 ${doc}
 export function ${queryHookName}<TData = ${TData}, TError = ${errorType}>(\n ${wrapPropsBodyWithMutatorBodyType({
-		propsString: adapter.getHookPropsDefinitions(props),
+		propsString: adapter.getHookPropsDefinitions(signatureProps),
 		body,
 		mutator
 	})} ${queryArguments} ${optionalQueryClientArgument} \n ): ${returnType} {
@@ -2336,9 +2476,10 @@ const generateQueryHook = async (verbOptions, options, outputClient, adapter) =>
 	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 hasConfiguredInfiniteQueryParam = !query.useInfiniteQueryParam || hasQueryParam(queryParams, query.useInfiniteQueryParam);
-	const effectiveUseInfinite = (operationQueryOptions?.useInfinite ?? globalSuspenseOrInfiniteOnlyForGet(override.query.useInfinite)) && hasConfiguredInfiniteQueryParam;
-	const effectiveUseSuspenseInfiniteQuery = (operationQueryOptions?.useSuspenseInfiniteQuery ?? globalSuspenseOrInfiniteOnlyForGet(override.query.useSuspenseInfiniteQuery)) && hasConfiguredInfiniteQueryParam;
+	const configuredInfiniteQueryParam = operationQueryOptions?.useInfiniteQueryParam ?? query.useInfiniteQueryParam;
+	const { queryParam: infiniteQueryParam, infiniteHookAllowed } = resolveInfiniteQueryParam(queryParams, configuredInfiniteQueryParam);
+	const effectiveUseInfinite = (operationQueryOptions?.useInfinite ?? globalSuspenseOrInfiniteOnlyForGet(override.query.useInfinite)) && infiniteHookAllowed;
+	const effectiveUseSuspenseInfiniteQuery = (operationQueryOptions?.useSuspenseInfiniteQuery ?? globalSuspenseOrInfiniteOnlyForGet(override.query.useSuspenseInfiniteQuery)) && infiniteHookAllowed;
 	let isQuery = effectiveUseQuery || effectiveUseSuspenseQuery || effectiveUseInfinite || effectiveUseSuspenseInfiniteQuery;
 	let isMutation = effectiveUseMutation;
 	if (verb !== Verbs.GET && isQuery) isMutation = false;
@@ -2377,7 +2518,7 @@ const generateQueryHook = async (verbOptions, options, outputClient, adapter) =>
 				typeName: camel(`${typeName}-infinite`),
 				options: query.options,
 				type: QueryType.INFINITE,
-				queryParam: query.useInfiniteQueryParam,
+				queryParam: infiniteQueryParam,
 				queryKeyFnName: camel(`get-${operationName}-infinite-query-key`)
 			}] : [],
 			...effectiveUseQuery ? [{
@@ -2399,7 +2540,7 @@ const generateQueryHook = async (verbOptions, options, outputClient, adapter) =>
 				typeName: camel(`${typeName}-suspense-infinite`),
 				options: query.options,
 				type: QueryType.SUSPENSE_INFINITE,
-				queryParam: query.useInfiniteQueryParam,
+				queryParam: infiniteQueryParam,
 				queryKeyFnName: camel(`get-${operationName}-infinite-query-key`)
 			}] : []
 		];
@@ -2431,6 +2572,19 @@ ${override.query.shouldExportQueryKey ? "export " : ""}const ${queryOption.query
 			].filter((x) => !!x).join(", ")}
     ]${override.query.shouldFilterQueryKey ? `.filter(${override.query.queryKeyFilter ?? "q => q !== undefined"})` : " as const"};
     }
+`;
+		}
+		else if (override.query.shouldExportQueryKey) for (const queryOption of uniqueQueryOptionsByKeys) {
+			const queryKeyProps = buildKeyShapedProps({
+				props,
+				body,
+				mutator,
+				widenNonPath: makeOptionalParam,
+				includeHeaders: true
+			});
+			queryKeyFns += `
+export const ${queryOption.queryKeyFnName} = (${queryKeyProps}) =>
+    ${queryKeyMutator.name}({ ${queryProperties} }${queryKeyMutator.hasSecondArg ? `, { url: \`${route}\` }` : ""});
 `;
 		}
 		implementation += `