@kubb/plugin-swr 5.4.1 → 5.4.4

package/dist/index.d.cts

@@ -0,0 +1,317 @@
+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>;
+//#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 src/types.d.ts
+/**
+ * The concrete resolver type for `@kubb/plugin-swr`.
+ * 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
+ * `useSWR` and `useSWRMutation` hooks and their companion helpers.
+ */
+type ResolverSwr = Resolver & {
+  /**
+   * Naming for the generated `useSWR` 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 `useSWRMutation` 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 key helper name.
+     *
+     * @example Mutation key helper names
+     * `resolver.mutation.keyName(node) // → 'updatePetMutationKey'`
+     */
+    keyName(node: ast.OperationNode): string;
+    /**
+     * Resolves the mutation key type name.
+     *
+     * @example Mutation key type names
+     * `resolver.mutation.keyTypeName(node) // → 'UpdatePetMutationKey'`
+     */
+    keyTypeName(node: ast.OperationNode): string;
+    /**
+     * Resolves the mutation argument type name emitted alongside the mutation hook.
+     *
+     * @example Mutation argument type names
+     * `resolver.mutation.argTypeName(node) // → 'UpdatePetMutationArg'`
+     */
+    argTypeName(node: ast.OperationNode): string;
+  };
+};
+/**
+ * Customize the queryKey.
+ */
+type QueryKey = Transformer;
+/**
+ * Customize the mutationKey.
+ */
+type MutationKey = Transformer;
+type Query = {
+  /**
+   * HTTP methods to use for queries.
+   *
+   * @default ['GET', 'QUERY']
+   */
+  methods?: Array<string>;
+  /**
+   * Path to the useSWR hook for useSWR functionality.
+   * Used as `import useSWR from '${importPath}'`.
+   * Accepts relative and absolute paths.
+   * Path is used as-is. Relative paths are based on the generated file location.
+   * @default 'swr'
+   */
+  importPath?: string;
+};
+type Mutation = {
+  /**
+   * HTTP methods to use for mutations.
+   *
+   * @default ['POST', 'PUT', 'PATCH', 'DELETE']
+   */
+  methods?: Array<string>;
+  /**
+   * Path to the useSWRMutation hook for useSWRMutation functionality.
+   * Used as `import useSWRMutation from '${importPath}'`.
+   * Accepts relative and absolute paths.
+   * Path is used as-is. Relative paths are based on the generated file location.
+   * @default 'swr/mutation'
+   */
+  importPath?: string;
+};
+/**
+ * Where the generated SWR 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'` / `'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 hooks always call its `<op>`.
+   */
+  client?: ClientSelector;
+  /**
+   * Tags, operations, or paths to exclude from generation.
+   */
+  exclude?: Array<Exclude>;
+  /**
+   * Tags, operations, or paths to include in generation.
+   */
+  include?: Array<Include>;
+  /**
+   * Override options for specific tags, operations, or paths.
+   */
+  override?: Array<Override<ResolvedOptions>>;
+  /**
+   * Custom `queryKey` builder. Use to add a version namespace, swap to
+   * operation IDs, or shape keys to match an existing invalidation strategy.
+   */
+  queryKey?: QueryKey;
+  /**
+   * Configure useSWR behavior.
+   */
+  query?: Partial<Query> | false;
+  /**
+   * Custom `mutationKey` builder. Useful when you match keys from SWR's
+   * global `mutate` for cache updates.
+   */
+  mutationKey?: MutationKey;
+  /**
+   * Configure useSWRMutation behavior.
+   */
+  mutation?: Partial<Mutation> | false;
+  /**
+   * Override naming conventions for function names and types.
+   */
+  resolver?: ResolverPatch<ResolverSwr>;
+  /**
+   * Macros that rewrite generated nodes before printing.
+   */
+  macros?: Array<ast.Macro>;
+};
+type ResolvedOptions = {
+  output: Output;
+  group: Group | undefined;
+  exclude: NonNullable<Options['exclude']>;
+  include: Options['include'];
+  override: NonNullable<Options['override']>;
+  /**
+   * The resolved contract client the generators import and call.
+   */
+  client: ResolvedContractClient;
+  queryKey: QueryKey | undefined;
+  query: NonNullable<Required<Query>> | false;
+  mutationKey: MutationKey | undefined;
+  mutation: NonNullable<Required<Mutation>> | false;
+  resolver: ResolverSwr;
+};
+type PluginSwr = PluginType<'plugin-swr', Options, ResolvedOptions, ResolverSwr>;
+declare global {
+  namespace Kubb {
+    interface PluginRegistry {
+      'plugin-swr': PluginSwr;
+    }
+  }
+}
+//#endregion
+//#region src/plugin.d.ts
+/**
+ * Canonical plugin name for `@kubb/plugin-swr`. Used for driver lookups and cross-plugin
+ * dependency references.
+ */
+export declare const pluginSwrName = "plugin-swr";
+/**
+ * Generates SWR hooks from OpenAPI operations. Read operations become `useFoo` hooks built on
+ * `useSWR` and write operations become `useFoo` hooks built on `useSWRMutation`, wrapping the
+ * client functions from `@kubb/plugin-axios` or `@kubb/plugin-fetch`.
+ *
+ * @example
+ * ```ts
+ * import { defineConfig } from 'kubb/config'
+ * import { pluginTs } from '@kubb/plugin-ts'
+ * import { pluginSwr } from '@kubb/plugin-swr'
+ *
+ * export default defineConfig({
+ *   input: './petStore.yaml',
+ *   output: { path: './src/gen' },
+ *   plugins: [
+ *     pluginTs(),
+ *     pluginSwr({ output: { path: './hooks' } }),
+ *   ],
+ * })
+ * ```
+ */
+export declare const pluginSwr: import("kubb/kit").PluginFactory<PluginSwr>;
+//#endregion
+//#region src/resolvers/resolverSwr.d.ts
+/**
+ * Default resolver used by `@kubb/plugin-swr`. Decides the names and file paths for every generated
+ * SWR hook (`useFoo`, `useFooMutation`) and its companion helpers (`fooQueryKey`, `fooQueryOptions`,
+ * `fooMutationKey`).
+ *
+ * Functions and files use the built-in camelCase casing; hooks get the `use` prefix.
+ *
+ * @example Resolve hook and helper names
+ * ```ts
+ * import { resolverSwr } from '@kubb/plugin-swr'
+ *
+ * resolverSwr.query.name(operationNode)       // 'useGetPetById'
+ * resolverSwr.query.keyName(operationNode)     // 'getPetByIdQueryKey'
+ * resolverSwr.mutation.name(operationNode)     // 'useUpdatePet'
+ * ```
+ */
+export declare const resolverSwr: ResolverSwr;
+//#endregion
+export { type PluginSwr, type ResolverSwr, type Transformer, pluginSwr as default };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.ts

@@ -1,7 +1,6 @@
-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 "@kubb/plugin-ts";
+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
 /**
@@ -36,6 +35,32 @@ type Transformer = (props: {
   variant: KeyVariant;
 }) => Array<unknown>;
 //#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 src/types.d.ts
 /**
  * The concrete resolver type for `@kubb/plugin-swr`.

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
@@ -298,11 +298,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.4.1";
+var version = "5.4.4";
 //#endregion
 //#region ../../internals/client/src/resolveClient.ts
 /**
@@ -785,6 +785,16 @@ function buildHookParams(node, options) {
 //#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)}' }`];
@@ -876,6 +886,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);
@@ -1326,6 +1346,6 @@ const pluginSwr = defineExtension({
 	}
 });
 //#endregion
-export { pluginSwr as default, pluginSwr, pluginSwrName, resolverSwr };
+export { pluginSwr as default, pluginSwr, mutationKeyTransformer, pluginSwrName, queryKeyTransformer, resolverSwr };
 
 //# sourceMappingURL=index.js.map