@kubb/plugin-axios 5.5.0-canary.20260924T110844 → 5.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/plugin-axios",
-  "version": "5.5.0-canary.20260924T110844",
+  "version": "5.5.0",
   "description": "Generate a slim, type-safe HTTP client with Kubb based on axios.",
   "keywords": [
     "api-client",
@@ -65,19 +65,19 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@kubb/plugin-ts": "^5.1.0-canary.20260924T110844",
-    "@kubb/plugin-zod": "^5.3.0-canary.20260924T110844"
+    "@kubb/plugin-ts": "^5.0.2",
+    "@kubb/plugin-zod": "^5.2.1"
   },
   "devDependencies": {
-    "@internals/client": "0.1.0-canary.20260924T110844",
-    "@internals/shared": "0.1.0-canary.20260924T110844",
+    "@internals/client": "0.0.0",
+    "@internals/shared": "0.0.0",
     "axios": "^1.20.0",
-    "kubb": "^5.3.13",
+    "kubb": "^5.3.14",
     "typescript": "^6.0.3"
   },
   "peerDependencies": {
     "axios": "^1.20.0",
-    "kubb": "^5.3.13"
+    "kubb": "^5.3.14"
   },
   "peerDependenciesMeta": {
     "axios": {

package/src/plugin.ts

@@ -1,5 +1,5 @@
 import path from 'node:path'
-import { createSdkGenerator, defaultMacros, resolverClient } from '@internals/client'
+import { createSdkGenerator, defaultMacros, resolverClient, runtimeTemplate } from '@internals/client'
 import { createGroupConfig } from '@internals/shared'
 import { definePlugin, Resolver } from 'kubb/kit'
 import { pluginTsName } from '@kubb/plugin-ts'
@@ -43,6 +43,7 @@ export const pluginAxios = definePlugin<PluginAxios>((options) => {
     include,
     override = [],
     baseURL,
+    throwOnErrorDefault = true,
     validator = false,
     returnType = 'full',
     group,
@@ -57,6 +58,7 @@ export const pluginAxios = definePlugin<PluginAxios>((options) => {
     override,
     group: createGroupConfig(group),
     baseURL,
+    throwOnErrorDefault,
     validator,
     returnType,
     sdk: sdk ? { mode: sdk.mode ?? 'tag', name: sdk.name } : undefined,
@@ -93,7 +95,8 @@ export const pluginAxios = definePlugin<PluginAxios>((options) => {
         ctx.injectFile({
           baseName: 'client.ts',
           path: path.resolve(root, '.kubb/client.ts'),
-          copy: axiosClientTemplatePath,
+          // Keep sources empty so the barrel exports the whole runtime module.
+          banner: runtimeTemplate(axiosClientTemplatePath, ctx.config),
           footer: baseURLExpression ? `client.setConfig({ baseURL: ${baseURLExpression} })` : undefined,
         })
 

package/templates/axios.ts

@@ -1,8 +1,8 @@
 import axios from 'axios'
 import type { AxiosError, AxiosInstance, AxiosRequestConfig, AxiosResponse, InternalAxiosRequestConfig } from 'axios'
-import { applyHeaderStyles, defaultBodySerializer, defaultPathSerializer, defaultQuerySerializer, isDefaultJsonBody, serializeCookies } from './serializers'
-import type { HeadersInit, PathParamStyle, PathSerializer, Serializers, Styles } from './serializers'
-import { ParseError, type StandardSchemaValidator, validateStandardSchema } from './standardSchema'
+import { applyHeaderStyles, defaultBodySerializer, defaultPathSerializer, defaultQuerySerializer, isDefaultJsonBody, serializeCookies } from './serializers.ts'
+import type { HeadersInit, PathParamStyle, PathSerializer, Serializers, Styles } from './serializers.ts'
+import { ParseError, type StandardSchemaValidator, validateStandardSchema } from './standardSchema.ts'
 
 /**
  * HTTP status codes treated as a success, everything else is an error.
@@ -111,10 +111,8 @@ export function withUnwrap<T extends { data: unknown; error: unknown }>(promise:
 }
 
 /**
- * The shape a generated operation returns when `returnType: 'data'` is set: the bare success body
- * once `throwOnError` (on by default) narrows away the error branch, falling back to the full
- * `RequestResult` when a call sets `throwOnError: false` and still needs `error` to discriminate a
- * failed response.
+ * The shape a generated operation returns with `returnType: 'data'`: the success body when
+ * `throwOnError` is true, or the full `RequestResult` when it is false.
  */
 export type UnwrappedResult<
   TResponses,
@@ -124,11 +122,8 @@ export type UnwrappedResult<
 > = ThrowOnError extends true ? RequestResult<TResponses, true, TRequest, TResponse>['data'] : RequestResult<TResponses, ThrowOnError, TRequest, TResponse>
 
 /**
- * Narrows a resolved call down to its success body once `throwOnError` (on by default) rules out
- * the error branch, the same default the runtime itself applies. Falls back to the full result for
- * a call that sets `throwOnError: false`, since that path still needs `error` to discriminate a
- * failed response. Backs `returnType: 'data'`, mirroring how `toEventStream` centralizes the
- * post-processing for `text/event-stream` operations.
+ * Returns the success body when `throwOnError` is true, or the full result when it is false.
+ * Backs generated operations with `returnType: 'data'`.
  */
 export function unwrapResult<T extends { data: unknown; error: unknown }>(promise: Promise<T>, throwOnError: boolean | undefined): Promise<T | T['data']> {
   return promise.then((result) => ((throwOnError ?? true) ? result.data : result))
@@ -289,24 +284,27 @@ export type CallResult<TRequest = AxiosRequestConfig, TResponse = AxiosResponse>
   response: TResponse
 }
 
-export type InterceptorFn<T> = (value: T) => T | Promise<T>
+export type InterceptorFn<T, TRequest = AxiosRequestConfig, TResponse = AxiosResponse> = (
+  value: T,
+  requestConfig?: RequestConfig<unknown, TRequest, TResponse>,
+) => T | Promise<T>
 
 /**
  * A single interceptor channel with a transport-agnostic `use` / `eject` / `update` API, backed by axios's native interceptor managers.
  */
-export type InterceptorChannel<T> = {
-  use: (fn: InterceptorFn<T>) => number
+export type InterceptorChannel<T, TRequest = AxiosRequestConfig, TResponse = AxiosResponse> = {
+  use: (fn: InterceptorFn<T, TRequest, TResponse>) => number
   eject: (id: number) => void
-  update: (id: number, fn: InterceptorFn<T>) => void
+  update: (id: number, fn: InterceptorFn<T, TRequest, TResponse>) => void
 }
 
 /**
  * The three interceptor channels every client instance exposes, wrapping axios's native managers with `error` mapped onto the response rejection handler.
  */
-export type Interceptors = {
-  request: InterceptorChannel<InternalAxiosRequestConfig>
-  response: InterceptorChannel<AxiosResponse>
-  error: InterceptorChannel<AxiosError>
+export type Interceptors<TRequest = AxiosRequestConfig, TResponse = AxiosResponse> = {
+  request: InterceptorChannel<InternalAxiosRequestConfig, TRequest, TResponse>
+  response: InterceptorChannel<AxiosResponse, TRequest, TResponse>
+  error: InterceptorChannel<AxiosError, TRequest, TResponse>
 }
 
 /**
@@ -318,7 +316,7 @@ export type ClientInstance<TRequest = AxiosRequestConfig, TResponse = AxiosRespo
   getConfig: () => ClientConfig
   setConfig: (config: ClientConfig) => ClientConfig
   getUrl: <TBody = unknown>(config: RequestConfig<TBody, TRequest, TResponse>) => string
-  interceptors: Interceptors
+  interceptors: Interceptors<TRequest, TResponse>
   createClient: (config?: ClientConfig) => ClientInstance<TRequest, TResponse>
 }
 
@@ -397,13 +395,27 @@ function serializeUrl({
 /**
  * Wraps an axios interceptor registration behind the shared `use` / `eject` / `update` API, mapping a stable external id onto axios's own so `update` can swap a handler in place.
  */
-function createInterceptorChannel<T>(register: (fn: InterceptorFn<T>) => number, ejectNative: (id: number) => void): InterceptorChannel<T> {
+function createInterceptorChannel<T, TRequest, TResponse>(
+  register: (fn: InterceptorFn<T, TRequest, TResponse>) => number,
+  ejectNative: (id: number) => void,
+  getRequestConfig: (value: T) => RequestConfig<unknown, TRequest, TResponse> | undefined,
+  getContextId: (value: T) => number | undefined,
+  setContextId: (value: T, id: number | undefined) => void,
+): InterceptorChannel<T, TRequest, TResponse> {
   const ids = new Map<number, number>()
   let counter = 0
+  const registerWithContext = (fn: InterceptorFn<T, TRequest, TResponse>) =>
+    register(async (value) => {
+      const contextId = getContextId(value)
+      const result = await fn(value, getRequestConfig(value))
+      if (contextId !== undefined) setContextId(result, contextId)
+      return result
+    })
+
   return {
     use(fn) {
       const id = ++counter
-      ids.set(id, register(fn))
+      ids.set(id, registerWithContext(fn))
       return id
     },
     eject(id) {
@@ -415,7 +427,7 @@ function createInterceptorChannel<T>(register: (fn: InterceptorFn<T>) => number,
     update(id, fn) {
       const nativeId = ids.get(id)
       if (nativeId !== undefined) ejectNative(nativeId)
-      ids.set(id, register(fn))
+      ids.set(id, registerWithContext(fn))
     },
   }
 }
@@ -665,53 +677,89 @@ async function settleResponse<TRequest, TResponse>({
 export function createClientCore<TRequest = AxiosRequestConfig, TResponse = AxiosResponse>(options: ClientConfig = {}): ClientInstance<TRequest, TResponse> {
   let config: ClientConfig = { ...options }
   const instance = config.transport ?? axios.create()
+  const requestContexts = new Map<number, RequestConfig<unknown, TRequest, TResponse>>()
+  let requestContextId = 0
+  const getContextId = (value: AxiosRequestConfig | AxiosResponse | AxiosError) => {
+    if (!value || typeof value !== 'object') return undefined
+    const axiosConfig = 'config' in value ? value.config : value
+    return (axiosConfig as (AxiosRequestConfig & { __kubbRequestContext?: number }) | undefined)?.__kubbRequestContext
+  }
+  const getRequestConfig = (value: AxiosRequestConfig | AxiosResponse | AxiosError) => {
+    const id = getContextId(value)
+    return id === undefined ? undefined : requestContexts.get(id)
+  }
+  const setContextId = (value: AxiosRequestConfig | AxiosResponse | AxiosError, id: number | undefined) => {
+    if (!value || typeof value !== 'object') return
+    const axiosConfig = 'config' in value ? value.config : value
+    if (!axiosConfig) return
+    const contextualConfig = axiosConfig as AxiosRequestConfig & { __kubbRequestContext?: number }
+    if (id === undefined) delete contextualConfig.__kubbRequestContext
+    else contextualConfig.__kubbRequestContext = id
+  }
 
   const requestManager = instance.interceptors.request
   const responseManager = instance.interceptors.response
-  const interceptors: Interceptors = {
-    request: createInterceptorChannel<InternalAxiosRequestConfig>(
+  const interceptors: Interceptors<TRequest, TResponse> = {
+    request: createInterceptorChannel<InternalAxiosRequestConfig, TRequest, TResponse>(
       (fn) => requestManager.use(fn),
       (id) => requestManager.eject(id),
+      getRequestConfig,
+      getContextId,
+      setContextId,
     ),
-    response: createInterceptorChannel<AxiosResponse>(
+    response: createInterceptorChannel<AxiosResponse, TRequest, TResponse>(
       (fn) => responseManager.use(fn),
       (id) => responseManager.eject(id),
+      getRequestConfig,
+      getContextId,
+      setContextId,
     ),
-    error: createInterceptorChannel<AxiosError>(
-      (fn) =>
-        responseManager.use(undefined, async (error: unknown) => {
-          await fn(error as AxiosError)
-          return Promise.reject(error)
-        }),
+    error: createInterceptorChannel<AxiosError, TRequest, TResponse>(
+      (fn) => responseManager.use(undefined, (error: unknown) => Promise.resolve(fn(error as AxiosError)).then(() => Promise.reject(error))),
       (id) => responseManager.eject(id),
+      getRequestConfig,
+      getContextId,
+      setContextId,
     ),
   }
 
   const client = (async <TBody = unknown>(requestConfig: RequestConfig<TBody, TRequest, TResponse>): Promise<CallResult<TRequest, TResponse>> => {
     const activeInstance = requestConfig.transport ?? config.transport ?? instance
     const { axiosConfig, codecs, throwOnError } = await resolveRequest({ config, requestConfig })
+    const contextId = ++requestContextId
+    requestContexts.set(contextId, requestConfig)
+    ;(axiosConfig as AxiosRequestConfig & { __kubbRequestContext: number }).__kubbRequestContext = contextId
 
     try {
-      const response = await activeInstance.request<unknown, AxiosResponse>(axiosConfig)
-      return await settleResponse({
-        response,
-        codecs,
-        validator: requestConfig.validator,
-        onValidationError: requestConfig.onValidationError ?? config.onValidationError,
-      })
-    } catch (error) {
-      const axiosError = error as AxiosError
-      if (throwOnError && axiosError.response) {
-        throw new ResponseError({
-          data: axiosError.response.data,
-          status: axiosError.response.status,
-          statusText: axiosError.response.statusText,
-          contentType: getResponseContentType(axiosError.response.headers as Record<string, unknown>),
-          request: axiosError.config as TRequest,
-          response: axiosError.response as TResponse,
+      try {
+        const response = await activeInstance.request<unknown, AxiosResponse>(axiosConfig)
+        const result = await settleResponse<TRequest, TResponse>({
+          response,
+          codecs,
+          validator: requestConfig.validator,
+          onValidationError: requestConfig.onValidationError ?? config.onValidationError,
         })
+        setContextId(response, undefined)
+        return result
+      } catch (error) {
+        const axiosError = error as AxiosError
+        setContextId(axiosError, undefined)
+        if (axiosError.response) setContextId(axiosError.response, undefined)
+        if (throwOnError && axiosError.response) {
+          throw new ResponseError({
+            data: axiosError.response.data,
+            status: axiosError.response.status,
+            statusText: axiosError.response.statusText,
+            contentType: getResponseContentType(axiosError.response.headers as Record<string, unknown>),
+            request: axiosError.config as TRequest,
+            response: axiosError.response as TResponse,
+          })
+        }
+        throw error
       }
-      throw error
+    } finally {
+      setContextId(axiosConfig, undefined)
+      requestContexts.delete(contextId)
     }
   }) as ClientInstance<TRequest, TResponse>