@kubb/plugin-client 5.5.12 → 5.5.15

package/dist/index.d.cts

@@ -0,0 +1,251 @@
+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$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<Omit<ResolvedOptions$1, '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$1 = {
+  output: Output;
+  exclude: Array<Exclude>;
+  include: Array<Include> | undefined;
+  override: Array<Override<Omit<ResolvedOptions$1, 'throwOnErrorDefault'>>>;
+  group: Group | null;
+  baseURL: Options$1['baseURL'];
+  throwOnErrorDefault: boolean;
+  validator: NonNullable<Options$1['validator']>;
+  returnType: ReturnTypeOption;
+  sdk: {
+    mode: Mode;
+    name: string | undefined;
+  } | undefined;
+  resolver: ResolverClient;
+};
+//#endregion
+//#region src/types.d.ts
+/**
+ * Omits keys from every member of a union, where the built-in `Omit` would collapse the union into one shape.
+ */
+type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never;
+/**
+ * Options for `pluginClient`. It takes the shared client options, without the ones this plugin does not use,
+ * plus the required `importPath`.
+ *
+ * @example
+ * ```ts
+ * pluginClient({ importPath: '../../../client' })
+ * ```
+ */
+type Options = DistributiveOmit<Options$1, 'sdk' | 'returnType' | 'baseURL' | 'override'> & {
+  /**
+   * Applies different options to operations that match a pattern.
+   * `sdk`, `returnType`, and `baseURL` are not available, because this plugin generates standalone operations and your client module owns the base URL.
+   */
+  override?: Array<Override<Omit<ResolvedOptions, 'throwOnErrorDefault' | 'sdk' | 'returnType' | 'baseURL'>>>;
+  /**
+   * Import specifier of your own client module, written into every generated import exactly as given.
+   * It must resolve from the generated file, so use a relative path, a package name, or an alias.
+   *
+   * @example
+   * ```ts
+   * pluginClient({ importPath: '../../../client' }) // relative to src/gen/clients/<tag>/
+   * pluginClient({ importPath: '@my-org/api-client' }) // a package
+   * ```
+   */
+  importPath: string;
+};
+/**
+ * Options after `pluginClient` applies its defaults.
+ */
+type ResolvedOptions = ResolvedOptions$1 & {
+  importPath: string;
+};
+/**
+ * Plugin type of `@kubb/plugin-client`, registered in the Kubb plugin registry.
+ */
+type PluginClient = PluginType<'plugin-client', Options, ResolvedOptions, ResolverClient>;
+declare global {
+  namespace Kubb {
+    interface PluginRegistry {
+      'plugin-client': PluginClient;
+    }
+  }
+}
+//#endregion
+//#region src/plugin.d.ts
+/**
+ * Canonical plugin name for `@kubb/plugin-client`.
+ */
+export declare const pluginClientName = "plugin-client";
+/**
+ * Generates typed operations that call a client module owned by your application.
+ * The module at `importPath` must export the runtime helpers and types used by generated operations.
+ * Kubb does not copy or inject a transport implementation.
+ *
+ * @example
+ * ```ts
+ * pluginClient({ importPath: '../api/client' })
+ * ```
+ */
+export declare const pluginClient: import("kubb/kit").PluginFactory<PluginClient>;
+//#endregion
+export { type Options, type PluginClient, type ResolvedOptions, type ResolverClient, pluginClient 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,10 +1,10 @@
-import "./rolldown-runtime-C0LytTxp.js";
 import { Diagnostics, Resolver, Url, addGenerator, ast, createResolver, defineExtension, defineGenerator, macroSimplifyUnion, setMacros, setResolver } from "kubb/kit";
 import path from "node:path";
 import { createFunctionParameter, createFunctionParameters, functionPrinter, pluginTsName } from "@kubb/plugin-ts";
 import { pluginZodName } from "@kubb/plugin-zod";
 import { File, Function, jsxRenderer } from "kubb/jsx";
 import { jsx, jsxs } from "kubb/jsx/jsx-runtime";
+//#endregion
 //#region ../../internals/shared/src/operation.ts
 /**
 * Builds the `ResolverFileParams` every operation generator passes to
@@ -413,11 +413,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.12";
+var version = "5.5.15";
 //#endregion
 //#region ../../internals/client/src/builders/validatorOptions.ts
 /**
@@ -679,21 +679,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.
 *