@kubb/plugin-react-query 5.0.0-alpha.9 → 5.0.0-beta.100

package/dist/index.d.ts

@@ -1,10 +1,498 @@
-import { t as __name } from "./chunk--u3MIqq1.js";
-import { n as Options, r as PluginReactQuery } from "./types-D5S7Ny9r.js";
-import * as _kubb_core0 from "@kubb/core";
-
+import { t as __name } from "./rolldown-runtime-C0LytTxp.js";
+import { Exclude, Group, Include, Output, OutputOptions, Override, PluginFactoryOptions, Resolver, ResolverPatch, ast } from "kubb/kit";
+import "@kubb/plugin-ts";
+import "kubb/jsx";
+import "@kubb/plugin-zod";
+//#region ../../internals/client/src/resolveClient.d.ts
+/**
+ * Resolves which client plugin a consumer (react-query, vue-query, swr, mcp) should call for an
+ * operation, shared so the selection rules and diagnostics stay in one place.
+ *
+ * Every client runtime lives in a dedicated client plugin, so a consumer always calls a registered
+ * contract client plugin (plugin-fetch or plugin-axios) and never emits its own inline client:
+ *
+ * - `contract` — a registered contract client plugin owns the `<op>` functions and the consumer
+ *   imports and calls them.
+ * - `error` — no client plugin is registered, several are registered without a selector, or the
+ *   requested one is missing.
+ *
+ * The `client` string selects explicitly (`'fetch'` / `'axios'`); when it is unset a lone registered
+ * contract client plugin is picked up automatically.
+ */
+/**
+ * The client selector accepted by a consumer's `client` option. Both call a registered contract
+ * client plugin.
+ */
+type ClientSelector = 'fetch' | 'axios';
+/**
+ * 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;
+type Transformer = (props: {
+  node: ast.OperationNode;
+  casing: ParamsCasing;
+}) => 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']
+   */
+  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;
+};
+//#endregion
+//#region src/types.d.ts
+/**
+ * The concrete resolver type for `@kubb/plugin-react-query`.
+ * Extends the base `Resolver` (which provides `default` naming and option helpers, the top-level
+ * `name` casing, and the `file` builder) with plugin-specific naming namespaces for the generated
+ * `useQuery`, `useSuspenseQuery`, `useInfiniteQuery`, `useSuspenseInfiniteQuery`, and `useMutation`
+ * hooks and their companion helpers.
+ */
+type ResolverReactQuery = Resolver & {
+  /**
+   * Naming for the generated `useQuery` hook and its companion helpers.
+   */
+  query: {
+    /**
+     * Resolves a query hook function name.
+     *
+     * @example Query hook names
+     * `resolver.query.name(node) // → 'useGetPetById'`
+     */
+    name(node: ast.OperationNode): string;
+    /**
+     * Resolves the query options helper name.
+     *
+     * @example Query options helper names
+     * `resolver.query.optionsName(node) // → 'getPetByIdQueryOptions'`
+     */
+    optionsName(node: ast.OperationNode): string;
+    /**
+     * Resolves the query key helper name.
+     *
+     * @example Query key helper names
+     * `resolver.query.keyName(node) // → 'getPetByIdQueryKey'`
+     */
+    keyName(node: ast.OperationNode): string;
+    /**
+     * Resolves the query key type name.
+     *
+     * @example Query key type names
+     * `resolver.query.keyTypeName(node) // → 'GetPetByIdQueryKey'`
+     */
+    keyTypeName(node: ast.OperationNode): string;
+    /**
+     * Resolves the client function name generated inline by query hooks.
+     *
+     * @example Client function names
+     * `resolver.query.clientName(node) // → 'getPetById'`
+     */
+    clientName(node: ast.OperationNode): string;
+  };
+  /**
+   * Naming for the generated `useSuspenseQuery` hook and its companion helpers.
+   */
+  suspenseQuery: {
+    /**
+     * Resolves a suspense query hook function name.
+     *
+     * @example Suspense query hook names
+     * `resolver.suspenseQuery.name(node) // → 'useGetPetByIdSuspense'`
+     */
+    name(node: ast.OperationNode): string;
+    /**
+     * Resolves the suspense query options helper name.
+     */
+    optionsName(node: ast.OperationNode): string;
+    /**
+     * Resolves the suspense query key helper name.
+     */
+    keyName(node: ast.OperationNode): string;
+    /**
+     * Resolves the suspense query key type name.
+     */
+    keyTypeName(node: ast.OperationNode): string;
+    /**
+     * Resolves the client function name generated inline by suspense query hooks.
+     */
+    clientName(node: ast.OperationNode): string;
+  };
+  /**
+   * Naming for the generated `useInfiniteQuery` hook and its companion helpers.
+   */
+  infiniteQuery: {
+    /**
+     * Resolves an infinite query hook function name.
+     *
+     * @example Infinite query hook names
+     * `resolver.infiniteQuery.name(node) // → 'useGetPetByIdInfinite'`
+     */
+    name(node: ast.OperationNode): string;
+    /**
+     * Resolves the infinite query options helper name.
+     */
+    optionsName(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 client function name generated inline by infinite query hooks.
+     */
+    clientName(node: ast.OperationNode): string;
+  };
+  /**
+   * Naming for the generated `useSuspenseInfiniteQuery` hook and its companion helpers.
+   */
+  suspenseInfiniteQuery: {
+    /**
+     * Resolves a suspense infinite query hook function name.
+     *
+     * @example Suspense infinite query hook names
+     * `resolver.suspenseInfiniteQuery.name(node) // → 'useGetPetByIdSuspenseInfinite'`
+     */
+    name(node: ast.OperationNode): string;
+    /**
+     * Resolves the suspense infinite query options helper name.
+     */
+    optionsName(node: ast.OperationNode): string;
+    /**
+     * Resolves the suspense infinite query key helper name.
+     */
+    keyName(node: ast.OperationNode): string;
+    /**
+     * Resolves the suspense infinite query key type name.
+     */
+    keyTypeName(node: ast.OperationNode): string;
+    /**
+     * Resolves the client function name generated inline by suspense infinite query hooks.
+     */
+    clientName(node: ast.OperationNode): string;
+  };
+  /**
+   * Naming for the generated `useMutation` hook and its companion helpers.
+   */
+  mutation: {
+    /**
+     * Resolves a mutation hook function name.
+     *
+     * @example Mutation hook names
+     * `resolver.mutation.name(node) // → 'useUpdatePet'`
+     */
+    name(node: ast.OperationNode): string;
+    /**
+     * Resolves the mutation options helper name.
+     */
+    optionsName(node: ast.OperationNode): string;
+    /**
+     * Resolves the mutation key helper name.
+     */
+    keyName(node: ast.OperationNode): string;
+    /**
+     * Resolves the mutation type name.
+     *
+     * @example Mutation type names
+     * `resolver.mutation.typeName(node) // → 'UpdatePet'`
+     */
+    typeName(node: ast.OperationNode): string;
+  };
+  /**
+   * Naming for the generated custom hook options file.
+   */
+  hook: {
+    /**
+     * Resolves the generated custom hook options map type name.
+     */
+    optionsName(): string;
+    /**
+     * Resolves the helper function name used inside the custom hook options file.
+     */
+    customOptionsName(): string;
+  };
+};
+type Suspense = object;
+/**
+ * Builds the `queryKey` used by each generated query hook.
+ *
+ * @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 hook.
+ *
+ * @note String values are inlined verbatim into generated code. Wrap literal
+ * strings in `JSON.stringify(...)`.
+ */
+type MutationKey = Transformer;
+type CustomOptions = {
+  /**
+   * Module specifier of your custom-options hook. Imported as a named import,
+   * `import { ${name} } from '${importPath}'`.
+   */
+  importPath: string;
+  /**
+   * Exported function name of your custom-options hook.
+   *
+   * @default 'useCustomHookOptions'
+   */
+  name?: string;
+};
+/**
+ * Where the generated hooks 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 hooks call. Every client plugin speaks the `RequestResult`
+   * contract, so the hooks call a contract `<op>` that takes one grouped `options` object.
+   *
+   * `'fetch'` / `'axios'` calls the `@kubb/plugin-fetch` / `@kubb/plugin-axios` functions. When a
+   * single client plugin (plugin-fetch or plugin-axios) is registered it is
+   * auto-detected, so the string is only needed to disambiguate several client plugins.
+   *
+   * A client plugin must be registered. The hooks 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` hooks 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;
+  /**
+   * Adds `useSuspenseQuery` hooks alongside the regular `useQuery` ones.
+   * Pass an empty object (`{}`) to enable. TanStack Query v5+ only.
+   *
+   * @default false
+   */
+  suspense?: Partial<Suspense> | false;
+  /**
+   * Custom `queryKey` builder. Use to add a version namespace, swap to
+   * operation IDs, or shape keys to match an existing invalidation strategy.
+   */
+  queryKey?: QueryKey;
+  /**
+   * Configures query hooks. Set to `false` to skip generating hooks entirely
+   * and emit only `queryOptions(...)` helpers.
+   */
+  query?: Partial<Query> | false;
+  /**
+   * Custom `mutationKey` builder. Useful when you batch invalidations or read
+   * mutation state via `useMutationState`.
+   */
+  mutationKey?: MutationKey;
+  /**
+   * Configures mutation hooks. Set to `false` to skip mutation generation.
+   */
+  mutation?: Partial<Mutation> | false;
+  /**
+   * Wires every generated hook through a user-supplied function that returns
+   * extra options (`onSuccess`, `onError`, `select`, ...). Also emits a
+   * `HookOptions` type so the wrapper stays in sync with generated hooks.
+   */
+  customOptions?: CustomOptions;
+  /**
+   * Override how hook names and file paths are built. Methods you omit fall
+   * back to the default `resolverReactQuery`.
+   */
+  resolver?: ResolverPatch<ResolverReactQuery>;
+  /**
+   * Set to `false` to skip generating `use*` hook functions. `queryOptions`,
+   * `mutationOptions`, `queryKey`, and `mutationKey` helpers are still emitted.
+   * The resulting output uses only `@tanstack/react-query` factory imports
+   * (`queryOptions`, `infiniteQueryOptions`, `mutationOptions`) that are
+   * adapter-portable across React, Vue, Solid, and Svelte.
+   *
+   * @default false
+   */
+  hooks?: boolean;
+  /**
+   * Macros applied to each operation node before printing.
+   */
+  macros?: Array<ast.Macro>;
+};
+/**
+ * The resolved client strategy for the generated hooks, computed once during setup. The hooks 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;
+  suspense: Suspense | false;
+  queryKey: QueryKey | null;
+  query: NonNullable<Required<Query>> | false;
+  mutationKey: MutationKey | null;
+  mutation: NonNullable<Required<Mutation>> | false;
+  customOptions: NonNullable<Required<CustomOptions>> | null;
+  hooks: boolean;
+  resolver: ResolverReactQuery;
+};
+type PluginReactQuery = PluginFactoryOptions<'plugin-react-query', Options, ResolvedOptions, ResolverReactQuery>;
+declare global {
+  namespace Kubb {
+    interface PluginRegistry {
+      'plugin-react-query': PluginReactQuery;
+    }
+  }
+}
+//#endregion
 //#region src/plugin.d.ts
+/**
+ * Canonical plugin name for `@kubb/plugin-react-query`. Used for driver lookups
+ * and cross-plugin dependency references.
+ */
 declare const pluginReactQueryName = "plugin-react-query";
-declare const pluginReactQuery: (options?: Options | undefined) => _kubb_core0.UserPluginWithLifeCycle<PluginReactQuery>;
+/**
+ * Generates one TanStack Query hook per OpenAPI operation for React. Queries
+ * become `useFoo`, with `useFooSuspense` and `useFooInfinite` variants.
+ * Mutations become `useFoo`. Each hook is fully typed: query keys, input
+ * variables, response data, and error shape all come from the spec.
+ *
+ * @example
+ * ```ts
+ * import { defineConfig } from 'kubb/config'
+ * import { pluginTs } from '@kubb/plugin-ts'
+ * import { pluginReactQuery } from '@kubb/plugin-react-query'
+ *
+ * export default defineConfig({
+ *   input: './petStore.yaml',
+ *   output: { path: './src/gen' },
+ *   plugins: [
+ *     pluginTs(),
+ *     pluginReactQuery({
+ *       output: { path: './hooks' },
+ *       suspense: {},
+ *     }),
+ *   ],
+ * })
+ * ```
+ */
+declare const pluginReactQuery: (options?: Options | undefined) => import("kubb/kit").Plugin<PluginReactQuery>;
+//#endregion
+//#region src/resolvers/resolverReactQuery.d.ts
+/**
+ * Default resolver used by `@kubb/plugin-react-query`. Decides the names and
+ * file paths for every generated TanStack Query hook (`useFoo`,
+ * `useFooSuspense`, `useFooInfinite`, ...) and its companion helpers
+ * (`fooQueryKey`, `fooQueryOptions`).
+ *
+ * Functions and files use the built-in camelCase casing; hooks get the `use`
+ * prefix; suspense and infinite variants are suffixed with `Suspense`/`Infinite`.
+ *
+ * @example Resolve hook and helper names
+ * ```ts
+ * import { resolverReactQuery } from '@kubb/plugin-react-query'
+ *
+ * resolverReactQuery.query.name(operationNode)       // 'useGetPetById'
+ * resolverReactQuery.mutation.name(operationNode)    // 'useUpdatePet'
+ * resolverReactQuery.query.keyName(operationNode)     // 'getPetByIdQueryKey'
+ * resolverReactQuery.query.optionsName(operationNode) // 'getPetByIdQueryOptions'
+ * ```
+ */
+declare const resolverReactQuery: ResolverReactQuery;
 //#endregion
-export { type PluginReactQuery, pluginReactQuery, pluginReactQueryName };
+export { type PluginReactQuery, type ResolverReactQuery, pluginReactQuery as default, pluginReactQuery, pluginReactQueryName, resolverReactQuery };
 //# sourceMappingURL=index.d.ts.map