@kubb/plugin-vue-query 5.5.1 → 5.5.4

package/dist/index.d.cts

@@ -0,0 +1,427 @@
+import { Exclude, Group, Include, Output, OutputOptions, Override, PluginType, Resolver, ResolverPatch, ast } from "kubb/kit";
+import "@kubb/plugin-zod";
+import "@kubb/plugin-ts";
+import "kubb/jsx";
+//#region ../../internals/client/src/resolveClient.d.ts
+/**
+ * The client selector accepted by a consumer's `client` option. Each calls a registered contract
+ * client plugin.
+ */
+type ClientSelector = 'fetch' | 'axios' | 'client';
+/**
+ * The resolved client strategy stored in a consumer plugin's options: the generated code always
+ * imports and calls a registered contract client plugin's `<op>`. The client runtime lives in
+ * plugin-axios / plugin-fetch, so nothing is bundled by the consumer.
+ */
+type ResolvedContractClient = {
+  kind: 'contract';
+  pluginName: string;
+};
+//#endregion
+//#region ../../internals/tanstack-query/src/types.d.ts
+type ParamsCasing = 'camelcase' | undefined;
+/**
+ * The hook a key is built for. Plain and suspense queries can share a key, but an infinite query
+ * caches `InfiniteData` and must never share one with a plain query.
+ */
+type KeyVariant = 'query' | 'suspenseQuery' | 'infiniteQuery' | 'suspenseInfiniteQuery' | 'mutation';
+/**
+ * Builds query or mutation key segments for an operation node.
+ * Receives `variant` indicating which hook or composable the key is built for.
+ */
+type Transformer = (props: {
+  node: ast.OperationNode;
+  casing: ParamsCasing;
+  variant: KeyVariant;
+}) => Array<unknown>;
+/**
+ * Configures the query side of a TanStack-family plugin: which HTTP methods produce query
+ * hooks and where the query runtime is imported from.
+ */
+type Query = {
+  /**
+   * HTTP methods treated as queries. Operations using these methods produce
+   * `useQuery`-style hooks.
+   *
+   * @default ['GET', 'QUERY']
+   */
+  methods?: Array<string>;
+  /**
+   * Module specifier used in the `import { useQuery } from '...'` statement at
+   * the top of every generated file. Each plugin defaults this to its own runtime
+   * package. Useful for routing through a wrapper that injects a default
+   * `queryClient`.
+   */
+  importPath?: string;
+};
+/**
+ * Configures the mutation side of a TanStack-family plugin: which HTTP methods produce
+ * mutation hooks and where the mutation runtime is imported from.
+ */
+type Mutation = {
+  /**
+   * HTTP methods treated as mutations. Operations using these methods produce
+   * `useMutation`-style hooks.
+   *
+   * @default ['POST', 'PUT', 'PATCH', 'DELETE']
+   */
+  methods?: Array<string>;
+  /**
+   * Module specifier used in the `import { useMutation } from '...'` statement
+   * at the top of every generated file. Each plugin defaults this to its own
+   * runtime package.
+   */
+  importPath?: string;
+};
+type Infinite = {
+  /**
+   * Name of the query parameter that holds the page cursor.
+   *
+   * @default 'id'
+   */
+  queryParam?: string;
+  /**
+   * Path to the cursor field on the response. Leave undefined when the cursor
+   * is not known.
+   *
+   * @deprecated Use `nextParam` and `previousParam` for richer pagination control.
+   */
+  cursorParam?: string | null;
+  /**
+   * Path to the next-page cursor on the response. Supports dot notation
+   * (`'pagination.next.id'`) or array form (`['pagination', 'next', 'id']`).
+   */
+  nextParam?: string | Array<string> | null;
+  /**
+   * Path to the previous-page cursor on the response. Supports dot notation
+   * or array form.
+   */
+  previousParam?: string | Array<string> | null;
+  /**
+   * Initial value for `pageParam` on the first fetch.
+   *
+   * @default 0
+   */
+  initialPageParam?: unknown;
+  /**
+   * Whether `initialPageParam` was explicitly configured rather than defaulted.
+   * When omitted or false, the default previous page threshold remains 1 (legacy 1-based default).
+   */
+  hasExplicitInitialPageParam?: boolean;
+  /**
+   * Source of TanStack Query's `getNextPageParam`, inlined verbatim as a function expression. Use it
+   * when the next page has to be computed rather than read from a field. Takes precedence over
+   * `nextParam` and `cursorParam`.
+   *
+   * Note: Because functions are inlined verbatim into generated code via `.toString()`, they cannot
+   * reference local closures or external variables from the config file.
+   *
+   * @example
+   * `'(lastPage) => (lastPage.hasNext ? lastPage.number + 1 : undefined)'`
+   * // or with definePageParam:
+   * `definePageParam<MyResponse, number>((lastPage) => (lastPage.hasNext ? lastPage.number + 1 : undefined))`
+   */
+  getNextPageParam?: string | PageParamFn | null;
+  /**
+   * Source of TanStack Query's `getPreviousPageParam`, inlined verbatim as a function expression.
+   * Takes precedence over `previousParam` and `cursorParam`.
+   *
+   * Note: Because functions are inlined verbatim into generated code via `.toString()`, they cannot
+   * reference local closures or external variables from the config file.
+   *
+   * @example
+   * `'(firstPage) => (firstPage.number > 0 ? firstPage.number - 1 : undefined)'`
+   * // or with definePageParam:
+   * `definePageParam<MyResponse, number>((firstPage) => (firstPage.number > 0 ? firstPage.number - 1 : undefined))`
+   */
+  getPreviousPageParam?: string | PageParamFn | null;
+};
+type PageParamFn<TPage = any, TParam = any> = (page: TPage, allPages: Array<TPage>, pageParam: TParam, allPageParams: Array<TParam>) => TParam | undefined | null;
+//#endregion
+//#region ../../internals/tanstack-query/src/components/MutationKey.d.ts
+/**
+ * Default `mutationKey` builder. Call it from a custom builder to extend the default key.
+ *
+ * @remarks The returned segments may change between releases. Spread them instead of reading single entries.
+ *
+ * @example
+ * ```ts
+ * mutationKey: (props) => [JSON.stringify(props.node.operationId), ...mutationKeyTransformer(props)]
+ * ```
+ */
+export declare const mutationKeyTransformer: Transformer;
+//#endregion
+//#region ../../internals/tanstack-query/src/components/QueryKey.d.ts
+/**
+ * Default `queryKey` builder. Call it from a custom builder to extend the default key.
+ *
+ * @remarks The returned segments may change between releases. Spread them instead of reading single entries.
+ *
+ * @example
+ * ```ts
+ * queryKey: (props) => [JSON.stringify(props.node.operationId), ...queryKeyTransformer(props)]
+ * ```
+ */
+export declare const queryKeyTransformer: Transformer;
+//#endregion
+//#region ../../internals/tanstack-query/src/utils.d.ts
+/**
+ * Helper to define a typed page param function for `infinite.getNextPageParam` or
+ * `infinite.getPreviousPageParam`. Serializes the function to a string for inlining in generated code.
+ *
+ * Note: Because the function is inlined verbatim into the generated file via `.toString()`,
+ * it must be self-contained and cannot reference local closures or external variables from
+ * the config file.
+ */
+export declare function definePageParam<TPage = any, TParam = any>(fn: PageParamFn<TPage, TParam>): string;
+//#endregion
+//#region src/types.d.ts
+/**
+ * Resolver for Vue Query that provides naming methods for hook functions.
+ */
+type ResolverVueQuery = Resolver & {
+  /**
+   * Names for a query operation: its `useQuery` composable, key helpers, options helper, and the
+   * inline client function it calls.
+   */
+  query: {
+    /**
+     * Resolves a query hook function name.
+     */
+    name(node: ast.OperationNode): string;
+    /**
+     * Resolves the query key helper name.
+     */
+    keyName(node: ast.OperationNode): string;
+    /**
+     * Resolves the query key type name.
+     */
+    keyTypeName(node: ast.OperationNode): string;
+    /**
+     * Resolves the query options helper name.
+     */
+    optionsName(node: ast.OperationNode): string;
+    /**
+     * Resolves the client function name generated inline by query hooks.
+     */
+    clientName(node: ast.OperationNode): string;
+  };
+  /**
+   * Names for an infinite query operation: its `useInfiniteQuery` composable, key helpers, options
+   * helper, and the inline client function it calls.
+   */
+  infiniteQuery: {
+    /**
+     * Resolves an infinite query hook function name.
+     */
+    name(node: ast.OperationNode): string;
+    /**
+     * Resolves the infinite query key helper name.
+     */
+    keyName(node: ast.OperationNode): string;
+    /**
+     * Resolves the infinite query key type name.
+     */
+    keyTypeName(node: ast.OperationNode): string;
+    /**
+     * Resolves the infinite query options helper name.
+     */
+    optionsName(node: ast.OperationNode): string;
+    /**
+     * Resolves the client function name generated inline by infinite query hooks.
+     */
+    clientName(node: ast.OperationNode): string;
+  };
+  /**
+   * Names for a mutation operation: its `useMutation` composable, key helper, and type name.
+   */
+  mutation: {
+    /**
+     * Resolves a mutation hook function name.
+     */
+    name(node: ast.OperationNode): string;
+    /**
+     * Resolves the mutation key helper name.
+     */
+    keyName(node: ast.OperationNode): string;
+    /**
+     * Resolves the mutation type name.
+     */
+    typeName(node: ast.OperationNode): string;
+  };
+};
+/**
+ * Builds the `queryKey` used by each generated query composable. `variant` tells which composable
+ * the key is for, so infinite keys can stay apart from plain ones.
+ *
+ * @note String values are inlined verbatim into generated code. Wrap literal
+ * strings in `JSON.stringify(...)`.
+ */
+type QueryKey = Transformer;
+/**
+ * Builds the `mutationKey` used by each generated mutation composable.
+ *
+ * @note String values are inlined verbatim into generated code. Wrap literal
+ * strings in `JSON.stringify(...)`.
+ */
+type MutationKey = Transformer;
+/**
+ * Where the generated composables are written and how they are exported, plus the optional
+ * `group` strategy. The `group` option organizes `output.mode: 'directory'` output into per-tag or per-path subdirectories.
+ *
+ * @default { path: 'hooks', barrel: { type: 'named' } }
+ */
+type Options = OutputOptions & {
+  /**
+   * Selects the HTTP client the generated composables call. Every client plugin speaks the `RequestResult`
+   * contract, so the composables call a contract `<op>` that takes one grouped `options` object.
+   *
+   * - `'fetch'` / `'axios'` / `'client'` calls the `@kubb/plugin-fetch` / `@kubb/plugin-axios` /
+   *   `@kubb/plugin-client` functions. When a single client plugin is registered it is
+   *   auto-detected, so the string is only needed to disambiguate several client plugins.
+   *
+   * A client plugin must be registered. The composables always call its `<op>`.
+   */
+  client?: ClientSelector;
+  /**
+   * Skip operations matching at least one entry in the list.
+   */
+  exclude?: Array<Exclude>;
+  /**
+   * Restrict generation to operations matching at least one entry in the list.
+   */
+  include?: Array<Include>;
+  /**
+   * Apply a different options object to operations matching a pattern.
+   */
+  override?: Array<Override<ResolvedOptions>>;
+  /**
+   * Enables `useInfiniteQuery` composables for cursor- or page-based pagination.
+   * Pass an object to configure how the cursor is read, or pass `false` to skip.
+   *
+   * @default false
+   */
+  infinite?: Partial<Infinite> | false;
+  /**
+   * Custom `queryKey` builder.
+   */
+  queryKey?: QueryKey;
+  /**
+   * Configures query composables. Set to `false` to skip composable generation
+   * and emit only `queryOptions(...)` helpers.
+   */
+  query?: Partial<Query> | false;
+  /**
+   * Custom `mutationKey` builder.
+   */
+  mutationKey?: MutationKey;
+  /**
+   * Configures mutation composables. Set to `false` to skip mutation generation.
+   */
+  mutation?: Partial<Mutation> | false;
+  /**
+   * Override how composable names and file paths are built.
+   */
+  resolver?: ResolverPatch<ResolverVueQuery>;
+  /**
+   * Set to `true` to also generate `use*` composable functions. By default only the
+   * `queryOptions`, `queryKey`, and `mutationKey` helpers are emitted.
+   *
+   * @default false
+   */
+  hooks?: boolean;
+  /**
+   * Macros applied to each operation node before printing.
+   */
+  macros?: Array<ast.Macro>;
+};
+/**
+ * The resolved client strategy for the generated composables, computed once during setup. The
+ * composables always import and call a registered contract client plugin's `<op>`.
+ */
+type ResolvedClient = ResolvedContractClient;
+type ResolvedOptions = {
+  output: Output;
+  group: Group | null;
+  exclude: NonNullable<Options['exclude']>;
+  include: Options['include'];
+  override: NonNullable<Options['override']>;
+  /**
+   * The resolved contract client the generators import and call.
+   */
+  client: ResolvedClient;
+  /**
+   * Resolved infinite query configuration, or `false` when infinite queries are disabled.
+   */
+  infinite: NonNullable<Infinite> | false;
+  queryKey: QueryKey | null;
+  query: NonNullable<Required<Query>> | false;
+  mutationKey: MutationKey | null;
+  mutation: NonNullable<Required<Mutation>> | false;
+  hooks: boolean;
+  resolver: ResolverVueQuery;
+};
+type PluginVueQuery = PluginType<'plugin-vue-query', Options, ResolvedOptions, ResolverVueQuery>;
+declare global {
+  namespace Kubb {
+    interface PluginRegistry {
+      'plugin-vue-query': PluginVueQuery;
+    }
+  }
+}
+//#endregion
+//#region src/plugin.d.ts
+/**
+ * Canonical plugin name for `@kubb/plugin-vue-query`. Used for driver lookups
+ * and cross-plugin dependency references.
+ */
+export declare const pluginVueQueryName = "plugin-vue-query";
+/**
+ * Generates one TanStack Query composable per OpenAPI operation for Vue's
+ * Composition API. Queries become `useFoo` (and optionally
+ * `useFooInfinite`). Mutations become `useFoo` as well. Each composable
+ * is fully typed end to end.
+ *
+ * @example
+ * ```ts
+ * import { defineConfig } from 'kubb/config'
+ * import { pluginTs } from '@kubb/plugin-ts'
+ * import { pluginVueQuery } from '@kubb/plugin-vue-query'
+ *
+ * export default defineConfig({
+ *   input: './petStore.yaml',
+ *   output: { path: './src/gen' },
+ *   plugins: [
+ *     pluginTs(),
+ *     pluginVueQuery({
+ *       output: { path: './hooks' },
+ *     }),
+ *   ],
+ * })
+ * ```
+ */
+export declare const pluginVueQuery: import("kubb/kit").PluginFactory<PluginVueQuery>;
+//#endregion
+//#region src/resolvers/resolverVueQuery.d.ts
+/**
+ * Default resolver used by `@kubb/plugin-vue-query`. Decides the names and
+ * file paths for every generated TanStack Query composable (`useFoo`,
+ * `useFooInfinite`) and its companion helpers.
+ *
+ * The `default` helpers are supplied by `createResolver`. Functions and files use camelCase;
+ * composables get the `use` prefix. Operation-specific naming is grouped under the `query`,
+ * `infiniteQuery`, and `mutation` namespaces.
+ *
+ * @example Resolve composable and helper names
+ * ```ts
+ * import { resolverVueQuery } from '@kubb/plugin-vue-query'
+ *
+ * resolverVueQuery.query.name(operationNode)        // 'useGetPetById'
+ * resolverVueQuery.query.keyName(operationNode)     // 'getPetByIdQueryKey'
+ * resolverVueQuery.query.optionsName(operationNode) // 'getPetByIdQueryOptions'
+ * ```
+ */
+export declare const resolverVueQuery: ResolverVueQuery;
+//#endregion
+export { type PageParamFn, type PluginVueQuery, type ResolverVueQuery, type Transformer, pluginVueQuery as default };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.ts

@@ -1,8 +1,7 @@
-import { t as __name } from "./rolldown-runtime-C0LytTxp.js";
-import { Diagnostics, Exclude, Group, Include, Output, OutputOptions, Override, PluginType, Resolver, ResolverPatch, ast } from "kubb/kit";
+import { Exclude, Group, Include, Output, OutputOptions, Override, PluginType, Resolver, ResolverPatch, ast } from "kubb/kit";
+import "@kubb/plugin-zod";
 import "@kubb/plugin-ts";
 import "kubb/jsx";
-import "@kubb/plugin-zod";
 //#region ../../internals/client/src/resolveClient.d.ts
 /**
  * The client selector accepted by a consumer's `client` option. Each calls a registered contract
@@ -139,6 +138,32 @@ type Infinite = {
 };
 type PageParamFn<TPage = any, TParam = any> = (page: TPage, allPages: Array<TPage>, pageParam: TParam, allPageParams: Array<TParam>) => TParam | undefined | null;
 //#endregion
+//#region ../../internals/tanstack-query/src/components/MutationKey.d.ts
+/**
+ * Default `mutationKey` builder. Call it from a custom builder to extend the default key.
+ *
+ * @remarks The returned segments may change between releases. Spread them instead of reading single entries.
+ *
+ * @example
+ * ```ts
+ * mutationKey: (props) => [JSON.stringify(props.node.operationId), ...mutationKeyTransformer(props)]
+ * ```
+ */
+export declare const mutationKeyTransformer: Transformer;
+//#endregion
+//#region ../../internals/tanstack-query/src/components/QueryKey.d.ts
+/**
+ * Default `queryKey` builder. Call it from a custom builder to extend the default key.
+ *
+ * @remarks The returned segments may change between releases. Spread them instead of reading single entries.
+ *
+ * @example
+ * ```ts
+ * queryKey: (props) => [JSON.stringify(props.node.operationId), ...queryKeyTransformer(props)]
+ * ```
+ */
+export declare const queryKeyTransformer: Transformer;
+//#endregion
 //#region ../../internals/tanstack-query/src/utils.d.ts
 /**
  * Helper to define a typed page param function for `infinite.getNextPageParam` or
@@ -398,5 +423,5 @@ export declare const pluginVueQuery: import("kubb/kit").PluginFactory<PluginVueQ
  */
 export declare const resolverVueQuery: ResolverVueQuery;
 //#endregion
-export { type PageParamFn, type PluginVueQuery, type ResolverVueQuery, pluginVueQuery as default };
+export { type PageParamFn, type PluginVueQuery, type ResolverVueQuery, type Transformer, pluginVueQuery as default };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,9 +1,9 @@
-import "./rolldown-runtime-C0LytTxp.js";
 import { Diagnostics, Resolver, Url, addGenerator, ast, createResolver, defineExtension, defineGenerator, setMacros, setResolver, useConfig } from "kubb/kit";
 import path from "node:path";
 import { createFunctionParameter, createFunctionParameters, createObjectBindingPattern, createTypeLiteral, functionPrinter, pluginTsName } from "@kubb/plugin-ts";
 import { File, Function, Type, jsxRenderer } from "kubb/jsx";
 import { Fragment, jsx, jsxs } from "kubb/jsx/jsx-runtime";
+//#endregion
 //#region ../../internals/shared/src/operation.ts
 /**
 * Builds the `ResolverFileParams` every operation generator passes to
@@ -315,11 +315,11 @@ function createGroupConfig(group) {
 //#region kubb-extension.json
 var compatibility = {
 	"kubb": ">=5.8.3",
-	"node": ">=22"
+	"node": ">=22.12"
 };
 //#endregion
 //#region package.json
-var version = "5.5.1";
+var version = "5.5.4";
 //#endregion
 //#region ../../internals/tanstack-query/src/components/HookFile.tsx
 /**
@@ -809,6 +809,16 @@ return infiniteQueryOptions<${queryFnDataType}, ${errorType}, InfiniteData<${que
 //#endregion
 //#region ../../internals/tanstack-query/src/components/MutationKey.tsx
 const declarationPrinter$4 = functionPrinter({ mode: "declaration" });
+/**
+* Default `mutationKey` builder. Call it from a custom builder to extend the default key.
+*
+* @remarks The returned segments may change between releases. Spread them instead of reading single entries.
+*
+* @example
+* ```ts
+* mutationKey: (props) => [JSON.stringify(props.node.operationId), ...mutationKeyTransformer(props)]
+* ```
+*/
 const mutationKeyTransformer = ({ node }) => {
 	if (!node.path) return [];
 	return [`{ url: '${Url.toPath(node.path)}' }`];
@@ -900,6 +910,16 @@ function createMutationResolver() {
 //#endregion
 //#region ../../internals/tanstack-query/src/components/QueryKey.tsx
 const declarationPrinter$3 = functionPrinter({ mode: "declaration" });
+/**
+* Default `queryKey` builder. Call it from a custom builder to extend the default key.
+*
+* @remarks The returned segments may change between releases. Spread them instead of reading single entries.
+*
+* @example
+* ```ts
+* queryKey: (props) => [JSON.stringify(props.node.operationId), ...queryKeyTransformer(props)]
+* ```
+*/
 const queryKeyTransformer = ({ node, variant }) => {
 	if (!node.path) return [];
 	const { path, query } = getOperationParameters(node);
@@ -1724,6 +1744,6 @@ const pluginVueQuery = defineExtension({
 	}
 });
 //#endregion
-export { pluginVueQuery as default, pluginVueQuery, definePageParam, pluginVueQueryName, resolverVueQuery };
+export { pluginVueQuery as default, pluginVueQuery, definePageParam, mutationKeyTransformer, pluginVueQueryName, queryKeyTransformer, resolverVueQuery };
 
 //# sourceMappingURL=index.js.map