@kubb/plugin-swr 5.0.0-beta.80 → 5.0.0-beta.84

package/dist/index.d.ts

@@ -1,161 +1,5 @@
 import { t as __name } from "./rolldown-runtime-C0LytTxp.js";
-import { Exclude, Group, Include, Output, OutputOptions, Override, PluginFactoryOptions, Resolver, ast } from "@kubb/core";
-//#region ../../internals/client/src/types.d.ts
-/**
- * Validator applied to request and response bodies using schemas from `@kubb/plugin-zod`.
- * - `false`: no validation.
- * - `'zod'`: validates the success (2xx) response body, and the error body when a non-2xx call does
- *   not throw (`throwOnError: false`).
- * - `{ request?: 'zod'; response?: 'zod' }`: opt in per direction. `request` validates the request
- *   body and query parameters before the call; `response` validates the success response body and,
- *   on the non-throw path, the error body.
- */
-type ValidatorOptions = false | 'zod' | {
-  request?: 'zod';
-  response?: 'zod';
-};
-/**
- * How the class-based SDK groups operations.
- * - `'tag'`: one class per tag, optionally composed into a root client.
- * - `'flat'`: one class with every operation as a direct method.
- */
-type Mode = 'tag' | 'flat';
-/**
- * The resolver shared by the client plugins. Functions and files use camelCase; URL helpers get
- * a `get<Operation>Url` name.
- */
-type ResolverClient = Resolver & {
-  /**
-   * Resolves the function name for a raw operation name.
-   *
-   * @example
-   * `resolver.resolveName('show pet by id') // -> 'showPetById'`
-   */
-  resolveName(this: ResolverClient, name: string): string;
-  /**
-   * Resolves the output file name for a generated client module.
-   */
-  resolvePathName(this: ResolverClient, name: string, type?: 'file' | 'function' | 'type' | 'const'): string;
-  /**
-   * Resolves the generated class name for class-based clients.
-   */
-  resolveClassName(this: ResolverClient, name: string): string;
-  /**
-   * Resolves the generated class name for a tag-based client group. The default appends a
-   * `Client` suffix (tag `pet` becomes `PetClient`) so the class never collides with the schema
-   * model of the same name in the barrel.
-   *
-   * @example
-   * `resolver.resolveGroupName('pet') // -> 'PetClient'`
-   */
-  resolveGroupName(this: ResolverClient, name: string): string;
-  /**
-   * Resolves the property name a tag client is exposed under on the composed root SDK
-   * (`new PetStore(config).pet`).
-   */
-  resolveClientPropertyName(this: ResolverClient, name: string): string;
-};
-/**
- * The shared options surface for the client plugins. Deliberately small: there is one
- * response contract and one grouped options object. Each plugin extends this with its own
- * `transport` field.
- */
-type Options$1 = OutputOptions & {
-  /**
-   * 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$1>>;
-  /**
-   * Base URL prepended to every request. When omitted, falls back to the adapter's server URL.
-   */
-  baseURL?: string;
-  /**
-   * Validate request and response bodies with schemas from `@kubb/plugin-zod`.
-   *
-   * @default false
-   */
-  validator?: ValidatorOptions;
-  /**
-   * Generates a class-based SDK instead of the standalone functions. Each tag client is an instance
-   * class whose constructor takes a client config and builds its own client, so every environment is
-   * a separate instance. Leave `sdk` unset to keep the standalone per-operation functions (the
-   * default), which is also what query plugins consume.
-   *
-   * @example Instance class per tag
-   * ```ts
-   * pluginFetch({ sdk: {} })
-   * // const api = new PetClient({ baseURL: 'https://api.example.com' })
-   * // await api.getPetById({ path: { petId: 1 } })
-   * ```
-   * @example Composed root that instantiates every tag client from one config
-   * ```ts
-   * pluginFetch({ sdk: { name: 'petStore' } })
-   * // class PetStore {
-   * //   readonly pet: PetClient
-   * //   readonly store: StoreClient
-   * //   constructor(config = {}) { ... }
-   * // }
-   * // const api = new PetStore({ baseURL })
-   * // await api.pet.getPetById({ path: { petId: 1 } })
-   * ```
-   * @example Flat class with every operation as a direct method
-   * ```ts
-   * pluginFetch({ sdk: { name: 'petStore', mode: 'flat' } })
-   * // const api = new PetStore({ baseURL })
-   * // await api.getPetById({ path: { petId: 1 } })
-   * ```
-   */
-  sdk?: {
-    /**
-     * How the SDK groups operations.
-     * - `'tag'`: one class per tag. With `name`, a composed root instantiates every tag client.
-     * - `'flat'`: one class named by `name`, with every operation as a direct method.
-     *
-     * @default 'tag'
-     */
-    mode?: Mode;
-    /**
-     * Name of the generated entry point, also the file name. With `mode: 'tag'` it emits a
-     * composed root class that instantiates every tag client from one shared config. With
-     * `mode: 'flat'` it names the single class.
-     */
-    name?: string;
-  };
-  /**
-   * Override how names and file paths are built. Methods you omit fall back to the default resolver.
-   */
-  resolver?: Partial<ResolverClient> & ThisType<ResolverClient>;
-  /**
-   * Macros applied to each operation node before code is printed.
-   */
-  macros?: Array<ast.Macro>;
-};
-/**
- * The resolved options after defaults are applied.
- */
-type ResolvedOptions$1 = {
-  output: Output;
-  exclude: Array<Exclude>;
-  include: Array<Include> | undefined;
-  override: Array<Override<ResolvedOptions$1>>;
-  group: Group | null;
-  baseURL: Options$1['baseURL'];
-  validator: NonNullable<Options$1['validator']>;
-  sdk: {
-    mode: Mode;
-    name: string | undefined;
-  } | undefined;
-  resolver: ResolverClient;
-};
-//#endregion
+import { Exclude, Group, Include, Output, OutputOptions, Override, PluginFactoryOptions, Resolver, ast } from "kubb/kit";
 //#region ../../internals/client/src/resolveClient.d.ts
 /**
  * Resolves which client plugin a consumer (react-query, vue-query, swr, mcp) should call for an
@@ -250,14 +94,14 @@ type Query = {
   /**
    * HTTP methods to use for queries.
    *
-   * @default ['get']
+   * @default ['GET']
    */
   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.
+   * Path is used as-is. Relative paths are based on the generated file location.
    * @default 'swr'
    */
   importPath?: string;
@@ -266,14 +110,14 @@ type Mutation = {
   /**
    * HTTP methods to use for mutations.
    *
-   * @default ['post', 'put', 'delete', 'patch']
+   * @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.
+   * Path is used as-is. Relative paths are based on the generated file location.
    * @default 'swr/mutation'
    */
   importPath?: string;
@@ -308,20 +152,24 @@ type Options = OutputOptions & {
    * 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;
-  /**
-   * Parser to use for validating response data.
-   */
-  validator?: Options$1['validator'];
   /**
    * Override naming conventions for function names and types.
    */
@@ -349,7 +197,6 @@ type ResolvedOptions = {
    * The resolved contract client the generators import and call.
    */
   client: ResolvedClient;
-  validator: NonNullable<Options['validator']>;
   queryKey: QueryKey | undefined;
   query: NonNullable<Required<Query>> | false;
   mutationKey: MutationKey | undefined;
@@ -366,8 +213,33 @@ declare global {
 }
 //#endregion
 //#region src/plugin.d.ts
+/**
+ * Canonical plugin name for `@kubb/plugin-swr`. Used for driver lookups and cross-plugin
+ * dependency references.
+ */
 declare const pluginSwrName = "plugin-swr";
-declare const pluginSwr: (options?: Options | undefined) => import("@kubb/core").Plugin<PluginSwr>;
+/**
+ * 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: { path: './petStore.yaml' },
+ *   output: { path: './src/gen' },
+ *   plugins: [
+ *     pluginTs(),
+ *     pluginSwr({ output: { path: './hooks' } }),
+ *   ],
+ * })
+ * ```
+ */
+declare const pluginSwr: (options?: Options | undefined) => import("kubb/kit").Plugin<PluginSwr>;
 //#endregion
 export { type PluginSwr, type Transformer, pluginSwr as default, pluginSwr, pluginSwrName };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,10 +1,9 @@
 import { t as __name } from "./rolldown-runtime-C0LytTxp.js";
 import path from "node:path";
-import { ast, defineGenerator, definePlugin, defineResolver } from "@kubb/core";
+import { ast, defineGenerator, definePlugin, defineResolver } from "kubb/kit";
 import { createFunctionParameter, createFunctionParameters, createObjectBindingPattern, createTypeLiteral, functionPrinter, pluginTsName } from "@kubb/plugin-ts";
-import { pluginZodName } from "@kubb/plugin-zod";
-import { File, Function, Type, jsxRenderer } from "@kubb/renderer-jsx";
-import { Fragment, jsx, jsxs } from "@kubb/renderer-jsx/jsx-runtime";
+import { File, Function, Type, jsxRenderer } from "kubb/jsx";
+import { Fragment, jsx, jsxs } from "kubb/jsx/jsx-runtime";
 //#region ../../internals/utils/src/casing.ts
 /**
 * Shared implementation for camelCase and PascalCase conversion.
@@ -525,16 +524,6 @@ function createGroupConfig(group) {
 	};
 }
 //#endregion
-//#region ../../internals/client/src/builders/validatorOptions.ts
-/**
-* Returns `true` when any direction of the validator uses zod (used for dependency checks).
-*/
-function isValidatorEnabled(validator) {
-	if (!validator) return false;
-	if (validator === "zod") return true;
-	return Boolean(validator.request || validator.response);
-}
-//#endregion
 //#region ../../internals/client/src/resolveClient.ts
 /**
 * Resolves which client plugin a consumer (react-query, vue-query, swr, mcp) should call for an
@@ -753,51 +742,6 @@ function buildClientCall(node, options) {
 	].filter((part) => part !== null).join(", ")} })`;
 }
 /**
-* Returns `'zod'` when response-direction parsing is enabled.
-* The string shorthand `'zod'` also enables response parsing.
-*/
-function resolveResponseParser(parser) {
-	if (!parser) return null;
-	if (parser === "zod") return "zod";
-	return parser.response ?? null;
-}
-/**
-* Returns `'zod'` when request body parsing is enabled.
-* The string shorthand `'zod'` also enables request body parsing (existing behavior).
-*/
-function resolveRequestParser(parser) {
-	if (!parser) return null;
-	if (parser === "zod") return "zod";
-	return parser.request ?? null;
-}
-/**
-* Returns `'zod'` when query-params parsing is enabled.
-* Only the object form `{ request: 'zod' }` enables this. `parser: 'zod'` does not.
-*/
-function resolveQueryParamsParser(parser) {
-	if (!parser || parser === "zod") return null;
-	return parser.request ?? null;
-}
-/**
-* Collects the Zod schema import names for an operation based on the active parser directions.
-*
-* - `parser: 'zod'`: response and request body names (backward-compatible behavior).
-* - `parser: { request: 'zod' }`: request body and query params names.
-* - `parser: { response: 'zod' }`: response name only.
-* - `parser: { request: 'zod', response: 'zod' }`: all three.
-*
-* Returns an empty array when no resolver is provided or `parser` is falsy.
-*/
-function resolveZodSchemaNames(node, zodResolver, parser) {
-	if (!zodResolver || !parser) return [];
-	const { query: queryParams } = getOperationParameters(node, { paramsCasing: "original" });
-	return [
-		resolveResponseParser(parser) === "zod" ? zodResolver.resolveResponseName?.(node) : null,
-		resolveRequestParser(parser) === "zod" && node.requestBody?.content?.[0]?.schema ? zodResolver.resolveDataName?.(node) : null,
-		resolveQueryParamsParser(parser) === "zod" && queryParams.length > 0 ? zodResolver.resolveQueryParamsName?.(node, queryParams[0]) : null
-	].filter((n) => Boolean(n));
-}
-/**
 * Build QueryKey params as the grouped `{ path, query, body }` object (NO headers, NO config),
 * typed from the operation's `RequestConfig` minus `url`. The query key transformer reads the
 * grouped `path`/`query`/`body` bindings.
@@ -1062,7 +1006,7 @@ const mutationGenerator = defineGenerator({
 	operation(node, ctx) {
 		if (!ast.isHttpOperationNode(node)) return null;
 		const { config, driver, resolver, root } = ctx;
-		const { output, query, mutation, validator, client, group } = ctx.options;
+		const { output, query, mutation, client, group } = ctx.options;
 		const pluginTs = driver.getPlugin(pluginTsName);
 		if (!pluginTs) return null;
 		const tsResolver = driver.getResolver(pluginTsName);
@@ -1108,19 +1052,6 @@ const mutationGenerator = defineGenerator({
 			order: "body-response-first",
 			includeParams: false
 		})].filter((name) => Boolean(name));
-		const pluginZod = isValidatorEnabled(validator) ? driver.getPlugin(pluginZodName) : void 0;
-		const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : void 0;
-		const fileZod = zodResolver ? zodResolver.resolveFile({
-			name: node.operationId,
-			extname: ".ts",
-			tag: node.tags[0] ?? "default",
-			path: node.path
-		}, {
-			root,
-			output: pluginZod?.options?.output ?? output,
-			group: pluginZod?.options?.group
-		}) : void 0;
-		const zodSchemaNames = resolveZodSchemaNames(node, zodResolver, validator);
 		const calledClientName = contractOp.name;
 		return /* @__PURE__ */ jsxs(File, {
 			baseName: meta.file.baseName,
@@ -1143,11 +1074,6 @@ const mutationGenerator = defineGenerator({
 				}
 			}),
 			children: [
-				fileZod && zodSchemaNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
-					name: zodSchemaNames,
-					root: meta.file.path,
-					path: fileZod.path
-				}),
 				/* @__PURE__ */ jsx(File.Import, {
 					name: [contractOp.name],
 					root: meta.file.path,
@@ -1197,13 +1123,17 @@ const mutationGenerator = defineGenerator({
 });
 //#endregion
 //#region src/generators/queryGenerator.tsx
+/**
+* Built-in generator for `useSWR` hooks. Emits one `useFoo` hook per read operation plus the
+* matching `fooQueryKey` helper and `fooQueryOptions` factory.
+*/
 const queryGenerator = defineGenerator({
 	name: "swr-query",
 	renderer: jsxRenderer,
 	operation(node, ctx) {
 		if (!ast.isHttpOperationNode(node)) return null;
 		const { config, driver, resolver, root } = ctx;
-		const { output, query, mutation, validator, client, group } = ctx.options;
+		const { output, query, mutation, client, group } = ctx.options;
 		const pluginTs = driver.getPlugin(pluginTsName);
 		if (!pluginTs) return null;
 		const tsResolver = driver.getResolver(pluginTsName);
@@ -1251,19 +1181,6 @@ const queryGenerator = defineGenerator({
 			order: "body-response-first",
 			includeParams: false
 		})].filter((name) => Boolean(name));
-		const pluginZod = isValidatorEnabled(validator) ? driver.getPlugin(pluginZodName) : void 0;
-		const zodResolver = pluginZod ? driver.getResolver(pluginZodName) : void 0;
-		const fileZod = zodResolver ? zodResolver.resolveFile({
-			name: node.operationId,
-			extname: ".ts",
-			tag: node.tags[0] ?? "default",
-			path: node.path
-		}, {
-			root,
-			output: pluginZod?.options?.output ?? output,
-			group: pluginZod?.options?.group
-		}) : void 0;
-		const zodSchemaNames = resolveZodSchemaNames(node, zodResolver, validator);
 		const calledClientName = contractOp.name;
 		return /* @__PURE__ */ jsxs(File, {
 			baseName: meta.file.baseName,
@@ -1286,11 +1203,6 @@ const queryGenerator = defineGenerator({
 				}
 			}),
 			children: [
-				fileZod && zodSchemaNames.length > 0 && /* @__PURE__ */ jsx(File.Import, {
-					name: zodSchemaNames,
-					root: meta.file.path,
-					path: fileZod.path
-				}),
 				/* @__PURE__ */ jsx(File.Import, {
 					name: [contractOp.name],
 					root: meta.file.path,
@@ -1399,18 +1311,43 @@ const resolverSwr = defineResolver(() => ({
 }));
 //#endregion
 //#region src/plugin.ts
+/**
+* Canonical plugin name for `@kubb/plugin-swr`. Used for driver lookups and cross-plugin
+* dependency references.
+*/
 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: { path: './petStore.yaml' },
+*   output: { path: './src/gen' },
+*   plugins: [
+*     pluginTs(),
+*     pluginSwr({ output: { path: './hooks' } }),
+*   ],
+* })
+* ```
+*/
 const pluginSwr = definePlugin((options) => {
 	const { output = {
 		path: "hooks",
 		barrel: { type: "named" }
-	}, group, exclude = [], include, override = [], validator = false, mutation = {}, query = {}, mutationKey = mutationKeyTransformer, queryKey = queryKeyTransformer, client, resolver: userResolver, macros: userMacros } = options;
+	}, group, exclude = [], include, override = [], mutation = {}, query = {}, mutationKey = mutationKeyTransformer, queryKey = queryKeyTransformer, client, resolver: userResolver, macros: userMacros } = options;
 	const selectedGenerators = [queryGenerator, mutationGenerator].filter((generator) => Boolean(generator));
 	const groupConfig = createGroupConfig(group) ?? void 0;
 	return {
 		name: pluginSwrName,
 		options,
-		dependencies: [pluginTsName, isValidatorEnabled(validator) ? pluginZodName : void 0].filter((dependency) => Boolean(dependency)),
+		dependencies: [pluginTsName],
 		hooks: { "kubb:plugin:setup"(ctx) {
 			const resolver = userResolver ? {
 				...resolverSwr,
@@ -1431,21 +1368,20 @@ const pluginSwr = definePlugin((options) => {
 				queryKey,
 				query: query === false ? false : {
 					importPath: "swr",
-					methods: ["get"],
+					methods: ["GET"],
 					...query
 				},
 				mutationKey,
 				mutation: mutation === false ? false : {
 					importPath: "swr/mutation",
 					methods: [
-						"post",
-						"put",
-						"patch",
-						"delete"
+						"POST",
+						"PUT",
+						"PATCH",
+						"DELETE"
 					],
 					...mutation
 				},
-				validator,
 				group: groupConfig,
 				exclude,
 				include,