@orval/query 8.0.0-rc.5 → 8.0.0-rc.6

package/dist/index.mjs

@@ -1,7 +1,7 @@
-import { GetterPropType, OutputClient, OutputHttpClient, TEMPLATE_TAG_REGEX, Verbs, camel, compareVersions, generateFormDataAndUrlEncodedFunction, generateMutator, generateMutatorConfig, generateMutatorRequestOptions, generateOptions, generateVerbImports, getIsBodyVerb, getRouteAsArray, isObject, isString, isSyntheticDefaultImportsAllow, jsDoc, mergeDeep, pascal, stringify, toObjectString, upath } from "@orval/core";
-import { omitBy } from "remeda";
+import { GetterPropType, OutputClient, OutputHttpClient, TEMPLATE_TAG_REGEX, Verbs, camel, compareVersions, generateFormDataAndUrlEncodedFunction, generateMutator, generateMutatorConfig, generateMutatorRequestOptions, generateOptions, generateVerbImports, getRouteAsArray, isObject, isString, isSyntheticDefaultImportsAllow, jsDoc, mergeDeep, pascal, stringify, toObjectString, upath } from "@orval/core";
 import { generateFetchHeader, generateRequestFunction } from "@orval/fetch";
 import chalk from "chalk";
+import { omitBy } from "remeda";
 
 //#region src/utils.ts
 const normalizeQueryOptions = (queryOptions = {}, outputWorkspace) => {
@@ -12,9 +12,9 @@ const normalizeQueryOptions = (queryOptions = {}, outputWorkspace) => {
 		...queryOptions.useInfinite ? { useInfinite: true } : {},
 		...queryOptions.useInfiniteQueryParam ? { useInfiniteQueryParam: queryOptions.useInfiniteQueryParam } : {},
 		...queryOptions.options ? { options: queryOptions.options } : {},
-		...queryOptions?.queryKey ? { queryKey: normalizeMutator(outputWorkspace, queryOptions?.queryKey) } : {},
-		...queryOptions?.queryOptions ? { queryOptions: normalizeMutator(outputWorkspace, queryOptions?.queryOptions) } : {},
-		...queryOptions?.mutationOptions ? { mutationOptions: normalizeMutator(outputWorkspace, queryOptions?.mutationOptions) } : {},
+		...queryOptions.queryKey ? { queryKey: normalizeMutator(outputWorkspace, queryOptions.queryKey) } : {},
+		...queryOptions.queryOptions ? { queryOptions: normalizeMutator(outputWorkspace, queryOptions.queryOptions) } : {},
+		...queryOptions.mutationOptions ? { mutationOptions: normalizeMutator(outputWorkspace, queryOptions.mutationOptions) } : {},
 		...queryOptions.signal ? { signal: true } : {},
 		...queryOptions.shouldExportMutatorHooks ? { shouldExportMutatorHooks: true } : {},
 		...queryOptions.shouldExportQueryKey ? { shouldExportQueryKey: true } : {},
@@ -29,7 +29,7 @@ const normalizeMutator = (workspace, mutator) => {
 		return {
 			...mutator,
 			path: upath.resolve(workspace, mutator.path),
-			default: (mutator.default || !mutator.name) ?? false
+			default: mutator.default ?? !mutator.name
 		};
 	}
 	if (isString(mutator)) return {
@@ -59,6 +59,7 @@ const vueUnRefParams = (props) => {
 const wrapRouteParameters = (route, prepend, append) => route.replaceAll(TEMPLATE_TAG_REGEX, `\${${prepend}$1${append}}`);
 const makeRouteSafe = (route) => wrapRouteParameters(route, "encodeURIComponent(String(", "))");
 const isVue = (client) => OutputClient.VUE_QUERY === client;
+const isSolid = (client) => OutputClient.SOLID_QUERY === client;
 const isAngular = (client) => OutputClient.ANGULAR_QUERY === client;
 const getQueryTypeForFramework = (type) => {
 	switch (type) {
@@ -67,7 +68,7 @@ const getQueryTypeForFramework = (type) => {
 		default: return type;
 	}
 };
-const getHasSignal = ({ overrideQuerySignal = false, verb }) => overrideQuerySignal && (!getIsBodyVerb(verb) || verb === Verbs.POST);
+const getHasSignal = ({ overrideQuerySignal = false }) => overrideQuerySignal;
 
 //#endregion
 //#region src/client.ts
@@ -130,10 +131,7 @@ const generateAngularHttpRequestFunction = ({ headers, queryParams, operationNam
 	const isRequestOptions = override.requestOptions !== false;
 	const isFormData = !override.formData.disabled;
 	const isFormUrlEncoded = override.formUrlEncoded !== false;
-	const hasSignal = getHasSignal({
-		overrideQuerySignal: override.query.signal,
-		verb
-	});
+	const hasSignal = getHasSignal({ overrideQuerySignal: override.query.signal });
 	const bodyForm = generateFormDataAndUrlEncodedFunction({
 		formData,
 		formUrlEncoded,
@@ -157,7 +155,7 @@ const generateAngularHttpRequestFunction = ({ headers, queryParams, operationNam
 		});
 		const requestOptions = isRequestOptions ? generateMutatorRequestOptions(override.requestOptions, mutator.hasSecondArg) : "";
 		const propsImplementation = toObjectString(props, "implementation");
-		return `${override.query.shouldExportHttpClient ? "export " : ""}const ${operationName} = (\\n    ${propsImplementation}\\n ${isRequestOptions && mutator.hasSecondArg ? `options${context.output.optionsParamRequired ? "" : "?"}: SecondParameter<typeof ${mutator.name}>,` : ""}${hasSignal ? String.raw`signal?: AbortSignal\n` : ""}) => {
+		return String.raw`${override.query.shouldExportHttpClient ? "export " : ""}const ${operationName} = (\n    ${propsImplementation}\n ${isRequestOptions && mutator.hasSecondArg ? `options${context.output.optionsParamRequired ? "" : "?"}: SecondParameter<typeof ${mutator.name}>,` : ""}${hasSignal ? String.raw`signal?: AbortSignal\n` : ""}) => {
       ${bodyForm}
       return ${mutator.name}<${response.definition.success || "unknown"}>(
       ${mutatorConfig},
@@ -207,14 +205,11 @@ const generateAxiosRequestFunction = ({ headers, queryParams, operationName, res
 	let props = _props;
 	let route = _route;
 	if (isVue$1) props = vueWrapTypeWithMaybeRef(_props);
-	if (context.output?.urlEncodeParameters) route = makeRouteSafe(route);
+	if (context.output.urlEncodeParameters) route = makeRouteSafe(route);
 	const isRequestOptions = override.requestOptions !== false;
 	const isFormData = !override.formData.disabled;
 	const isFormUrlEncoded = override.formUrlEncoded !== false;
-	const hasSignal = getHasSignal({
-		overrideQuerySignal: override.query.signal,
-		verb
-	});
+	const hasSignal = getHasSignal({ overrideQuerySignal: override.query.signal });
 	const isExactOptionalPropertyTypes = !!context.output.tsconfig?.compilerOptions?.exactOptionalPropertyTypes;
 	const bodyForm = generateFormDataAndUrlEncodedFunction({
 		formData,
@@ -238,7 +233,7 @@ const generateAxiosRequestFunction = ({ headers, queryParams, operationName, res
 			isVue: isVue$1
 		});
 		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 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 = () => {
@@ -280,11 +275,11 @@ const generateAxiosRequestFunction = ({ headers, queryParams, operationName, res
 		queryParams,
 		response,
 		verb,
-		requestOptions: override?.requestOptions,
+		requestOptions: override.requestOptions,
 		isFormData,
 		isFormUrlEncoded,
 		paramsSerializer,
-		paramsSerializerOptions: override?.paramsSerializerOptions,
+		paramsSerializerOptions: override.paramsSerializerOptions,
 		isExactOptionalPropertyTypes,
 		hasSignal,
 		isVue: isVue$1
@@ -347,7 +342,7 @@ const getQueryErrorType = (operationName, response, httpClient, mutator) => {
 const getHooksOptionImplementation = (isRequestOptions, httpClient, operationName, mutator) => {
 	const options = httpClient === OutputHttpClient.AXIOS ? ", axios: axiosOptions" : ", fetch: fetchOptions";
 	return isRequestOptions ? `const mutationKey = ['${operationName}'];
-const {mutation: mutationOptions${mutator ? mutator?.hasSecondArg ? ", request: requestOptions" : "" : options}} = options ?
+const {mutation: mutationOptions${mutator ? mutator.hasSecondArg ? ", request: requestOptions" : "" : options}} = options ?
       options.mutation && 'mutationKey' in options.mutation && options.mutation.mutationKey ?
       options
       : {...options, mutation: {...options.mutation, mutationKey}}
@@ -355,11 +350,10 @@ const {mutation: mutationOptions${mutator ? mutator?.hasSecondArg ? ", request:
 };
 const getMutationRequestArgs = (isRequestOptions, httpClient, mutator) => {
 	const options = httpClient === OutputHttpClient.AXIOS ? "axiosOptions" : "fetchOptions";
-	return isRequestOptions ? mutator ? mutator?.hasSecondArg ? "requestOptions" : "" : options : "";
+	return isRequestOptions ? mutator ? mutator.hasSecondArg ? "requestOptions" : "" : options : "";
 };
 const getHttpFunctionQueryProps = (isVue$1, httpClient, queryProperties, isAngular$1 = false) => {
-	let result;
-	result = isVue$1 && httpClient === OutputHttpClient.FETCH && queryProperties ? queryProperties.split(",").map((prop) => `unref(${prop})`).join(",") : queryProperties;
+	const result = isVue$1 && httpClient === OutputHttpClient.FETCH && queryProperties ? queryProperties.split(",").map((prop) => `unref(${prop})`).join(",") : queryProperties;
 	if (isAngular$1 || httpClient === OutputHttpClient.ANGULAR) return result ? `http, ${result}` : "http";
 	return result;
 };
@@ -368,21 +362,7 @@ const getQueryHeader = (params) => {
 };
 
 //#endregion
-//#region src/index.ts
-/**
-* Get framework-aware prefix for hook names and type definitions
-* @param hasSvelteQueryV4 - Whether using Svelte Query v4
-* @param isAngularClient - Whether using Angular client
-* @param capitalize - Whether to capitalize the prefix (for type definitions)
-* @returns The appropriate prefix string
-*/
-const getFrameworkPrefix = (hasSvelteQueryV4, isAngularClient, capitalize = false) => {
-	let prefix;
-	if (hasSvelteQueryV4) prefix = "create";
-	else if (isAngularClient) prefix = "inject";
-	else prefix = "use";
-	return capitalize ? prefix.charAt(0).toUpperCase() + prefix.slice(1) : prefix;
-};
+//#region src/dependencies.ts
 const REACT_DEPENDENCIES = [{
 	exports: [{
 		name: "useCallback",
@@ -557,7 +537,7 @@ const REACT_QUERY_DEPENDENCIES = [{
 const getReactQueryDependencies = (hasGlobalMutator, hasParamsSerializerOptions, packageJson, httpClient, hasTagsMutator, override) => {
 	const hasReactQuery = packageJson?.dependencies?.["react-query"] ?? packageJson?.devDependencies?.["react-query"] ?? packageJson?.peerDependencies?.["react-query"];
 	const hasReactQueryV4 = packageJson?.dependencies?.["@tanstack/react-query"] ?? packageJson?.devDependencies?.["@tanstack/react-query"] ?? packageJson?.peerDependencies?.["@tanstack/react-query"];
-	const useReactQueryV3 = override?.query.version === void 0 ? hasReactQuery && !hasReactQueryV4 : override?.query.version <= 3;
+	const useReactQueryV3 = override.query.version === void 0 ? hasReactQuery && !hasReactQueryV4 : override.query.version <= 3;
 	return [
 		...hasGlobalMutator || hasTagsMutator ? REACT_DEPENDENCIES : [],
 		...!hasGlobalMutator && httpClient === OutputHttpClient.AXIOS ? AXIOS_DEPENDENCIES : [],
@@ -656,6 +636,36 @@ const VUE_QUERY_DEPENDENCIES = [{
 	],
 	dependency: "vue"
 }];
+const SOLID_QUERY_DEPENDENCIES = [{
+	exports: [
+		{
+			name: "createQuery",
+			values: true
+		},
+		{
+			name: "createInfiniteQuery",
+			values: true
+		},
+		{
+			name: "createMutation",
+			values: true
+		},
+		{ name: "CreateQueryOptions" },
+		{ name: "CreateInfiniteQueryOptions" },
+		{ name: "CreateMutationOptions" },
+		{ name: "QueryFunction" },
+		{ name: "MutationFunction" },
+		{ name: "CreateQueryResult" },
+		{ name: "CreateInfiniteQueryResult" },
+		{ name: "QueryKey" },
+		{ name: "InfiniteData" },
+		{ name: "CreateMutationResult" },
+		{ name: "DataTag" },
+		{ name: "QueryClient" },
+		{ name: "InvalidateOptions" }
+	],
+	dependency: "@tanstack/solid-query"
+}];
 const ANGULAR_QUERY_DEPENDENCIES = [{
 	exports: [
 		{
@@ -683,8 +693,12 @@ const ANGULAR_QUERY_DEPENDENCIES = [{
 		{ name: "InfiniteData" },
 		{ name: "CreateMutationResult" },
 		{ name: "DataTag" },
-		{ name: "QueryClient" },
-		{ name: "InvalidateOptions" }
+		{
+			name: "QueryClient",
+			values: true
+		},
+		{ name: "InvalidateOptions" },
+		{ name: "MutationFunctionContext" }
 	],
 	dependency: "@tanstack/angular-query-experimental"
 }, {
@@ -714,6 +728,13 @@ const getVueQueryDependencies = (hasGlobalMutator, hasParamsSerializerOptions, p
 		...hasVueQueryV3 ? VUE_QUERY_DEPENDENCIES_V3 : VUE_QUERY_DEPENDENCIES
 	];
 };
+const getSolidQueryDependencies = (hasGlobalMutator, hasParamsSerializerOptions, packageJson, httpClient) => {
+	return [
+		...!hasGlobalMutator && httpClient === OutputHttpClient.AXIOS ? AXIOS_DEPENDENCIES : [],
+		...hasParamsSerializerOptions ? PARAMS_SERIALIZER_DEPENDENCIES : [],
+		...SOLID_QUERY_DEPENDENCIES
+	];
+};
 const getAngularQueryDependencies = (hasGlobalMutator, hasParamsSerializerOptions, packageJson, httpClient) => {
 	const useAngularHttp = !hasGlobalMutator && httpClient === OutputHttpClient.ANGULAR;
 	const useAxios = !hasGlobalMutator && httpClient === OutputHttpClient.AXIOS;
@@ -757,8 +778,12 @@ const getPackageByQueryClient = (packageJson, queryClient) => {
 		case "svelte-query": return packageJson?.dependencies?.["@tanstack/svelte-query"] ?? packageJson?.devDependencies?.["@tanstack/svelte-query"] ?? packageJson?.peerDependencies?.["@tanstack/svelte-query"];
 		case "vue-query": return packageJson?.dependencies?.["@tanstack/vue-query"] ?? packageJson?.devDependencies?.["@tanstack/vue-query"] ?? packageJson?.peerDependencies?.["@tanstack/vue-query"];
 		case "angular-query": return packageJson?.dependencies?.["@tanstack/angular-query-experimental"] ?? packageJson?.devDependencies?.["@tanstack/angular-query-experimental"] ?? packageJson?.peerDependencies?.["@tanstack/angular-query-experimental"];
+		case "solid-query": return packageJson?.dependencies?.["@tanstack/solid-query"] ?? packageJson?.devDependencies?.["@tanstack/solid-query"] ?? packageJson?.peerDependencies?.["@tanstack/solid-query"];
 	}
 };
+
+//#endregion
+//#region src/query-options.ts
 const QueryType = {
 	INFINITE: "infiniteQuery",
 	QUERY: "query",
@@ -768,12 +793,12 @@ const QueryType = {
 const INFINITE_QUERY_PROPERTIES = new Set(["getNextPageParam", "getPreviousPageParam"]);
 const generateQueryOptions = ({ params, options, type, outputClient }) => {
 	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) => type !== QueryType.INFINITE && type !== QueryType.SUSPENSE_INFINITE && INFINITE_QUERY_PROPERTIES.has(key)))?.slice(1, -1)}` : "";
 	if (params.length === 0 || isSuspenseQuery(type)) {
 		if (options) return `${queryConfig} ...queryOptions`;
 		return "...queryOptions";
 	}
-	return `${!isObject(options) || !options.hasOwnProperty("enabled") ? isVue(outputClient) ? `enabled: computed(() => !!(${params.map(({ name }) => `unref(${name})`).join(" && ")})),` : `enabled: !!(${params.map(({ name }) => name).join(" && ")}),` : ""}${queryConfig} ...queryOptions`;
+	return `${!isObject(options) || !Object.hasOwn(options, "enabled") ? isVue(outputClient) ? `enabled: computed(() => !!(${params.map(({ name }) => `unref(${name})`).join(" && ")})),` : `enabled: !!(${params.map(({ name }) => name).join(" && ")}),` : ""}${queryConfig} ...queryOptions`;
 };
 const isSuspenseQuery = (type) => {
 	return [QueryType.SUSPENSE_INFINITE, QueryType.SUSPENSE_QUERY].includes(type);
@@ -791,7 +816,7 @@ const getQueryOptionsDefinition = ({ operationName, mutator, definitions, type,
           ${funcReturnType}${hasQueryV5 && (type === QueryType.INFINITE || type === QueryType.SUSPENSE_INFINITE) && queryParam && queryParams ? `, QueryKey` : ""}
         > , 'initialData'
       >` : "";
-		const optionType = `${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 optionType = `${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}']` : ""}>`;
 		return `${partialOptions ? "Partial<" : ""}${optionType}${partialOptions ? ">" : ""}${optionTypeInitialDataPostfix}`;
 	}
 	return `${prefix}MutationOptions<Awaited<ReturnType<${isMutatorHook ? `ReturnType<typeof use${pascal(operationName)}Hook>` : `typeof ${operationName}`}>>, TError,${definitions ? `{${definitions}}` : "void"}, TContext>`;
@@ -816,11 +841,17 @@ const generateQueryArguments = ({ operationName, definitions, mutator, isRequest
 	const isQueryRequired = initialData === "defined";
 	return `options${isQueryRequired ? "" : "?"}: { ${type ? "query" : "mutation"}${isQueryRequired ? "" : "?"}:${definition}, ${requestType}}\n`;
 };
+
+//#endregion
+//#region src/return-types.ts
 const generateQueryReturnType = ({ outputClient, type, isMutatorHook, operationName, hasVueQueryV4, hasSvelteQueryV4, hasQueryV5, hasQueryV5WithDataTagError, isInitialDataDefined }) => {
 	switch (outputClient) {
 		case OutputClient.ANGULAR_QUERY:
 			if (type !== QueryType.INFINITE && type !== QueryType.SUSPENSE_INFINITE) return `CreateQueryResult<TData, TError>`;
 			return `CreateInfiniteQueryResult<TData, TError>`;
+		case OutputClient.SOLID_QUERY:
+			if (type !== QueryType.INFINITE && type !== QueryType.SUSPENSE_INFINITE) return `CreateQueryResult<TData, TError> & { queryKey: ${hasQueryV5 ? `DataTag<QueryKey, TData${hasQueryV5WithDataTagError ? ", TError" : ""}>` : "QueryKey"} }`;
+			return `CreateInfiniteQueryResult<TData, TError> & { queryKey: ${hasQueryV5 ? `DataTag<QueryKey, TData${hasQueryV5WithDataTagError ? ", TError" : ""}>` : "QueryKey"} }`;
 		case OutputClient.SVELTE_QUERY:
 			if (!hasSvelteQueryV4) return `Use${pascal(type)}StoreResult<Awaited<ReturnType<${isMutatorHook ? `ReturnType<typeof use${pascal(operationName)}Hook>` : `typeof ${operationName}`}>>, TError, TData, QueryKey> & { queryKey: QueryKey} }`;
 			return `Create${pascal(type)}Result<TData, TError> & { queryKey: ${hasQueryV5 ? `DataTag<QueryKey, TData${hasQueryV5WithDataTagError ? ", TError" : ""}>` : "QueryKey"} }`;
@@ -828,7 +859,6 @@ const generateQueryReturnType = ({ outputClient, type, isMutatorHook, operationN
 			if (!hasVueQueryV4) return ` UseQueryReturnType<TData, TError, Use${pascal(type)}Result<TData, TError>> & { queryKey: QueryKey} }`;
 			if (type !== QueryType.INFINITE && type !== QueryType.SUSPENSE_INFINITE) return `UseQueryReturnType<TData, TError> & { queryKey: ${hasQueryV5 ? `DataTag<QueryKey, TData${hasQueryV5WithDataTagError ? ", TError" : ""}>` : "QueryKey"} }`;
 			return `UseInfiniteQueryReturnType<TData, TError> & { queryKey: ${hasQueryV5 ? `DataTag<QueryKey, TData${hasQueryV5WithDataTagError ? ", TError" : ""}>` : "QueryKey"} }`;
-		case OutputClient.REACT_QUERY:
 		default: return ` ${isInitialDataDefined && !isSuspenseQuery(type) ? "Defined" : ""}Use${pascal(type)}Result<TData, TError> & { queryKey: ${hasQueryV5 ? `DataTag<QueryKey, TData${hasQueryV5WithDataTagError ? ", TError" : ""}>` : "QueryKey"} }`;
 	}
 };
@@ -844,6 +874,12 @@ const generateMutatorReturnType = ({ outputClient, dataType, variableType }) =>
         TError,
         ${variableType},
         TContext
+      >`;
+	if (outputClient === OutputClient.SOLID_QUERY) return `: CreateMutationResult<
+        Awaited<ReturnType<${dataType}>>,
+        TError,
+        ${variableType},
+        TContext
       >`;
 	if (outputClient === OutputClient.SVELTE_QUERY) return `: CreateMutationResult<
         Awaited<ReturnType<${dataType}>>,
@@ -867,6 +903,154 @@ const getQueryFnArguments = ({ hasQueryParam, hasSignal }) => {
 	}
 	return "{ signal }";
 };
+const getQueryReturnStatement = ({ outputClient, hasSvelteQueryV4, hasSvelteQueryV6, hasQueryV5, hasQueryV5WithDataTagError, queryResultVarName, queryOptionsVarName }) => {
+	if (isAngular(outputClient)) return `return ${queryResultVarName};`;
+	if (isVue(outputClient)) return `${queryResultVarName}.queryKey = unref(${queryOptionsVarName}).queryKey as ${hasQueryV5 ? `DataTag<QueryKey, TData${hasQueryV5WithDataTagError ? ", TError" : ""}>` : "QueryKey"};
+
+  return ${queryResultVarName};`;
+	if (hasSvelteQueryV6) return `return ${queryResultVarName}`;
+	if (hasSvelteQueryV4) return `${queryResultVarName}.queryKey = ${queryOptionsVarName}.queryKey;
+
+  return ${queryResultVarName};`;
+	return `return { ...${queryResultVarName}, queryKey: ${queryOptionsVarName}.queryKey };`;
+};
+
+//#endregion
+//#region src/mutation-generator.ts
+const normalizeTarget = (target) => typeof target === "string" ? { query: target } : target;
+const serializeTarget = (target) => JSON.stringify({
+	query: target.query,
+	params: target.params ?? []
+});
+const generateVariableRef = (varName) => {
+	const parts = varName.split(".");
+	if (parts.length === 1) return `variables.${varName}`;
+	return `variables.${parts[0]}?.${parts.slice(1).join("?.")}`;
+};
+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) => {
+	return `    queryClient.invalidateQueries({ queryKey: ${camel(`get-${target.query}-query-key`)}(${target.params ? generateParamArgs(target.params) : ""}) });`;
+};
+const generateMutationHook = async ({ verbOptions, options, outputClient, hasQueryV5, hasQueryV5WithInfiniteQueryOptionsError, hasSvelteQueryV4, hasSvelteQueryV6, isRequestOptions, httpClient, doc, isAngularHttp }) => {
+	const { operationName, body, props, mutator, response, operationId, override } = verbOptions;
+	const { route, context, output } = options;
+	const query = override.query;
+	const mutationOptionsMutator = query.mutationOptions ? await generateMutator({
+		output,
+		mutator: query.mutationOptions,
+		name: `${operationName}MutationOptions`,
+		workspace: context.workspace,
+		tsconfig: context.output.tsconfig
+	}) : void 0;
+	const definitions = props.map(({ definition, type }) => type === GetterPropType.BODY ? mutator?.bodyTypeName ? `data: ${mutator.bodyTypeName}<${body.definition}>` : `data: ${body.definition}` : definition).join(";");
+	const properties = props.map(({ name, type }) => type === GetterPropType.BODY ? "data" : name).join(",");
+	const errorType = getQueryErrorType(operationName, response, httpClient, mutator);
+	const dataType = mutator?.isHook ? `ReturnType<typeof use${pascal(operationName)}Hook>` : `typeof ${operationName}`;
+	const isAngularClient = isAngular(outputClient);
+	const mutationOptionFnReturnType = getQueryOptionsDefinition({
+		operationName,
+		mutator,
+		definitions,
+		hasSvelteQueryV4,
+		hasQueryV5,
+		hasQueryV5WithInfiniteQueryOptionsError,
+		isReturnType: true,
+		isAngularClient
+	});
+	const mutationArguments = generateQueryArguments({
+		operationName,
+		definitions,
+		mutator,
+		isRequestOptions,
+		hasSvelteQueryV4,
+		hasQueryV5,
+		hasQueryV5WithInfiniteQueryOptionsError,
+		httpClient,
+		isAngularClient
+	});
+	const mutationOptionsFnName = camel(mutationOptionsMutator || mutator?.isHook ? `use-${operationName}-mutationOptions` : `get-${operationName}-mutationOptions`);
+	const hooksOptionImplementation = getHooksOptionImplementation(isRequestOptions, httpClient, camel(operationName), mutator);
+	const invalidatesConfig = (query.mutationInvalidates ?? []).filter((rule) => rule.onMutations.includes(operationName)).flatMap((rule) => rule.invalidates).map((t) => normalizeTarget(t));
+	const seenTargets = /* @__PURE__ */ new Set();
+	const uniqueInvalidates = invalidatesConfig.filter((target) => {
+		const key = serializeTarget(target);
+		if (seenTargets.has(key)) return false;
+		seenTargets.add(key);
+		return true;
+	});
+	const hasInvalidation = uniqueInvalidates.length > 0 && isAngularClient;
+	const mutationOptionsFn = `export const ${mutationOptionsFnName} = <TError = ${errorType},
+    TContext = unknown>(${mutationArguments}): ${mutationOptionFnReturnType} => {
+
+${hooksOptionImplementation}
+${isAngularHttp ? "  const http = inject(HttpClient);" : ""}
+${hasInvalidation ? "  const queryClient = inject(QueryClient);" : ""}
+
+      ${mutator?.isHook ? `const ${operationName} =  use${pascal(operationName)}Hook()` : ""}
+
+
+      const mutationFn: MutationFunction<Awaited<ReturnType<${dataType}>>, ${definitions ? `{${definitions}}` : "void"}> = (${properties ? "props" : ""}) => {
+          ${properties ? `const {${properties}} = props ?? {};` : ""}
+
+          return  ${operationName}(${isAngularHttp ? "http, " : ""}${properties}${properties ? "," : ""}${getMutationRequestArgs(isRequestOptions, httpClient, mutator)})
+        }
+
+${hasInvalidation ? `  const onSuccess = (data: Awaited<ReturnType<typeof ${operationName}>>, variables: ${definitions ? `{${definitions}}` : "void"}, onMutateResult: TContext, context: MutationFunctionContext) => {
+${uniqueInvalidates.map((t) => generateInvalidateCall(t)).join("\n")}
+    mutationOptions?.onSuccess?.(data, variables, onMutateResult, context);
+  };` : ""}
+
+        ${mutationOptionsMutator ? `const customOptions = ${mutationOptionsMutator.name}({...mutationOptions, mutationFn}${mutationOptionsMutator.hasSecondArg ? `, { url: \`${route.replaceAll("/${", "/{")}\` }` : ""}${mutationOptionsMutator.hasThirdArg ? `, { operationId: '${operationId}', operationName: '${operationName}' }` : ""});` : ""}
+
+
+  return  ${mutationOptionsMutator ? "customOptions" : hasInvalidation ? "{ mutationFn, onSuccess, ...mutationOptions }" : "{ mutationFn, ...mutationOptions }"}}`;
+	const operationPrefix = getFrameworkPrefix(hasSvelteQueryV4, isAngular(outputClient), isSolid(outputClient));
+	const optionalQueryClientArgument = hasQueryV5 && !isAngular(outputClient) ? ", queryClient?: QueryClient" : "";
+	const mutationImplementation = `${mutationOptionsFnName}(${isRequestOptions ? "options" : "mutationOptions"})`;
+	const mutationOptionsVarName = camel(`${operationName}-mutation-options`);
+	return {
+		implementation: `
+${mutationOptionsFn}
+
+    export type ${pascal(operationName)}MutationResult = NonNullable<Awaited<ReturnType<${dataType}>>>
+    ${body.definition ? `export type ${pascal(operationName)}MutationBody = ${mutator?.bodyTypeName ? `${mutator.bodyTypeName}<${body.definition}>` : body.definition}` : ""}
+    export type ${pascal(operationName)}MutationError = ${errorType}
+
+    ${doc}export const ${camel(`${operationPrefix}-${operationName}`)} = <TError = ${errorType},
+    TContext = unknown>(${mutationArguments} ${optionalQueryClientArgument})${generateMutatorReturnType({
+			outputClient,
+			dataType,
+			variableType: definitions ? `{${definitions}}` : "void"
+		})} => {
+${isAngular(outputClient) ? `      const ${mutationOptionsVarName} = ${mutationImplementation};
+
+      return ${operationPrefix}Mutation(() => ${mutationOptionsVarName});` : `      return ${operationPrefix}Mutation(${hasSvelteQueryV6 ? `() => ({ ...${mutationImplementation}${optionalQueryClientArgument ? ", queryClient" : ""} })` : `${mutationImplementation}${optionalQueryClientArgument ? ", queryClient" : ""}`});`}
+    }
+    `,
+		mutators: mutationOptionsMutator ? [mutationOptionsMutator] : void 0
+	};
+};
+
+//#endregion
+//#region src/query-generator.ts
+/**
+* Get framework-aware prefix for hook names and type definitions
+* @param hasSvelteQueryV4 - Whether using Svelte Query v4
+* @param isAngularClient - Whether using Angular client
+* @param isSolidClient - Whether using Solid Query client
+* @param capitalize - Whether to capitalize the prefix (for type definitions)
+* @returns The appropriate prefix string
+*/
+const getFrameworkPrefix = (hasSvelteQueryV4, isAngularClient, isSolidClient, capitalize = false) => {
+	let prefix;
+	if (hasSvelteQueryV4 || isSolidClient) prefix = "create";
+	else if (isAngularClient) prefix = "inject";
+	else prefix = "use";
+	return capitalize ? prefix.charAt(0).toUpperCase() + prefix.slice(1) : prefix;
+};
 const generatePrefetch = ({ usePrefetch, type, useQuery, useInfinite, operationName, mutator, doc, queryProps, dataType, errorType, queryArguments, queryOptionsVarName, queryOptionsFnName, queryProperties, isRequestOptions, hasSvelteQueryV6 }) => {
 	if (!(usePrefetch && (type === QueryType.QUERY || type === QueryType.INFINITE || type === QueryType.SUSPENSE_QUERY && !useQuery || type === QueryType.SUSPENSE_INFINITE && !useInfinite))) return "";
 	const prefetchType = type === QueryType.QUERY || type === QueryType.SUSPENSE_QUERY ? "query" : "infinite-query";
@@ -1012,7 +1196,7 @@ const generateQueryImplementation = ({ queryOption: { name, queryParam, options,
 	const queryOptionsFnName = camel(queryKeyMutator || queryOptionsMutator || mutator?.isHook ? `use-${name}-queryOptions` : `get-${name}-queryOptions`);
 	const queryOptionsVarName = isRequestOptions ? "queryOptions" : "options";
 	const queryResultVarName = props.some((prop) => prop.name === "query") ? "_query" : "query";
-	const infiniteParam = queryParams && queryParam ? `, ${queryParams?.schema.name}['${queryParam}']` : "";
+	const infiniteParam = queryParams && queryParam ? `, ${queryParams.schema.name}['${queryParam}']` : "";
 	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}>(${queryProps} ${queryArguments}) => {
 
@@ -1023,7 +1207,7 @@ ${isAngularHttp ? "  const http = inject(HttpClient);" : ""}
 
   ${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, ${queryParams?.schema.name}['${queryParam}']` : ""}> = (${queryFnArguments}) => ${operationName}(${httpFunctionProps}${httpFunctionProps ? ", " : ""}${queryOptions});
+    const queryFn: QueryFunction<Awaited<ReturnType<${mutator?.isHook ? `ReturnType<typeof use${pascal(operationName)}Hook>` : `typeof ${operationName}`}>>${hasQueryV5 && hasInfiniteQueryParam ? `, QueryKey, ${queryParams.schema.name}['${queryParam}']` : ""}> = (${queryFnArguments}) => ${operationName}(${httpFunctionProps}${httpFunctionProps ? ", " : ""}${queryOptions});
 
       ${isVue(outputClient) ? vueUnRefParams(props.filter((prop) => prop.type === GetterPropType.NAMED_PATH_PARAMS)) : ""}
 
@@ -1031,8 +1215,8 @@ ${isAngularHttp ? "  const http = inject(HttpClient);" : ""}
 
    return  ${queryOptionsMutator ? "customOptions" : `{ queryKey, queryFn, ${queryOptionsImp}}`} as ${queryOptionFnReturnType} ${isVue(outputClient) || isAngular(outputClient) ? "" : `& { queryKey: ${hasQueryV5 ? `DataTag<QueryKey, TData${hasQueryV5WithDataTagError ? ", TError" : ""}>` : "QueryKey"} }`}
 }`;
-	const operationPrefix = getFrameworkPrefix(hasSvelteQueryV4, isAngular(outputClient));
-	const optionalQueryClientArgument = hasQueryV5 && !isAngular(outputClient) ? ", queryClient?: QueryClient" : "";
+	const operationPrefix = getFrameworkPrefix(hasSvelteQueryV4, isAngular(outputClient), isSolid(outputClient));
+	const optionalQueryClientArgument = hasSvelteQueryV6 ? `, queryClient?: () => QueryClient` : hasQueryV5 && !isAngular(outputClient) ? ", queryClient?: QueryClient" : "";
 	const queryHookName = camel(`${operationPrefix}-${name}`);
 	const overrideTypes = `
 export function ${queryHookName}<TData = ${TData}, TError = ${errorType}>(\n ${definedInitialDataQueryPropsDefinitions} ${definedInitialDataQueryArguments} ${optionalQueryClientArgument}\n  ): ${definedInitialDataReturnType}
@@ -1045,7 +1229,7 @@ export function ${queryHookName}<TData = ${TData}, TError = ${errorType}>(\n ${q
 		useInfinite,
 		operationName,
 		mutator,
-		queryProps,
+		queryProps: hasSvelteQueryV6 ? queryProps.replace(":", ": () => ") : queryProps,
 		dataType,
 		errorType,
 		hasSvelteQueryV6,
@@ -1066,15 +1250,27 @@ export type ${pascal(name)}QueryError = ${errorType}
 
 ${hasQueryV5 && OutputClient.REACT_QUERY === outputClient ? overrideTypes : ""}
 ${doc}
-export function ${queryHookName}<TData = ${TData}, TError = ${errorType}>(\n ${queryProps} ${queryArguments} ${optionalQueryClientArgument} \n ): ${returnType} {
+export function ${queryHookName}<TData = ${TData}, TError = ${errorType}>(\n ${hasSvelteQueryV6 ? toObjectString(props.map((p) => ({
+		...p,
+		definition: p.definition.replace(":", ": () => ")
+	})), "definition") : queryProps} ${hasSvelteQueryV6 ? queryArguments.replace(":", ": () => (") + ")" : queryArguments} ${optionalQueryClientArgument} \n ): ${returnType} {
 
-  const ${queryOptionsVarName} = ${queryOptionsFnName}(${queryProperties}${queryProperties ? "," : ""}${isRequestOptions ? "options" : "queryOptions"})
-
-  const ${queryResultVarName} = ${camel(`${operationPrefix}-${isAngular(outputClient) || hasSvelteQueryV4 ? getQueryTypeForFramework(type) : type}`)}(${isAngular(outputClient) ? `() => ${queryOptionsVarName}` : hasSvelteQueryV6 ? `() => ({ ...${queryOptionsVarName}${optionalQueryClientArgument ? ", queryClient" : ""} })` : `${queryOptionsVarName}${!isAngular(outputClient) && optionalQueryClientArgument ? ", queryClient" : ""}`}) as ${returnType};
+  ${hasSvelteQueryV6 ? "" : `const ${queryOptionsVarName} = ${queryOptionsFnName}(${queryProperties}${queryProperties ? "," : ""}${isRequestOptions ? "options" : "queryOptions"})`}
 
-  ${isAngular(outputClient) ? `` : `${queryResultVarName}.queryKey = ${isVue(outputClient) ? `unref(${queryOptionsVarName})` : queryOptionsVarName}.queryKey ${isVue(outputClient) ? `as ${hasQueryV5 ? `DataTag<QueryKey, TData${hasQueryV5WithDataTagError ? ", TError" : ""}>` : "QueryKey"}` : ""};`}
+  const ${queryResultVarName} = ${camel(`${operationPrefix}-${isAngular(outputClient) || hasSvelteQueryV4 ? getQueryTypeForFramework(type) : type}`)}(${isAngular(outputClient) ? `() => ${queryOptionsVarName}` : hasSvelteQueryV6 ? `() => ${queryOptionsFnName}(${toObjectString(props.map((p) => ({
+		...p,
+		name: p.default || !p.required ? `${p.name}?.()` : `${p.name}()`
+	})), "name")}${isRequestOptions ? "options?.()" : "queryOptions?.()"})` : `${queryOptionsVarName}${!isAngular(outputClient) && optionalQueryClientArgument ? ", queryClient" : ""}`}${hasSvelteQueryV6 ? `, queryClient` : ""}) as ${returnType};
 
-  return ${queryResultVarName};
+  ${getQueryReturnStatement({
+		outputClient,
+		hasSvelteQueryV4,
+		hasSvelteQueryV6,
+		hasQueryV5,
+		hasQueryV5WithDataTagError,
+		queryResultVarName,
+		queryOptionsVarName
+	})}
 }\n
 ${prefetch}
 ${shouldGenerateInvalidate ? `${doc}export const ${invalidateFnName} = async (\n queryClient: QueryClient, ${queryProps} options?: InvalidateOptions\n  ): Promise<QueryClient> => {
@@ -1085,14 +1281,16 @@ ${shouldGenerateInvalidate ? `${doc}export const ${invalidateFnName} = async (\n
 }\n` : ""}
 `;
 };
-const generateQueryHook = async ({ queryParams, operationName, body, props: _props, verb, params, override, mutator, response, operationId, summary, deprecated }, { route, override: { operations }, context, output }, outputClient) => {
+const generateQueryHook = async (verbOptions, options, outputClient) => {
+	const { queryParams, operationName, body, props: _props, verb, params, override, mutator, response, operationId, summary, deprecated } = verbOptions;
+	const { route, override: { operations }, context, output } = options;
 	let props = _props;
 	if (isVue(outputClient)) props = vueWrapTypeWithMaybeRef(_props);
-	const query = override?.query;
-	const isRequestOptions = override?.requestOptions !== false;
+	const query = override.query;
+	const isRequestOptions = override.requestOptions !== false;
 	const operationQueryOptions = operations[operationId]?.query;
 	const isExactOptionalPropertyTypes = !!context.output.tsconfig?.compilerOptions?.exactOptionalPropertyTypes;
-	const queryVersion = override.query.version ?? query?.version;
+	const queryVersion = query.version;
 	const hasVueQueryV4 = OutputClient.VUE_QUERY === outputClient && (!isVueQueryV3(context.output.packageJson) || queryVersion === 4);
 	const hasSvelteQueryV4 = OutputClient.SVELTE_QUERY === outputClient && (!isSvelteQueryV3(context.output.packageJson) || queryVersion === 4);
 	const hasSvelteQueryV6 = OutputClient.SVELTE_QUERY === outputClient && isSvelteQueryV6(context.output.packageJson);
@@ -1107,8 +1305,18 @@ const generateQueryHook = async ({ queryParams, operationName, body, props: _pro
 	});
 	let implementation = "";
 	let mutators;
-	const hasOperationQueryOption = !!(operationQueryOptions && (operationQueryOptions.useQuery || operationQueryOptions.useSuspenseQuery || operationQueryOptions.useInfinite || operationQueryOptions.useSuspenseInfiniteQuery));
-	let isQuery = Verbs.GET === verb && (override.query.useQuery || override.query.useSuspenseQuery || override.query.useInfinite || override.query.useSuspenseInfiniteQuery) || hasOperationQueryOption;
+	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;
 	if (verb !== Verbs.GET && isQuery) isMutation = false;
@@ -1137,36 +1345,36 @@ const generateQueryHook = async ({ queryParams, operationName, body, props: _pro
 			return param.type === GetterPropType.BODY ? body.implementation : param.name;
 		}).join(",");
 		const queries = [
-			...query?.useInfinite || operationQueryOptions?.useInfinite ? [{
+			...query.useInfinite || operationQueryOptions?.useInfinite ? [{
 				name: camel(`${operationName}-infinite`),
-				options: query?.options,
+				options: query.options,
 				type: QueryType.INFINITE,
-				queryParam: query?.useInfiniteQueryParam,
+				queryParam: query.useInfiniteQueryParam,
 				queryKeyFnName: camel(`get-${operationName}-infinite-query-key`)
 			}] : [],
-			...query?.useQuery || operationQueryOptions?.useQuery ? [{
+			...query.useQuery || operationQueryOptions?.useQuery ? [{
 				name: operationName,
-				options: query?.options,
+				options: query.options,
 				type: QueryType.QUERY,
 				queryKeyFnName: camel(`get-${operationName}-query-key`)
 			}] : [],
-			...query?.useSuspenseQuery || operationQueryOptions?.useSuspenseQuery ? [{
+			...query.useSuspenseQuery || operationQueryOptions?.useSuspenseQuery ? [{
 				name: camel(`${operationName}-suspense`),
-				options: query?.options,
+				options: query.options,
 				type: QueryType.SUSPENSE_QUERY,
 				queryKeyFnName: camel(`get-${operationName}-query-key`)
 			}] : [],
-			...query?.useSuspenseInfiniteQuery || operationQueryOptions?.useSuspenseInfiniteQuery ? [{
+			...query.useSuspenseInfiniteQuery || operationQueryOptions?.useSuspenseInfiniteQuery ? [{
 				name: camel(`${operationName}-suspense-infinite`),
-				options: query?.options,
+				options: query.options,
 				type: QueryType.SUSPENSE_INFINITE,
-				queryParam: query?.useInfiniteQueryParam,
+				queryParam: query.useInfiniteQueryParam,
 				queryKeyFnName: camel(`get-${operationName}-infinite-query-key`)
 			}] : []
 		];
 		const makeParamsOptional = (params$1) => {
 			if (!params$1) return "";
-			return params$1.replaceAll(/(\w+)(\?)?:\s*([^=,}]*?)\s*(=\s*[^,}]*)?([,}]|$)/g, (match, paramName, optionalMarker, type, defaultValue, suffix) => {
+			return params$1.replaceAll(/(\w+)(\?)?:\s*([^=,}]*?)\s*(=\s*[^,}]*)?([,}]|$)/g, (_match, paramName, _optionalMarker, type, defaultValue, suffix) => {
 				if (defaultValue) return `${paramName}: ${type.trim()}${defaultValue}${suffix}`;
 				return `${paramName}?: ${type.trim()}${suffix}`;
 			});
@@ -1207,10 +1415,7 @@ ${override.query.shouldExportQueryKey ? "export " : ""}const ${queryOption.query
 				outputClient,
 				httpClient,
 				isExactOptionalPropertyTypes,
-				hasSignal: getHasSignal({
-					overrideQuerySignal: override.query.signal,
-					verb
-				}),
+				hasSignal: getHasSignal({ overrideQuerySignal: override.query.signal }),
 				queryOptionsMutator,
 				queryKeyMutator,
 				route,
@@ -1231,87 +1436,33 @@ ${override.query.shouldExportQueryKey ? "export " : ""}const ${queryOption.query
 		mutators = queryOptionsMutator || queryKeyMutator ? [...queryOptionsMutator ? [queryOptionsMutator] : [], ...queryKeyMutator ? [queryKeyMutator] : []] : void 0;
 	}
 	if (isMutation) {
-		const mutationOptionsMutator = query.mutationOptions ? await generateMutator({
-			output,
-			mutator: query.mutationOptions,
-			name: `${operationName}MutationOptions`,
-			workspace: context.workspace,
-			tsconfig: context.output.tsconfig
-		}) : void 0;
-		const definitions = props.map(({ definition, type }) => type === GetterPropType.BODY ? mutator?.bodyTypeName ? `data: ${mutator.bodyTypeName}<${body.definition}>` : `data: ${body.definition}` : definition).join(";");
-		const properties = props.map(({ name, type }) => type === GetterPropType.BODY ? "data" : name).join(",");
-		const errorType = getQueryErrorType(operationName, response, httpClient, mutator);
-		const dataType = mutator?.isHook ? `ReturnType<typeof use${pascal(operationName)}Hook>` : `typeof ${operationName}`;
-		const mutationOptionFnReturnType = getQueryOptionsDefinition({
-			operationName,
-			mutator,
-			definitions,
-			hasSvelteQueryV4,
+		const mutationResult = await generateMutationHook({
+			verbOptions: {
+				...verbOptions,
+				props
+			},
+			options,
+			outputClient,
 			hasQueryV5,
 			hasQueryV5WithInfiniteQueryOptionsError,
-			isReturnType: true,
-			isAngularClient: isAngular(outputClient)
-		});
-		const mutationArguments = generateQueryArguments({
-			operationName,
-			definitions,
-			mutator,
-			isRequestOptions,
 			hasSvelteQueryV4,
-			hasQueryV5,
-			hasQueryV5WithInfiniteQueryOptionsError,
+			hasSvelteQueryV6,
+			isRequestOptions,
 			httpClient,
-			isAngularClient: isAngular(outputClient)
+			doc,
+			isAngularHttp
 		});
-		const mutationOptionsFnName = camel(mutationOptionsMutator || mutator?.isHook ? `use-${operationName}-mutationOptions` : `get-${operationName}-mutationOptions`);
-		const mutationOptionsVarName = isRequestOptions ? "mutationOptions" : "options";
-		const mutationOptionsFn = `export const ${mutationOptionsFnName} = <TError = ${errorType},
-    TContext = unknown>(${mutationArguments}): ${mutationOptionFnReturnType} => {
-
-${getHooksOptionImplementation(isRequestOptions, httpClient, camel(operationName), mutator)}
-${isAngularHttp ? "  const http = inject(HttpClient);" : ""}
-
-      ${mutator?.isHook ? `const ${operationName} =  use${pascal(operationName)}Hook()` : ""}
-
-
-      const mutationFn: MutationFunction<Awaited<ReturnType<${dataType}>>, ${definitions ? `{${definitions}}` : "void"}> = (${properties ? "props" : ""}) => {
-          ${properties ? `const {${properties}} = props ?? {};` : ""}
-
-          return  ${operationName}(${isAngularHttp ? "http, " : ""}${properties}${properties ? "," : ""}${getMutationRequestArgs(isRequestOptions, httpClient, mutator)})
-        }
-
-        ${mutationOptionsMutator ? `const customOptions = ${mutationOptionsMutator.name}({...mutationOptions, mutationFn}${mutationOptionsMutator.hasSecondArg ? `, { url: \`${route.replaceAll("/${", "/{")}\` }` : ""}${mutationOptionsMutator.hasThirdArg ? `, { operationId: '${operationId}', operationName: '${operationName}' }` : ""});` : ""}
-
-
-  return  ${mutationOptionsMutator ? "customOptions" : "{ mutationFn, ...mutationOptions }"}}`;
-		const operationPrefix = getFrameworkPrefix(hasSvelteQueryV4, isAngular(outputClient));
-		const optionalQueryClientArgument = hasQueryV5 && !isAngular(outputClient) ? ", queryClient?: QueryClient" : "";
-		implementation += `
-${mutationOptionsFn}
-
-    export type ${pascal(operationName)}MutationResult = NonNullable<Awaited<ReturnType<${dataType}>>>
-    ${body.definition ? `export type ${pascal(operationName)}MutationBody = ${mutator?.bodyTypeName ? `${mutator.bodyTypeName}<${body.definition}>` : body.definition}` : ""}
-    export type ${pascal(operationName)}MutationError = ${errorType}
-
-    ${doc}export const ${camel(`${operationPrefix}-${operationName}`)} = <TError = ${errorType},
-    TContext = unknown>(${mutationArguments} ${optionalQueryClientArgument})${generateMutatorReturnType({
-			outputClient,
-			dataType,
-			variableType: definitions ? `{${definitions}}` : "void"
-		})} => {
-
-      const ${mutationOptionsVarName} = ${mutationOptionsFnName}(${isRequestOptions ? "options" : "mutationOptions"});
-
-      return ${operationPrefix}Mutation(${isAngular(outputClient) ? `() => ${mutationOptionsVarName}` : hasSvelteQueryV6 ? `() => ({ ...${mutationOptionsVarName}${optionalQueryClientArgument ? ", queryClient" : ""} })` : `${mutationOptionsVarName}${!isAngular(outputClient) && optionalQueryClientArgument ? ", queryClient" : ""}`});
-    }
-    `;
-		mutators = mutationOptionsMutator ? [...mutators ?? [], mutationOptionsMutator] : mutators;
+		implementation += mutationResult.implementation;
+		mutators = mutationResult.mutators ? [...mutators ?? [], ...mutationResult.mutators] : mutators;
 	}
 	return {
 		implementation,
 		mutators
 	};
 };
+
+//#endregion
+//#region src/index.ts
 const generateQueryHeader = (params) => {
 	return `${params.hasAwaitedType ? "" : `type AwaitedInput<T> = PromiseLike<T> | T;\n
       type Awaited<O> = O extends AwaitedInput<infer T> ? T : never;\n\n`}
@@ -1333,7 +1484,8 @@ const dependenciesBuilder = {
 	"react-query": getReactQueryDependencies,
 	"vue-query": getVueQueryDependencies,
 	"svelte-query": getSvelteQueryDependencies,
-	"angular-query": getAngularQueryDependencies
+	"angular-query": getAngularQueryDependencies,
+	"solid-query": getSolidQueryDependencies
 };
 const builder = ({ type = "react-query", options: queryOptions, output } = {}) => () => {
 	const client = (verbOptions, options, outputClient) => {
@@ -1354,5 +1506,5 @@ const builder = ({ type = "react-query", options: queryOptions, output } = {}) =
 var src_default = builder;
 
 //#endregion
-export { builder, src_default as default, generateQuery, generateQueryHeader, getAngularQueryDependencies, getReactQueryDependencies, getSvelteQueryDependencies, getVueQueryDependencies };
+export { builder, src_default as default, generateQuery, generateQueryHeader, getAngularQueryDependencies, getReactQueryDependencies, getSolidQueryDependencies, getSvelteQueryDependencies, getVueQueryDependencies };
 //# sourceMappingURL=index.mjs.map