@kubb/plugin-fetch 5.6.2 → 5.6.5

package/dist/index.d.cts

@@ -0,0 +1,237 @@
+import { Exclude, Group, Include, Output, OutputOptions, Override, PluginType, Resolver, ResolverPatch, ast } from "kubb/kit";
+import "@kubb/plugin-zod";
+//#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 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';
+/**
+ * Shape of the value a generated operation function resolves to.
+ * - `'full'`: the complete `{ status, data, error, contentType, request, response }` result.
+ * - `'data'`: the bare success body when `throwOnError` is true, or the full result when it is false
+ *   so callers can inspect `error`.
+ * - `'plain'`: the client's own promise typed as `RequestResult`, with no `withUnwrap` / `unwrapResult`
+ *   helper. Backs `@kubb/plugin-client`.
+ */
+type ReturnTypeOption = 'full' | 'data' | 'plain';
+/**
+ * The resolver shared by the client plugins. Inherits the built-in camelCase `name` and `file`;
+ * classes and tag groups use PascalCase (with a `Client` suffix for groups).
+ */
+type ResolverClient = Resolver & {
+  /**
+   * Resolves the generated class name for class-based clients.
+   */
+  className(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.groupName('pet') // -> 'PetClient'`
+   */
+  groupName(this: ResolverClient, name: string): string;
+  /**
+   * Resolves the property name a tag client is exposed under on the composed root SDK
+   * (`new PetStore(config).pet`).
+   */
+  propertyName(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 = 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<Omit<ResolvedOptions, 'throwOnErrorDefault'>>>;
+  /**
+   * Base URL prepended to every request. When omitted, the generated client sets no base URL, so
+   * set one at runtime with `client.setConfig({ baseURL })`. The adapter's server URL is not used.
+   * Values containing a `${...}` interpolation are emitted as template literals in the generated
+   * client config, which keeps runtime environment reads dynamic.
+   */
+  baseURL?: string;
+  /**
+   * Default error behavior for generated operations and their client. Per-call `throwOnError`
+   * takes precedence.
+   *
+   * @default true
+   */
+  throwOnErrorDefault?: boolean;
+  /**
+   * Validate request and response bodies with schemas from `@kubb/plugin-zod`.
+   *
+   * @default false
+   */
+  validator?: ValidatorOptions;
+  /**
+   * Shape of the value a generated operation function resolves to. Applies to the standalone
+   * functions and the class-based SDK; not to the query-hook plugins (`@kubb/plugin-react-query`,
+   * `@kubb/plugin-vue-query`, `@kubb/plugin-swr`), which keep calling the client directly and
+   * expect the full result.
+   *
+   * @default 'full'
+   * @example
+   * ```ts
+   * pluginAxios({ returnType: 'data' })
+   * // const pet = await getPetById({ path: { petId: 1 } }) // Pet, not { status, data, ... }
+   * ```
+   */
+  returnType?: ReturnTypeOption;
+  /**
+   * 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?: ResolverPatch<ResolverClient>;
+  /**
+   * Macros applied to each operation node before code is printed.
+   */
+  macros?: Array<ast.Macro>;
+};
+/**
+ * The resolved options after defaults are applied.
+ */
+type ResolvedOptions = {
+  output: Output;
+  exclude: Array<Exclude>;
+  include: Array<Include> | undefined;
+  override: Array<Override<Omit<ResolvedOptions, 'throwOnErrorDefault'>>>;
+  group: Group | null;
+  baseURL: Options['baseURL'];
+  throwOnErrorDefault: boolean;
+  validator: NonNullable<Options['validator']>;
+  returnType: ReturnTypeOption;
+  sdk: {
+    mode: Mode;
+    name: string | undefined;
+  } | undefined;
+  resolver: ResolverClient;
+};
+//#endregion
+//#region src/types.d.ts
+/**
+ * The plugin factory type for `@kubb/plugin-fetch`. Shares the options surface, resolver, and
+ * resolved-options shape with the other client plugins; only the plugin name and transport
+ * differ.
+ */
+type PluginFetch = PluginType<'plugin-fetch', Options, ResolvedOptions, ResolverClient>;
+declare global {
+  namespace Kubb {
+    interface PluginRegistry {
+      'plugin-fetch': PluginFetch;
+    }
+  }
+}
+//#endregion
+//#region src/generators/clientGenerator.d.ts
+/**
+ * Built-in operation generator for `@kubb/plugin-fetch`. Emits one async function per OpenAPI
+ * operation using the shared `Operation` component: a grouped `<Name>Request` type and a function
+ * that forwards a single `options` object to the bundled `client` and returns the `RequestResult`.
+ */
+export declare const clientGenerator: import("kubb/kit").Generator<PluginFetch>;
+//#endregion
+//#region src/plugin.d.ts
+/**
+ * Canonical plugin name for `@kubb/plugin-fetch`. Used for driver lookups and cross-plugin
+ * dependency references.
+ */
+export declare const pluginFetchName = "plugin-fetch";
+/**
+ * Generates a type-safe HTTP client pinned to the Fetch API. Each operation becomes one async
+ * function that takes a single grouped `options` object and returns the shared `RequestResult`
+ * contract. The runtime is always bundled into `.kubb/client.ts`, so generated code never imports
+ * from `@kubb/plugin-fetch` and the only runtime dependency is the global `fetch`.
+ *
+ * @example
+ * ```ts
+ * import { defineConfig } from 'kubb/config'
+ * import { pluginTs } from '@kubb/plugin-ts'
+ * import { pluginFetch } from '@kubb/plugin-fetch'
+ *
+ * export default defineConfig({
+ *   input: './petStore.yaml',
+ *   output: { path: './src/gen' },
+ *   plugins: [
+ *     pluginTs(),
+ *     pluginFetch({ output: { path: './clients' } }),
+ *   ],
+ * })
+ * ```
+ */
+export declare const pluginFetch: import("kubb/kit").PluginFactory<PluginFetch>;
+//#endregion
+export { type Options, type PluginFetch, type ResolvedOptions, type ResolverClient, pluginFetch as default };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.ts

@@ -1,5 +1,4 @@
-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";
 //#region ../../internals/client/src/types.d.ts
 /**

package/dist/index.js

@@ -1,4 +1,3 @@
-import "./rolldown-runtime-C0LytTxp.js";
 import { Diagnostics, Resolver, Url, addGenerator, assertPluginOption, ast, createResolver, defineExtension, defineGenerator, injectFile, macroSimplifyUnion, setMacros, setResolver, useConfig } from "kubb/kit";
 import path from "node:path";
 import { pluginZodName } from "@kubb/plugin-zod";
@@ -6,6 +5,7 @@ import { File, Function, jsxRenderer } from "kubb/jsx";
 import { createFunctionParameter, createFunctionParameters, functionPrinter, pluginTsName } from "@kubb/plugin-ts";
 import { Fragment, jsx, jsxs } from "kubb/jsx/jsx-runtime";
 import { fileURLToPath } from "node:url";
+//#endregion
 //#region ../../internals/shared/src/operation.ts
 /**
 * Builds the `ResolverFileParams` every operation generator passes to
@@ -688,21 +688,23 @@ function toKey(name, location) {
 	return isValidVarName(key) ? key : JSON.stringify(key);
 }
 /**
-* Serializes one parameter's metadata into a `{ style, explode }` literal, or `null` when the
-* parameter carries neither. Path and query carry the serialization `style`; header and cookie use a
-* fixed style (`simple` and `form`), so only `explode` is emitted for them.
+* Serializes one parameter's metadata into a `{ style, explode, allowReserved }` literal, or `null`
+* when the parameter carries none. Path and query carry the serialization `style`; header and cookie
+* use a fixed style (`simple` and `form`), so only `explode` is emitted for them. `allowReserved`
+* only applies to query parameters.
 */
 function serializeParameter(parameter) {
 	const parts = [];
 	if ((parameter.in === "path" || parameter.in === "query") && parameter.style) parts.push(`style: '${parameter.style}'`);
 	if (parameter.explode !== void 0) parts.push(`explode: ${parameter.explode}`);
+	if (parameter.in === "query" && parameter.allowReserved !== void 0) parts.push(`allowReserved: ${parameter.allowReserved}`);
 	return parts.length > 0 ? `{ ${parts.join(", ")} }` : null;
 }
 /**
 * Builds the per-operation `styles` literal from the operation's parameters, grouped by location.
 * Path entries are keyed by the camelCased name to match the URL template placeholders; query,
 * header, and cookie entries keep the spec name to match the keys the runtime serializes.
-* Only parameters whose source defines `style` or `explode` are emitted, so calls without
+* Only parameters whose source defines `style`, `explode`, or `allowReserved` are emitted, so calls without
 * serialization metadata keep the runtime defaults and existing output is unchanged. Returns `null`
 * when no parameter carries metadata.
 *
@@ -1398,11 +1400,11 @@ const clientGenerator = createClientGenerator("fetch");
 //#region kubb-extension.json
 var compatibility = {
 	"kubb": ">=5.8.3",
-	"node": ">=22"
+	"node": ">=22.12"
 };
 //#endregion
 //#region package.json
-var version = "5.6.2";
+var version = "5.6.5";
 //#endregion
 //#region src/templates.ts
 /** Absolute path to the fetch client template, copied into `.kubb/client.ts`. */