@kubb/plugin-fetch 5.12.0-canary.20261105T084754 → 5.12.0

package/dist/index.cjs

@@ -1511,7 +1511,7 @@ var compatibility = {
 	"node": ">=22.22"
 };
 // package.json
-var version = "5.12.0-canary.20261105T084754";
+var version = "5.12.0";
 // src/templates.ts
 /** Absolute path to the fetch client template, copied into `.kubb/client.ts`. */
 const fetchClientTemplatePath = (0, node_url.fileURLToPath)(new URL("../templates/fetch.ts", require("url").pathToFileURL(__filename).href));

package/dist/index.js

@@ -1485,7 +1485,7 @@ var compatibility = {
 	"node": ">=22.22"
 };
 // package.json
-var version = "5.12.0-canary.20261105T084754";
+var version = "5.12.0";
 // src/templates.ts
 /** Absolute path to the fetch client template, copied into `.kubb/client.ts`. */
 const fetchClientTemplatePath = fileURLToPath(new URL("../templates/fetch.ts", import.meta.url));

package/dist/templates/fetch.d.ts

@@ -169,6 +169,17 @@ export type ValidationErrorHandler = (error: ParseError, context: ValidationErro
 } | void | Promise<{
   value: unknown;
 } | void>;
+/**
+ * Turns generated validation on or off. `false` skips every validator, an object skips only the directions set to `false`:
+ * `request` is the body, `params` are path, query, and header params, `response` and `error` are the response bodies.
+ * @default true
+ */
+export type ValidateOption = boolean | {
+  request?: boolean;
+  params?: boolean;
+  response?: boolean;
+  error?: boolean;
+};
 /**
  * A resolved security scheme carried on each generated call's `security` array and passed to the `auth` resolver.
  */
@@ -223,6 +234,7 @@ export type RequestConfig<TBody = unknown, TRequest = Request, TResponse = Respo
     error?: Validator;
   };
   onValidationError?: ValidationErrorHandler;
+  validate?: ValidateOption;
   security?: Array<Auth>;
   auth?: AuthResolver;
 };
@@ -246,6 +258,7 @@ export type ClientConfig<TRequest = Request, TResponse = Response> = {
   serializer?: Serializers;
   codecs?: Record<string, Codec>;
   onValidationError?: ValidationErrorHandler;
+  validate?: ValidateOption;
   auth?: AuthResolver;
 };
 /**

package/docs/guides/error-handling.md

@@ -116,3 +116,21 @@ A `ParseError` reports schema validation issues. A `ResponseError` reports a non
 
 Calling `.unwrap()` on a `throwOnError: false` call turns that same `error` into a rejection, so a
 `try`/`catch` works there too.
+
+## Turn validation off at runtime
+
+The `validator` option decides at generation time which schemas each call carries. Set `validate` on the client to skip them at runtime, for example in production or in tests with partial fixtures:
+
+```typescript
+import { client } from './gen/.kubb/client'
+
+client.setConfig({ validate: import.meta.env.DEV })
+```
+
+`validate: false` skips every schema. An object skips only the directions set to `false`: `request` (the body), `params` (path, query, and header params), `response`, and `error`:
+
+```typescript
+client.setConfig({ validate: { response: false } })
+```
+
+A per-call `validate` overrides the client setting, such as `getPetById({ path: { petId: 1 }, validate: true })`. The default is `true`.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/plugin-fetch",
-  "version": "5.12.0-canary.20261105T084754",
+  "version": "5.12.0",
   "description": "Generate a slim, type-safe HTTP client with Kubb based on the native Fetch api.",
   "keywords": [
     "api-client",
@@ -81,13 +81,13 @@
   },
   "dependencies": {
     "@kubb/kit": "^5.15.4",
-    "@kubb/plugin-ts": "^5.5.0-canary.20261105T084753",
-    "@kubb/plugin-zod": "^5.9.0-canary.20261105T084753",
+    "@kubb/plugin-ts": "^5.4.0",
+    "@kubb/plugin-zod": "^5.8.1",
     "@kubb/renderer-jsx": "^5.15.4"
   },
   "devDependencies": {
-    "@internals/client": "0.1.0-canary.20261105T084753",
-    "@internals/shared": "0.1.0-canary.20261105T084753",
+    "@internals/client": "0.0.0",
+    "@internals/shared": "0.0.0",
     "typescript": "^7.0.2"
   },
   "peerDependencies": {},

package/templates/fetch.ts

@@ -168,6 +168,13 @@ export type ValidationErrorContext = {
  */
 export type ValidationErrorHandler = (error: ParseError, context: ValidationErrorContext) => { value: unknown } | void | Promise<{ value: unknown } | void>
 
+/**
+ * Turns generated validation on or off. `false` skips every validator, an object skips only the directions set to `false`:
+ * `request` is the body, `params` are path, query, and header params, `response` and `error` are the response bodies.
+ * @default true
+ */
+export type ValidateOption = boolean | { request?: boolean; params?: boolean; response?: boolean; error?: boolean }
+
 /**
  * A resolved security scheme carried on each generated call's `security` array and passed to the `auth` resolver.
  */
@@ -217,6 +224,7 @@ export type RequestConfig<TBody = unknown, TRequest = Request, TResponse = Respo
   codecs?: Record<string, Codec>
   validator?: { request?: Validator; path?: Validator; query?: Validator; headers?: Validator; response?: Validator; error?: Validator }
   onValidationError?: ValidationErrorHandler
+  validate?: ValidateOption
   security?: Array<Auth>
   auth?: AuthResolver
 }
@@ -246,6 +254,7 @@ export type ClientConfig<TRequest = Request, TResponse = Response> = {
   serializer?: Serializers
   codecs?: Record<string, Codec>
   onValidationError?: ValidationErrorHandler
+  validate?: ValidateOption
   auth?: AuthResolver
 }
 
@@ -493,6 +502,10 @@ export async function resolveAuth(params: {
   }
 }
 
+function isValidationEnabled(validate: ValidateOption | undefined, direction: 'request' | 'params' | 'response' | 'error'): boolean {
+  return typeof validate === 'object' ? validate[direction] !== false : validate !== false
+}
+
 async function runValidator<T>({
   validator,
   value,
@@ -540,10 +553,11 @@ async function resolveRequest<TBody, TRequest, TResponse>({
 }: {
   config: ClientConfig<TRequest, TResponse>
   requestConfig: RequestConfig<TBody, TRequest, TResponse>
-}): Promise<{ request: ResolvedRequest; codecs: Record<string, Codec> }> {
+}): Promise<{ request: ResolvedRequest; codecs: Record<string, Codec>; validate: ValidateOption | undefined }> {
   const { querySerializer, bodySerializer, pathSerializer } = resolveSerializers({ config, requestConfig })
   const codecs = { ...config.codecs, ...requestConfig.codecs }
   const onValidationError = requestConfig.onValidationError ?? config.onValidationError
+  const validate = requestConfig.validate ?? config.validate
   const validationContext = { direction: 'request', method: requestConfig.method, url: requestConfig.url } as const
 
   // Params are encoded before anything reads them: headers before styling, query before auth adds its values.
@@ -554,7 +568,12 @@ async function resolveRequest<TBody, TRequest, TResponse>({
   }
   const [validatedPath, validatedQuery, validatedHeaders] = await Promise.all(
     (['path', 'query', 'headers'] as const).map((source) =>
-      runValidator({ validator: requestConfig.validator?.[source], value: paramValues[source], context: { ...validationContext, source }, onValidationError }),
+      runValidator({
+        validator: isValidationEnabled(validate, 'params') ? requestConfig.validator?.[source] : undefined,
+        value: paramValues[source],
+        context: { ...validationContext, source },
+        onValidationError,
+      }),
     ),
   )
 
@@ -581,7 +600,7 @@ async function resolveRequest<TBody, TRequest, TResponse>({
   }
 
   const validatedBody = await runValidator({
-    validator: requestConfig.validator?.request,
+    validator: isValidationEnabled(validate, 'request') ? requestConfig.validator?.request : undefined,
     value: requestConfig.body,
     context: { ...validationContext, source: 'body' },
     onValidationError,
@@ -615,6 +634,7 @@ async function resolveRequest<TBody, TRequest, TResponse>({
 
   return {
     codecs,
+    validate,
     request: {
       url,
       method: (requestConfig.method ?? 'GET').toUpperCase(),
@@ -645,7 +665,7 @@ export function createClientCore<TRequest = Request, TResponse = Response>(
 
   const client = (async <TBody = unknown>(requestConfig: RequestConfig<TBody, TRequest, TResponse>): Promise<CallResult<TRequest, TResponse>> => {
     const transport = requestConfig.transport ?? config.transport ?? defaultTransport
-    const { request, codecs } = await resolveRequest({ config, requestConfig })
+    const { request, codecs, validate } = await resolveRequest({ config, requestConfig })
 
     const resolvedRequest = await interceptors.request.run(request, requestConfig)
     const result = await interceptors.response.run(await transport(resolvedRequest), requestConfig)
@@ -654,13 +674,14 @@ export function createClientCore<TRequest = Request, TResponse = Response>(
     const validator = requestConfig.validator
     const onValidationError = requestConfig.onValidationError ?? config.onValidationError
     const isSuccess = result.status >= 200 && result.status < 300
+    const direction = isSuccess ? 'response' : 'error'
     const contentType = result.contentType ?? getResponseContentType(result.headers)
     const codec = contentType ? codecs[contentType] : undefined
     const decoded = contentType && codec?.deserialize ? await codec.deserialize(result.data, contentType) : result.data
     const data = await runValidator({
-      validator: isSuccess ? validator?.response : validator?.error,
+      validator: isValidationEnabled(validate, direction) ? validator?.[direction] : undefined,
       value: decoded,
-      context: { direction: isSuccess ? 'response' : 'error', source: 'body', method: resolvedRequest.method, url: resolvedRequest.url, status: result.status },
+      context: { direction, source: 'body', method: resolvedRequest.method, url: resolvedRequest.url, status: result.status },
       onValidationError,
     })
     if (!isSuccess && throwOnError) {