@orval/query 8.0.0-rc.4 → 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,7 +59,16 @@ 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 getHasSignal = ({ overrideQuerySignal = false, verb }) => overrideQuerySignal && (!getIsBodyVerb(verb) || verb === Verbs.POST);
+const isSolid = (client) => OutputClient.SOLID_QUERY === client;
+const isAngular = (client) => OutputClient.ANGULAR_QUERY === client;
+const getQueryTypeForFramework = (type) => {
+	switch (type) {
+		case "suspenseQuery": return "query";
+		case "suspenseInfiniteQuery": return "infiniteQuery";
+		default: return type;
+	}
+};
+const getHasSignal = ({ overrideQuerySignal = false }) => overrideQuerySignal;
 
 //#endregion
 //#region src/client.ts
@@ -77,21 +86,130 @@ const AXIOS_DEPENDENCIES = [{
 	],
 	dependency: "axios"
 }];
-const generateQueryRequestFunction = (verbOptions, options, isVue$1) => {
+const ANGULAR_HTTP_DEPENDENCIES = [
+	{
+		exports: [
+			{
+				name: "HttpClient",
+				values: true
+			},
+			{
+				name: "HttpHeaders",
+				values: true
+			},
+			{
+				name: "HttpParams",
+				values: true
+			},
+			{ name: "HttpContext" }
+		],
+		dependency: "@angular/common/http"
+	},
+	{
+		exports: [{
+			name: "lastValueFrom",
+			values: true
+		}, {
+			name: "fromEvent",
+			values: true
+		}],
+		dependency: "rxjs"
+	},
+	{
+		exports: [{
+			name: "takeUntil",
+			values: true
+		}],
+		dependency: "rxjs/operators"
+	}
+];
+const generateQueryRequestFunction = (verbOptions, options, isVue$1, isAngularClient = false) => {
+	if (isAngularClient || options.context.output.httpClient === OutputHttpClient.ANGULAR) return generateAngularHttpRequestFunction(verbOptions, options);
 	return options.context.output.httpClient === OutputHttpClient.AXIOS ? generateAxiosRequestFunction(verbOptions, options, isVue$1) : generateRequestFunction(verbOptions, options);
 };
+const generateAngularHttpRequestFunction = ({ headers, queryParams, operationName, response, mutator, body, props, verb, formData, formUrlEncoded, override }, { route, context }) => {
+	const isRequestOptions = override.requestOptions !== false;
+	const isFormData = !override.formData.disabled;
+	const isFormUrlEncoded = override.formUrlEncoded !== false;
+	const hasSignal = getHasSignal({ overrideQuerySignal: override.query.signal });
+	const bodyForm = generateFormDataAndUrlEncodedFunction({
+		formData,
+		formUrlEncoded,
+		body,
+		isFormData,
+		isFormUrlEncoded
+	});
+	if (mutator) {
+		const mutatorConfig = generateMutatorConfig({
+			route,
+			body,
+			headers,
+			queryParams,
+			response,
+			verb,
+			isFormData,
+			isFormUrlEncoded,
+			hasSignal,
+			isExactOptionalPropertyTypes: !!context.output.tsconfig?.compilerOptions?.exactOptionalPropertyTypes,
+			isVue: false
+		});
+		const requestOptions = isRequestOptions ? generateMutatorRequestOptions(override.requestOptions, mutator.hasSecondArg) : "";
+		const propsImplementation = toObjectString(props, "implementation");
+		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},
+      ${requestOptions});
+    }
+  `;
+	}
+	const queryProps = toObjectString(props, "implementation").replace(/,\s*$/, "");
+	const dataType = response.definition.success || "unknown";
+	const hasQueryParams = queryParams?.schema.name;
+	const urlConstruction = hasQueryParams ? `const httpParams = params ? new HttpParams({ fromObject: params as Record<string, string> }) : undefined;
+    const url = \`${route}\`;` : `const url = \`${route}\`;`;
+	const httpOptions = [];
+	if (hasQueryParams) httpOptions.push("params: httpParams");
+	if (headers) httpOptions.push("headers: new HttpHeaders(headers)");
+	const optionsStr = httpOptions.length > 0 ? `, { ${httpOptions.join(", ")} }` : "";
+	let httpCall;
+	const bodyArg = body.definition ? toObjectString([body], "implementation").replace(/,\s*$/, "") : "";
+	switch (verb) {
+		case "get":
+		case "head":
+			httpCall = `http.${verb}<${dataType}>(url${optionsStr})`;
+			break;
+		case "delete":
+			httpCall = bodyArg ? `http.${verb}<${dataType}>(url, { ${httpOptions.length > 0 ? httpOptions.join(", ") + ", " : ""}body: ${bodyArg} })` : `http.${verb}<${dataType}>(url${optionsStr})`;
+			break;
+		default:
+			httpCall = `http.${verb}<${dataType}>(url, ${bodyArg || "undefined"}${optionsStr})`;
+			break;
+	}
+	const optionsParam = hasSignal ? ", options?: { signal?: AbortSignal | null }" : "";
+	return `${override.query.shouldExportHttpClient ? "export " : ""}const ${operationName} = (
+    http: HttpClient,
+    ${queryProps}${optionsParam}
+  ): Promise<${dataType}> => {
+    ${bodyForm}
+    ${urlConstruction}
+    const request$ = ${httpCall};
+    if (options?.signal) {
+      return lastValueFrom(request$.pipe(takeUntil(fromEvent(options.signal, 'abort'))));
+    }
+    return lastValueFrom(request$);
+  }
+`;
+};
 const generateAxiosRequestFunction = ({ headers, queryParams, operationName, response, mutator, body, props: _props, verb, formData, formUrlEncoded, override, paramsSerializer }, { route: _route, context }, isVue$1) => {
 	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,
@@ -115,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(/* @__PURE__ */ new RegExp(`(\\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 = () => {
@@ -157,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
@@ -224,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}}
@@ -232,18 +350,19 @@ 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) => {
-	if (isVue$1 && httpClient === OutputHttpClient.FETCH && queryProperties) return queryProperties.split(",").map((prop) => `unref(${prop})`).join(",");
-	return queryProperties;
+const getHttpFunctionQueryProps = (isVue$1, httpClient, queryProperties, isAngular$1 = false) => {
+	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;
 };
 const getQueryHeader = (params) => {
 	return params.output.httpClient === OutputHttpClient.FETCH ? generateFetchHeader(params) : "";
 };
 
 //#endregion
-//#region src/index.ts
+//#region src/dependencies.ts
 const REACT_DEPENDENCIES = [{
 	exports: [{
 		name: "useCallback",
@@ -418,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 : [],
@@ -517,6 +636,85 @@ 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: [
+		{
+			name: "injectQuery",
+			values: true
+		},
+		{
+			name: "injectInfiniteQuery",
+			values: true
+		},
+		{
+			name: "injectMutation",
+			values: true
+		},
+		{ name: "InjectQueryOptions" },
+		{ name: "InjectMutationOptions" },
+		{ name: "CreateQueryOptions" },
+		{ name: "CreateInfiniteQueryOptions" },
+		{ name: "CreateMutationOptions" },
+		{ name: "QueryFunction" },
+		{ name: "MutationFunction" },
+		{ name: "QueryKey" },
+		{ name: "CreateQueryResult" },
+		{ name: "CreateInfiniteQueryResult" },
+		{ name: "InfiniteData" },
+		{ name: "CreateMutationResult" },
+		{ name: "DataTag" },
+		{
+			name: "QueryClient",
+			values: true
+		},
+		{ name: "InvalidateOptions" },
+		{ name: "MutationFunctionContext" }
+	],
+	dependency: "@tanstack/angular-query-experimental"
+}, {
+	exports: [
+		{
+			name: "inject",
+			values: true
+		},
+		{ name: "Signal" },
+		{
+			name: "computed",
+			values: true
+		}
+	],
+	dependency: "@angular/core"
+}];
 const isVueQueryV3 = (packageJson) => {
 	const hasVueQuery = packageJson?.dependencies?.["vue-query"] ?? packageJson?.devDependencies?.["vue-query"] ?? packageJson?.peerDependencies?.["vue-query"];
 	const hasVueQueryV4 = packageJson?.dependencies?.["@tanstack/vue-query"] ?? packageJson?.devDependencies?.["@tanstack/vue-query"] ?? packageJson?.peerDependencies?.["@tanstack/vue-query"];
@@ -530,7 +728,25 @@ 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;
+	return [
+		...useAngularHttp ? ANGULAR_HTTP_DEPENDENCIES : [],
+		...useAxios ? AXIOS_DEPENDENCIES : [],
+		...hasParamsSerializerOptions ? PARAMS_SERIALIZER_DEPENDENCIES : [],
+		...ANGULAR_QUERY_DEPENDENCIES
+	];
+};
 const isQueryV5 = (packageJson, queryClient) => {
+	if (queryClient === "angular-query") return true;
 	const version = getPackageByQueryClient(packageJson, queryClient);
 	if (!version) return false;
 	const withoutRc = version.split("-")[0];
@@ -543,12 +759,14 @@ const isQueryV6 = (packageJson, queryClient) => {
 	return compareVersions(withoutRc, "6.0.0");
 };
 const isQueryV5WithDataTagError = (packageJson, queryClient) => {
+	if (queryClient === "angular-query") return true;
 	const version = getPackageByQueryClient(packageJson, queryClient);
 	if (!version) return false;
 	const withoutRc = version.split("-")[0];
 	return compareVersions(withoutRc, "5.62.0");
 };
 const isQueryV5WithInfiniteQueryOptionsError = (packageJson, queryClient) => {
+	if (queryClient === "angular-query") return true;
 	const version = getPackageByQueryClient(packageJson, queryClient);
 	if (!version) return false;
 	const withoutRc = version.split("-")[0];
@@ -559,8 +777,13 @@ const getPackageByQueryClient = (packageJson, queryClient) => {
 		case "react-query": return packageJson?.dependencies?.["@tanstack/react-query"] ?? packageJson?.devDependencies?.["@tanstack/react-query"] ?? packageJson?.peerDependencies?.["@tanstack/react-query"];
 		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",
@@ -570,19 +793,19 @@ 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);
 };
-const getQueryOptionsDefinition = ({ operationName, mutator, definitions, type, hasSvelteQueryV4, hasQueryV5, hasQueryV5WithInfiniteQueryOptionsError, queryParams, queryParam, isReturnType, initialData }) => {
+const getQueryOptionsDefinition = ({ operationName, mutator, definitions, type, hasSvelteQueryV4, hasQueryV5, hasQueryV5WithInfiniteQueryOptionsError, queryParams, queryParam, isReturnType, initialData, isAngularClient }) => {
 	const isMutatorHook = mutator?.isHook;
-	const prefix = hasSvelteQueryV4 ? "Create" : "Use";
+	const prefix = !hasSvelteQueryV4 && !isAngularClient ? "Use" : "Create";
 	const partialOptions = !isReturnType && hasQueryV5;
 	if (type) {
 		const funcReturnType = `Awaited<ReturnType<${isMutatorHook ? `ReturnType<typeof use${pascal(operationName)}Hook>` : `typeof ${operationName}`}>>`;
@@ -593,12 +816,12 @@ 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>`;
 };
-const generateQueryArguments = ({ operationName, definitions, mutator, isRequestOptions, type, hasSvelteQueryV4, hasQueryV5, hasQueryV5WithInfiniteQueryOptionsError, queryParams, queryParam, initialData, httpClient }) => {
+const generateQueryArguments = ({ operationName, definitions, mutator, isRequestOptions, type, hasSvelteQueryV4, hasQueryV5, hasQueryV5WithInfiniteQueryOptionsError, queryParams, queryParam, initialData, httpClient, isAngularClient }) => {
 	const definition = getQueryOptionsDefinition({
 		operationName,
 		mutator,
@@ -610,15 +833,25 @@ const generateQueryArguments = ({ operationName, definitions, mutator, isRequest
 		queryParams,
 		queryParam,
 		isReturnType: false,
-		initialData
+		initialData,
+		isAngularClient
 	});
 	if (!isRequestOptions) return `${type ? "queryOptions" : "mutationOptions"}${initialData === "defined" ? "" : "?"}: ${definition}`;
 	const requestType = getQueryArgumentsRequestType(httpClient, mutator);
 	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"} }`;
@@ -626,16 +859,27 @@ 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"} }`;
 	}
 };
 const generateMutatorReturnType = ({ outputClient, dataType, variableType }) => {
+	if (outputClient === OutputClient.ANGULAR_QUERY) return `: CreateMutationResult<
+        Awaited<ReturnType<${dataType}>>,
+        TError,
+        ${variableType},
+        TContext
+      >`;
 	if (outputClient === OutputClient.REACT_QUERY) return `: UseMutationResult<
         Awaited<ReturnType<${dataType}>>,
         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}>>,
@@ -659,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";
@@ -683,7 +1075,7 @@ const generatePrefetch = ({ usePrefetch, type, useQuery, useInfinite, operationN
 const generateQueryImplementation = ({ queryOption: { name, queryParam, options, type, queryKeyFnName }, operationName, queryProperties, queryKeyProperties, queryParams, params, props, mutator, queryOptionsMutator, queryKeyMutator, isRequestOptions, response, outputClient, httpClient, isExactOptionalPropertyTypes, hasSignal, route, hasVueQueryV4, hasSvelteQueryV4, hasSvelteQueryV6, hasQueryV5, hasQueryV5WithDataTagError, hasQueryV5WithInfiniteQueryOptionsError, doc, usePrefetch, useQuery, useInfinite, useInvalidate }) => {
 	const queryPropDefinitions = toObjectString(props, "definition");
 	const definedInitialDataQueryPropsDefinitions = toObjectString(props.map((prop) => {
-		const regex = /* @__PURE__ */ new RegExp(`^${prop.name}\\s*\\?:`);
+		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 {
@@ -693,10 +1085,12 @@ const generateQueryImplementation = ({ queryOption: { name, queryParam, options,
 	}), "definition");
 	const queryProps = toObjectString(props, "implementation");
 	const hasInfiniteQueryParam = queryParam && queryParams?.schema.name;
-	const httpFunctionProps = queryParam ? props.map((param) => {
+	const isAngularHttp = isAngular(outputClient) || httpClient === OutputHttpClient.ANGULAR;
+	let httpFunctionProps = queryParam ? props.map((param) => {
 		if (param.type === GetterPropType.NAMED_PATH_PARAMS && !isVue(outputClient)) return param.destructured;
 		return param.name === "params" ? `{...${isVue(outputClient) ? `unref(params)` : "params"}, '${queryParam}': pageParam || ${isVue(outputClient) ? `unref(params)?.['${queryParam}']` : `params?.['${queryParam}']`}}` : param.name;
-	}).join(",") : getHttpFunctionQueryProps(isVue(outputClient), httpClient, queryProperties);
+	}).join(",") : getHttpFunctionQueryProps(isVue(outputClient), httpClient, queryProperties, isAngularHttp);
+	if (queryParam && isAngularHttp) httpFunctionProps = httpFunctionProps ? `http, ${httpFunctionProps}` : "http";
 	const definedInitialDataReturnType = generateQueryReturnType({
 		outputClient,
 		type,
@@ -732,7 +1126,8 @@ const generateQueryImplementation = ({ queryOption: { name, queryParam, options,
 		queryParams,
 		queryParam,
 		initialData: "defined",
-		httpClient
+		httpClient,
+		isAngularClient: isAngular(outputClient)
 	});
 	const undefinedInitialDataQueryArguments = generateQueryArguments({
 		operationName,
@@ -746,7 +1141,8 @@ const generateQueryImplementation = ({ queryOption: { name, queryParam, options,
 		queryParams,
 		queryParam,
 		initialData: "undefined",
-		httpClient
+		httpClient,
+		isAngularClient: isAngular(outputClient)
 	});
 	const queryArguments = generateQueryArguments({
 		operationName,
@@ -759,7 +1155,8 @@ const generateQueryImplementation = ({ queryOption: { name, queryParam, options,
 		hasQueryV5WithInfiniteQueryOptionsError,
 		queryParams,
 		queryParam,
-		httpClient
+		httpClient,
+		isAngularClient: isAngular(outputClient)
 	});
 	const queryOptions = getQueryOptions({
 		isRequestOptions,
@@ -787,7 +1184,8 @@ const generateQueryImplementation = ({ queryOption: { name, queryParam, options,
 		hasQueryV5WithInfiniteQueryOptionsError,
 		queryParams,
 		queryParam,
-		isReturnType: true
+		isReturnType: true,
+		isAngularClient: isAngular(outputClient)
 	});
 	const queryOptionsImp = generateQueryOptions({
 		params,
@@ -798,26 +1196,27 @@ 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}) => {
 
 ${hookOptions}
+${isAngularHttp ? "  const http = inject(HttpClient);" : ""}
 
   const queryKey =  ${queryKeyMutator ? `${queryKeyMutator.name}({ ${queryProperties} }${queryKeyMutator.hasSecondArg ? `, { url: \`${route}\`, queryOptions }` : ""});` : `${hasVueQueryV4 ? "" : "queryOptions?.queryKey ?? "}${queryKeyFnName}(${queryKeyProperties});`}
 
   ${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)) : ""}
 
       ${queryOptionsMutator ? `const customOptions = ${queryOptionsMutator.name}({...queryOptions, queryKey, queryFn}${queryOptionsMutator.hasSecondArg ? `, { ${queryProperties} }` : ""}${queryOptionsMutator.hasThirdArg ? `, { url: \`${route}\` }` : ""});` : ""}
 
-   return  ${queryOptionsMutator ? "customOptions" : `{ queryKey, queryFn, ${queryOptionsImp}}`} as ${queryOptionFnReturnType} ${isVue(outputClient) ? "" : `& { queryKey: ${hasQueryV5 ? `DataTag<QueryKey, TData${hasQueryV5WithDataTagError ? ", TError" : ""}>` : "QueryKey"} }`}
+   return  ${queryOptionsMutator ? "customOptions" : `{ queryKey, queryFn, ${queryOptionsImp}}`} as ${queryOptionFnReturnType} ${isVue(outputClient) || isAngular(outputClient) ? "" : `& { queryKey: ${hasQueryV5 ? `DataTag<QueryKey, TData${hasQueryV5WithDataTagError ? ", TError" : ""}>` : "QueryKey"} }`}
 }`;
-	const operationPrefix = hasSvelteQueryV4 ? "create" : "use";
-	const optionalQueryClientArgument = hasQueryV5 ? ", 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}
@@ -830,7 +1229,7 @@ export function ${queryHookName}<TData = ${TData}, TError = ${errorType}>(\n ${q
 		useInfinite,
 		operationName,
 		mutator,
-		queryProps,
+		queryProps: hasSvelteQueryV6 ? queryProps.replace(":", ": () => ") : queryProps,
 		dataType,
 		errorType,
 		hasSvelteQueryV6,
@@ -851,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} {
-
-  const ${queryOptionsVarName} = ${queryOptionsFnName}(${queryProperties}${queryProperties ? "," : ""}${isRequestOptions ? "options" : "queryOptions"})
+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 ${queryResultVarName} = ${camel(`${operationPrefix}-${type}`)}(${hasSvelteQueryV6 ? `() => ({ ...${queryOptionsVarName}${optionalQueryClientArgument ? ", queryClient" : ""} })` : `${queryOptionsVarName}${optionalQueryClientArgument ? ", queryClient" : ""}`}) as ${returnType};
+  ${hasSvelteQueryV6 ? "" : `const ${queryOptionsVarName} = ${queryOptionsFnName}(${queryProperties}${queryProperties ? "," : ""}${isRequestOptions ? "options" : "queryOptions"})`}
 
-  ${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> => {
@@ -870,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);
@@ -885,14 +1298,25 @@ const generateQueryHook = async ({ queryParams, operationName, body, props: _pro
 	const hasQueryV5WithDataTagError = queryVersion === 5 || isQueryV5WithDataTagError(context.output.packageJson, outputClient);
 	const hasQueryV5WithInfiniteQueryOptionsError = queryVersion === 5 || isQueryV5WithInfiniteQueryOptionsError(context.output.packageJson, outputClient);
 	const httpClient = context.output.httpClient;
+	const isAngularHttp = isAngular(outputClient) || httpClient === OutputHttpClient.ANGULAR;
 	const doc = jsDoc({
 		summary,
 		deprecated
 	});
 	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;
@@ -921,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}`;
 			});
@@ -991,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,
@@ -1015,84 +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
-		});
-		const mutationArguments = generateQueryArguments({
-			operationName,
-			definitions,
-			mutator,
-			isRequestOptions,
 			hasSvelteQueryV4,
-			hasQueryV5,
-			hasQueryV5WithInfiniteQueryOptionsError,
-			httpClient
+			hasSvelteQueryV6,
+			isRequestOptions,
+			httpClient,
+			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)}
-
-      ${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}(${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 = hasSvelteQueryV4 ? "create" : "use";
-		const optionalQueryClientArgument = hasQueryV5 ? ", 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(${hasSvelteQueryV6 ? `() => ({ ...${mutationOptionsVarName}${optionalQueryClientArgument ? ", queryClient" : ""} })` : `${mutationOptionsVarName}${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`}
@@ -1113,7 +1483,9 @@ const generateQuery = async (verbOptions, options, outputClient) => {
 const dependenciesBuilder = {
 	"react-query": getReactQueryDependencies,
 	"vue-query": getVueQueryDependencies,
-	"svelte-query": getSvelteQueryDependencies
+	"svelte-query": getSvelteQueryDependencies,
+	"angular-query": getAngularQueryDependencies,
+	"solid-query": getSolidQueryDependencies
 };
 const builder = ({ type = "react-query", options: queryOptions, output } = {}) => () => {
 	const client = (verbOptions, options, outputClient) => {
@@ -1134,5 +1506,5 @@ const builder = ({ type = "react-query", options: queryOptions, output } = {}) =
 var src_default = builder;
 
 //#endregion
-export { builder, src_default as default, generateQuery, generateQueryHeader, getReactQueryDependencies, getSvelteQueryDependencies, getVueQueryDependencies };
+export { builder, src_default as default, generateQuery, generateQueryHeader, getAngularQueryDependencies, getReactQueryDependencies, getSolidQueryDependencies, getSvelteQueryDependencies, getVueQueryDependencies };
 //# sourceMappingURL=index.mjs.map