@kubb/plugin-vue-query/dist/generators-BGPjkJ0B.js

Vue Query hooks generator plugin for Kubb, creating type-safe API client hooks from OpenAPI specifications for Vue.js applications.

import { a as InfiniteQuery, i as InfiniteQueryOptions, n as Mutation, o as QueryOptions, r as MutationKey, s as QueryKey, t as Query } from "./components-CPddkKK9.js";
import path from "node:path";
import { pluginClientName } from "@kubb/plugin-client";
import { pluginTsName } from "@kubb/plugin-ts";
import { pluginZodName } from "@kubb/plugin-zod";
import { getBanner, getFooter } from "@kubb/plugin-oas/utils";
import { File } from "@kubb/react-fabric";
import { Fragment, jsx, jsxs } from "@kubb/react-fabric/jsx-runtime";
import { Client } from "@kubb/plugin-client/components";
import { usePluginManager } from "@kubb/core/hooks";
import { createReactGenerator } from "@kubb/plugin-oas/generators";
import { useOas, useOperationManager } from "@kubb/plugin-oas/hooks";
import { difference } from "remeda";

//#region src/generators/infiniteQueryGenerator.tsx
const infiniteQueryGenerator = createReactGenerator({
	name: "vue-infinite-query",
	Operation({ config, operation, generator, plugin }) {
		const { options, options: { output } } = plugin;
		const pluginManager = usePluginManager();
		const oas = useOas();
		const { getSchemas, getName, getFile } = useOperationManager(generator);
		const isQuery = typeof options.query === "boolean" ? true : options.query?.methods.some((method) => operation.method === method);
		const isMutation = difference(options.mutation ? options.mutation.methods : [], options.query ? options.query.methods : []).some((method) => operation.method === method);
		const isInfinite = isQuery && !!options.infinite;
		const importPath = options.query ? options.query.importPath : "@tanstack/vue-query";
		const query = {
			name: getName(operation, {
				type: "function",
				prefix: "use",
				suffix: "infinite"
			}),
			typeName: getName(operation, { type: "type" }),
			file: getFile(operation, {
				prefix: "use",
				suffix: "infinite"
			})
		};
		const shouldUseClientPlugin = !!pluginManager.getPluginByKey([pluginClientName]) && options.client.clientType !== "class";
		const client = {
			name: shouldUseClientPlugin ? getName(operation, {
				type: "function",
				pluginKey: [pluginClientName]
			}) : getName(operation, {
				type: "function",
				suffix: "infinite"
			}),
			file: getFile(operation, { pluginKey: [pluginClientName] })
		};
		const queryOptions = { name: getName(operation, {
			type: "function",
			suffix: "InfiniteQueryOptions"
		}) };
		const queryKey = {
			name: getName(operation, {
				type: "const",
				suffix: "InfiniteQueryKey"
			}),
			typeName: getName(operation, {
				type: "type",
				suffix: "InfiniteQueryKey"
			})
		};
		const type = {
			file: getFile(operation, { pluginKey: [pluginTsName] }),
			schemas: getSchemas(operation, {
				pluginKey: [pluginTsName],
				type: "type"
			})
		};
		const zod = {
			file: getFile(operation, { pluginKey: [pluginZodName] }),
			schemas: getSchemas(operation, {
				pluginKey: [pluginZodName],
				type: "function"
			})
		};
		if (!isQuery || isMutation || !isInfinite) return null;
		return /* @__PURE__ */ jsxs(File, {
			baseName: query.file.baseName,
			path: query.file.path,
			meta: query.file.meta,
			banner: getBanner({
				oas,
				output,
				config: pluginManager.config
			}),
			footer: getFooter({
				oas,
				output
			}),
			children: [
				options.parser === "zod" && /* @__PURE__ */ jsx(File.Import, {
					name: [zod.schemas.response.name, zod.schemas.request?.name].filter(Boolean),
					root: query.file.path,
					path: zod.file.path
				}),
				options.client.importPath ? /* @__PURE__ */ jsxs(Fragment, { children: [
					/* @__PURE__ */ jsx(File.Import, {
						name: "fetch",
						path: options.client.importPath
					}),
					/* @__PURE__ */ jsx(File.Import, {
						name: ["RequestConfig", "ResponseErrorConfig"],
						path: options.client.importPath,
						isTypeOnly: true
					}),
					options.client.dataReturnType === "full" && /* @__PURE__ */ jsx(File.Import, {
						name: ["ResponseConfig"],
						path: options.client.importPath,
						isTypeOnly: true
					})
				] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
					/* @__PURE__ */ jsx(File.Import, {
						name: ["fetch"],
						root: query.file.path,
						path: path.resolve(config.root, config.output.path, ".kubb/fetch.ts")
					}),
					/* @__PURE__ */ jsx(File.Import, {
						name: ["RequestConfig", "ResponseErrorConfig"],
						root: query.file.path,
						path: path.resolve(config.root, config.output.path, ".kubb/fetch.ts"),
						isTypeOnly: true
					}),
					options.client.dataReturnType === "full" && /* @__PURE__ */ jsx(File.Import, {
						name: ["ResponseConfig"],
						root: query.file.path,
						path: path.resolve(config.root, config.output.path, ".kubb/fetch.ts"),
						isTypeOnly: true
					})
				] }),
				/* @__PURE__ */ jsx(File.Import, {
					name: ["toValue"],
					path: "vue"
				}),
				/* @__PURE__ */ jsx(File.Import, {
					name: ["MaybeRefOrGetter"],
					path: "vue",
					isTypeOnly: true
				}),
				shouldUseClientPlugin && /* @__PURE__ */ jsx(File.Import, {
					name: [client.name],
					root: query.file.path,
					path: client.file.path
				}),
				!shouldUseClientPlugin && /* @__PURE__ */ jsx(File.Import, {
					name: ["buildFormData"],
					root: query.file.path,
					path: path.resolve(config.root, config.output.path, ".kubb/config.ts")
				}),
				/* @__PURE__ */ jsx(File.Import, {
					name: [
						type.schemas.request?.name,
						type.schemas.response.name,
						type.schemas.pathParams?.name,
						type.schemas.queryParams?.name,
						type.schemas.headerParams?.name,
						...type.schemas.statusCodes?.map((item) => item.name) || []
					].filter(Boolean),
					root: query.file.path,
					path: type.file.path,
					isTypeOnly: true
				}),
				/* @__PURE__ */ jsx(QueryKey, {
					name: queryKey.name,
					typeName: queryKey.typeName,
					operation,
					paramsCasing: options.paramsCasing,
					pathParamsType: options.pathParamsType,
					typeSchemas: type.schemas,
					transformer: options.queryKey
				}),
				!shouldUseClientPlugin && /* @__PURE__ */ jsx(Client, {
					name: client.name,
					baseURL: options.client.baseURL,
					operation,
					typeSchemas: type.schemas,
					zodSchemas: zod.schemas,
					dataReturnType: options.client.dataReturnType || "data",
					paramsCasing: options.paramsCasing,
					paramsType: options.paramsType,
					pathParamsType: options.pathParamsType,
					parser: options.parser
				}),
				options.infinite && /* @__PURE__ */ jsxs(Fragment, { children: [
					/* @__PURE__ */ jsx(File.Import, {
						name: ["InfiniteData"],
						isTypeOnly: true,
						path: importPath
					}),
					/* @__PURE__ */ jsx(File.Import, {
						name: ["infiniteQueryOptions"],
						path: importPath
					}),
					/* @__PURE__ */ jsx(InfiniteQueryOptions, {
						name: queryOptions.name,
						clientName: client.name,
						queryKeyName: queryKey.name,
						typeSchemas: type.schemas,
						paramsType: options.paramsType,
						paramsCasing: options.paramsCasing,
						pathParamsType: options.pathParamsType,
						dataReturnType: options.client.dataReturnType || "data",
						cursorParam: options.infinite.cursorParam,
						nextParam: options.infinite.nextParam,
						previousParam: options.infinite.previousParam,
						initialPageParam: options.infinite.initialPageParam,
						queryParam: options.infinite.queryParam
					})
				] }),
				options.infinite && /* @__PURE__ */ jsxs(Fragment, { children: [
					/* @__PURE__ */ jsx(File.Import, {
						name: ["useInfiniteQuery"],
						path: importPath
					}),
					/* @__PURE__ */ jsx(File.Import, {
						name: [
							"QueryKey",
							"QueryClient",
							"UseInfiniteQueryOptions",
							"UseInfiniteQueryReturnType"
						],
						path: importPath,
						isTypeOnly: true
					}),
					/* @__PURE__ */ jsx(InfiniteQuery, {
						name: query.name,
						queryOptionsName: queryOptions.name,
						typeSchemas: type.schemas,
						paramsCasing: options.paramsCasing,
						paramsType: options.paramsType,
						pathParamsType: options.pathParamsType,
						operation,
						dataReturnType: options.client.dataReturnType || "data",
						queryKeyName: queryKey.name,
						queryKeyTypeName: queryKey.typeName
					})
				] })
			]
		});
	}
});

//#endregion
//#region src/generators/mutationGenerator.tsx
const mutationGenerator = createReactGenerator({
	name: "vue-query",
	Operation({ config, operation, generator, plugin }) {
		const { options, options: { output } } = plugin;
		const pluginManager = usePluginManager();
		const oas = useOas();
		const { getSchemas, getName, getFile } = useOperationManager(generator);
		const isQuery = !!options.query && options.query?.methods.some((method) => operation.method === method);
		const isMutation = options.mutation !== false && !isQuery && difference(options.mutation ? options.mutation.methods : [], options.query ? options.query.methods : []).some((method) => operation.method === method);
		const importPath = options.mutation ? options.mutation.importPath : "@tanstack/vue-query";
		const mutation = {
			name: getName(operation, {
				type: "function",
				prefix: "use"
			}),
			typeName: getName(operation, { type: "type" }),
			file: getFile(operation, { prefix: "use" })
		};
		const type = {
			file: getFile(operation, { pluginKey: [pluginTsName] }),
			schemas: getSchemas(operation, {
				pluginKey: [pluginTsName],
				type: "type"
			})
		};
		const zod = {
			file: getFile(operation, { pluginKey: [pluginZodName] }),
			schemas: getSchemas(operation, {
				pluginKey: [pluginZodName],
				type: "function"
			})
		};
		const shouldUseClientPlugin = !!pluginManager.getPluginByKey([pluginClientName]) && options.client.clientType !== "class";
		const client = {
			name: shouldUseClientPlugin ? getName(operation, {
				type: "function",
				pluginKey: [pluginClientName]
			}) : getName(operation, { type: "function" }),
			file: getFile(operation, { pluginKey: [pluginClientName] })
		};
		const mutationKey = {
			name: getName(operation, {
				type: "const",
				suffix: "MutationKey"
			}),
			typeName: getName(operation, {
				type: "type",
				suffix: "MutationKey"
			})
		};
		if (!isMutation) return null;
		return /* @__PURE__ */ jsxs(File, {
			baseName: mutation.file.baseName,
			path: mutation.file.path,
			meta: mutation.file.meta,
			banner: getBanner({
				oas,
				output,
				config: pluginManager.config
			}),
			footer: getFooter({
				oas,
				output
			}),
			children: [
				options.parser === "zod" && /* @__PURE__ */ jsx(File.Import, {
					name: [zod.schemas.response.name, zod.schemas.request?.name].filter(Boolean),
					root: mutation.file.path,
					path: zod.file.path
				}),
				options.client.importPath ? /* @__PURE__ */ jsxs(Fragment, { children: [
					/* @__PURE__ */ jsx(File.Import, {
						name: "fetch",
						path: options.client.importPath
					}),
					/* @__PURE__ */ jsx(File.Import, {
						name: ["RequestConfig", "ResponseErrorConfig"],
						path: options.client.importPath,
						isTypeOnly: true
					}),
					options.client.dataReturnType === "full" && /* @__PURE__ */ jsx(File.Import, {
						name: ["ResponseConfig"],
						path: options.client.importPath,
						isTypeOnly: true
					})
				] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
					/* @__PURE__ */ jsx(File.Import, {
						name: ["fetch"],
						root: mutation.file.path,
						path: path.resolve(config.root, config.output.path, ".kubb/fetch.ts")
					}),
					/* @__PURE__ */ jsx(File.Import, {
						name: ["RequestConfig", "ResponseErrorConfig"],
						root: mutation.file.path,
						path: path.resolve(config.root, config.output.path, ".kubb/fetch.ts"),
						isTypeOnly: true
					}),
					options.client.dataReturnType === "full" && /* @__PURE__ */ jsx(File.Import, {
						name: ["ResponseConfig"],
						root: mutation.file.path,
						path: path.resolve(config.root, config.output.path, ".kubb/fetch.ts"),
						isTypeOnly: true
					})
				] }),
				/* @__PURE__ */ jsx(File.Import, {
					name: ["MaybeRefOrGetter"],
					path: "vue",
					isTypeOnly: true
				}),
				shouldUseClientPlugin && /* @__PURE__ */ jsx(File.Import, {
					name: [client.name],
					root: mutation.file.path,
					path: client.file.path
				}),
				!shouldUseClientPlugin && /* @__PURE__ */ jsx(File.Import, {
					name: ["buildFormData"],
					root: mutation.file.path,
					path: path.resolve(config.root, config.output.path, ".kubb/config.ts")
				}),
				/* @__PURE__ */ jsx(File.Import, {
					name: [
						type.schemas.request?.name,
						type.schemas.response.name,
						type.schemas.pathParams?.name,
						type.schemas.queryParams?.name,
						type.schemas.headerParams?.name,
						...type.schemas.statusCodes?.map((item) => item.name) || []
					].filter(Boolean),
					root: mutation.file.path,
					path: type.file.path,
					isTypeOnly: true
				}),
				/* @__PURE__ */ jsx(MutationKey, {
					name: mutationKey.name,
					typeName: mutationKey.typeName,
					operation,
					pathParamsType: options.pathParamsType,
					paramsCasing: options.paramsCasing,
					typeSchemas: type.schemas,
					transformer: options.mutationKey
				}),
				!shouldUseClientPlugin && /* @__PURE__ */ jsx(Client, {
					name: client.name,
					baseURL: options.client.baseURL,
					operation,
					typeSchemas: type.schemas,
					zodSchemas: zod.schemas,
					dataReturnType: options.client.dataReturnType || "data",
					paramsCasing: options.paramsCasing,
					paramsType: options.paramsType,
					pathParamsType: options.pathParamsType,
					parser: options.parser
				}),
				options.mutation && /* @__PURE__ */ jsxs(Fragment, { children: [
					/* @__PURE__ */ jsx(File.Import, {
						name: ["useMutation"],
						path: importPath
					}),
					/* @__PURE__ */ jsx(File.Import, {
						name: ["MutationObserverOptions", "QueryClient"],
						path: importPath,
						isTypeOnly: true
					}),
					/* @__PURE__ */ jsx(Mutation, {
						name: mutation.name,
						clientName: client.name,
						typeName: mutation.typeName,
						typeSchemas: type.schemas,
						operation,
						paramsCasing: options.paramsCasing,
						dataReturnType: options.client.dataReturnType || "data",
						paramsType: options.paramsType,
						pathParamsType: options.pathParamsType,
						mutationKeyName: mutationKey.name
					})
				] })
			]
		});
	}
});

//#endregion
//#region src/generators/queryGenerator.tsx
const queryGenerator = createReactGenerator({
	name: "vue-query",
	Operation({ config, operation, generator, plugin }) {
		const { options, options: { output } } = plugin;
		const pluginManager = usePluginManager();
		const oas = useOas();
		const { getSchemas, getName, getFile } = useOperationManager(generator);
		const isQuery = typeof options.query === "boolean" ? true : options.query?.methods.some((method) => operation.method === method);
		const isMutation = difference(options.mutation ? options.mutation.methods : [], options.query ? options.query.methods : []).some((method) => operation.method === method);
		const importPath = options.query ? options.query.importPath : "@tanstack/vue-query";
		const query = {
			name: getName(operation, {
				type: "function",
				prefix: "use"
			}),
			typeName: getName(operation, { type: "type" }),
			file: getFile(operation, { prefix: "use" })
		};
		const shouldUseClientPlugin = !!pluginManager.getPluginByKey([pluginClientName]) && options.client.clientType !== "class";
		const client = {
			name: shouldUseClientPlugin ? getName(operation, {
				type: "function",
				pluginKey: [pluginClientName]
			}) : getName(operation, { type: "function" }),
			file: getFile(operation, { pluginKey: [pluginClientName] })
		};
		const queryOptions = { name: getName(operation, {
			type: "function",
			suffix: "QueryOptions"
		}) };
		const queryKey = {
			name: getName(operation, {
				type: "const",
				suffix: "QueryKey"
			}),
			typeName: getName(operation, {
				type: "type",
				suffix: "QueryKey"
			})
		};
		const type = {
			file: getFile(operation, { pluginKey: [pluginTsName] }),
			schemas: getSchemas(operation, {
				pluginKey: [pluginTsName],
				type: "type"
			})
		};
		const zod = {
			file: getFile(operation, { pluginKey: [pluginZodName] }),
			schemas: getSchemas(operation, {
				pluginKey: [pluginZodName],
				type: "function"
			})
		};
		if (!isQuery || isMutation) return null;
		return /* @__PURE__ */ jsxs(File, {
			baseName: query.file.baseName,
			path: query.file.path,
			meta: query.file.meta,
			banner: getBanner({
				oas,
				output,
				config: pluginManager.config
			}),
			footer: getFooter({
				oas,
				output
			}),
			children: [
				options.parser === "zod" && /* @__PURE__ */ jsx(File.Import, {
					name: [zod.schemas.response.name, zod.schemas.request?.name].filter(Boolean),
					root: query.file.path,
					path: zod.file.path
				}),
				options.client.importPath ? /* @__PURE__ */ jsxs(Fragment, { children: [
					/* @__PURE__ */ jsx(File.Import, {
						name: "fetch",
						path: options.client.importPath
					}),
					/* @__PURE__ */ jsx(File.Import, {
						name: ["RequestConfig", "ResponseErrorConfig"],
						path: options.client.importPath,
						isTypeOnly: true
					}),
					options.client.dataReturnType === "full" && /* @__PURE__ */ jsx(File.Import, {
						name: ["ResponseConfig"],
						path: options.client.importPath,
						isTypeOnly: true
					})
				] }) : /* @__PURE__ */ jsxs(Fragment, { children: [
					/* @__PURE__ */ jsx(File.Import, {
						name: ["fetch"],
						root: query.file.path,
						path: path.resolve(config.root, config.output.path, ".kubb/fetch.ts")
					}),
					/* @__PURE__ */ jsx(File.Import, {
						name: ["RequestConfig", "ResponseErrorConfig"],
						root: query.file.path,
						path: path.resolve(config.root, config.output.path, ".kubb/fetch.ts"),
						isTypeOnly: true
					}),
					options.client.dataReturnType === "full" && /* @__PURE__ */ jsx(File.Import, {
						name: ["ResponseConfig"],
						root: query.file.path,
						path: path.resolve(config.root, config.output.path, ".kubb/fetch.ts"),
						isTypeOnly: true
					})
				] }),
				/* @__PURE__ */ jsx(File.Import, {
					name: ["toValue"],
					path: "vue"
				}),
				/* @__PURE__ */ jsx(File.Import, {
					name: ["MaybeRefOrGetter"],
					path: "vue",
					isTypeOnly: true
				}),
				shouldUseClientPlugin && /* @__PURE__ */ jsx(File.Import, {
					name: [client.name],
					root: query.file.path,
					path: client.file.path
				}),
				!shouldUseClientPlugin && /* @__PURE__ */ jsx(File.Import, {
					name: ["buildFormData"],
					root: query.file.path,
					path: path.resolve(config.root, config.output.path, ".kubb/config.ts")
				}),
				/* @__PURE__ */ jsx(File.Import, {
					name: [
						type.schemas.request?.name,
						type.schemas.response.name,
						type.schemas.pathParams?.name,
						type.schemas.queryParams?.name,
						type.schemas.headerParams?.name,
						...type.schemas.statusCodes?.map((item) => item.name) || []
					].filter(Boolean),
					root: query.file.path,
					path: type.file.path,
					isTypeOnly: true
				}),
				/* @__PURE__ */ jsx(QueryKey, {
					name: queryKey.name,
					typeName: queryKey.typeName,
					operation,
					paramsCasing: options.paramsCasing,
					pathParamsType: options.pathParamsType,
					typeSchemas: type.schemas,
					transformer: options.queryKey
				}),
				!shouldUseClientPlugin && /* @__PURE__ */ jsx(Client, {
					name: client.name,
					baseURL: options.client.baseURL,
					operation,
					typeSchemas: type.schemas,
					zodSchemas: zod.schemas,
					dataReturnType: options.client.dataReturnType || "data",
					paramsCasing: options.paramsCasing,
					paramsType: options.paramsType,
					pathParamsType: options.pathParamsType,
					parser: options.parser
				}),
				/* @__PURE__ */ jsx(File.Import, {
					name: ["queryOptions"],
					path: importPath
				}),
				/* @__PURE__ */ jsx(QueryOptions, {
					name: queryOptions.name,
					clientName: client.name,
					queryKeyName: queryKey.name,
					paramsCasing: options.paramsCasing,
					typeSchemas: type.schemas,
					paramsType: options.paramsType,
					pathParamsType: options.pathParamsType,
					dataReturnType: options.client.dataReturnType || "data"
				}),
				options.query && /* @__PURE__ */ jsxs(Fragment, { children: [
					/* @__PURE__ */ jsx(File.Import, {
						name: ["useQuery"],
						path: importPath
					}),
					/* @__PURE__ */ jsx(File.Import, {
						name: [
							"QueryKey",
							"QueryClient",
							"UseQueryOptions",
							"UseQueryReturnType"
						],
						path: importPath,
						isTypeOnly: true
					}),
					/* @__PURE__ */ jsx(Query, {
						name: query.name,
						queryOptionsName: queryOptions.name,
						typeSchemas: type.schemas,
						paramsCasing: options.paramsCasing,
						paramsType: options.paramsType,
						pathParamsType: options.pathParamsType,
						operation,
						dataReturnType: options.client.dataReturnType || "data",
						queryKeyName: queryKey.name,
						queryKeyTypeName: queryKey.typeName
					})
				] })
			]
		});
	}
});

//#endregion
export { mutationGenerator as n, infiniteQueryGenerator as r, queryGenerator as t };
//# sourceMappingURL=generators-BGPjkJ0B.js.map