@kubb/plugin-fetch 5.4.0 → 5.4.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/plugin-fetch",
-  "version": "5.4.0",
+  "version": "5.4.2",
   "description": "Generate a slim, type-safe HTTP client with Kubb based on the native Fetch api.",
   "keywords": [
     "api-client",
@@ -66,16 +66,16 @@
   },
   "dependencies": {
     "@kubb/plugin-ts": "^5.0.2",
-    "@kubb/plugin-zod": "^5.1.5"
+    "@kubb/plugin-zod": "^5.2.1"
   },
   "devDependencies": {
     "@internals/client": "0.0.0",
     "@internals/shared": "0.0.0",
-    "kubb": "^5.2.0",
+    "kubb": "^5.3.13",
     "typescript": "^6.0.3"
   },
   "peerDependencies": {
-    "kubb": "^5.2.0"
+    "kubb": "^5.3.13"
   },
   "engines": {
     "node": ">=22"

package/src/plugin.ts

@@ -1,7 +1,8 @@
+import { readFileSync } from 'node:fs'
 import path from 'node:path'
 import { createSdkGenerator, defaultMacros, resolverClient } from '@internals/client'
 import { createGroupConfig } from '@internals/shared'
-import { definePlugin, Resolver } from 'kubb/kit'
+import { ast, definePlugin, Resolver } from 'kubb/kit'
 import { pluginTsName } from '@kubb/plugin-ts'
 import { pluginZodName } from '@kubb/plugin-zod'
 import { clientGenerator } from './generators/clientGenerator.tsx'
@@ -90,10 +91,39 @@ export const pluginFetch = definePlugin<PluginFetch>((options) => {
           copy: fetchSerializersTemplatePath,
         })
 
+        const clientPath = path.resolve(root, '.kubb/client.ts')
+        const clientSource = readFileSync(fetchClientTemplatePath, 'utf8')
+        const clientBody = clientSource.slice(clientSource.indexOf('\n\n') + 2)
+        const runtimeRoot = path.dirname(clientPath)
+
         ctx.injectFile({
           baseName: 'client.ts',
-          path: path.resolve(root, '.kubb/client.ts'),
-          copy: fetchClientTemplatePath,
+          path: clientPath,
+          imports: [
+            ast.factory.createImport({
+              name: ['applyHeaderStyles', 'defaultBodySerializer', 'defaultPathSerializer', 'defaultQuerySerializer', 'isDefaultJsonBody', 'serializeCookies'],
+              path: path.resolve(root, '.kubb/serializers.ts'),
+              root: runtimeRoot,
+            }),
+            ast.factory.createImport({
+              name: ['HeadersInit', 'PathParamStyle', 'PathSerializer', 'RequestBody', 'Serializers', 'Styles'],
+              path: path.resolve(root, '.kubb/serializers.ts'),
+              root: runtimeRoot,
+              isTypeOnly: true,
+            }),
+            ast.factory.createImport({
+              name: ['ParseError', 'validateStandardSchema'],
+              path: path.resolve(root, '.kubb/standardSchema.ts'),
+              root: runtimeRoot,
+            }),
+            ast.factory.createImport({
+              name: ['StandardSchemaValidator'],
+              path: path.resolve(root, '.kubb/standardSchema.ts'),
+              root: runtimeRoot,
+              isTypeOnly: true,
+            }),
+          ],
+          sources: [ast.factory.createSource({ nodes: [ast.factory.createText(clientBody)] })],
           footer: baseURLExpression ? `client.setConfig({ baseURL: ${baseURLExpression} })` : undefined,
         })
 

package/templates/fetch.ts

@@ -1,6 +1,6 @@
-import { applyHeaderStyles, defaultBodySerializer, defaultPathSerializer, defaultQuerySerializer, isDefaultJsonBody, serializeCookies } from './serializers'
-import type { HeadersInit, PathParamStyle, PathSerializer, RequestBody, 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, RequestBody, 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.
@@ -221,12 +221,12 @@ export type RequestConfig<TBody = unknown, TRequest = Request, TResponse = Respo
   baseURL?: string
   url?: string
   method?: 'GET' | 'PUT' | 'PATCH' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD'
-  path?: Record<string, unknown>
+  path?: unknown
   query?: unknown
   params?: unknown
-  cookies?: Record<string, unknown>
+  cookies?: unknown
   body?: TBody
-  headers?: HeadersInit
+  headers?: unknown
   styles?: Styles
   signal?: AbortSignal
   credentials?: RequestCredentials
@@ -317,25 +317,25 @@ export type CallResult<TRequest = Request, TResponse = Response> = {
   response: TResponse
 }
 
-export type InterceptorFn<T> = (value: T) => T | Promise<T>
+export type InterceptorFn<T, TContext = never> = (value: T, context?: TContext) => T | Promise<T>
 
 /**
  * A single interceptor channel with a transport-agnostic `use` / `eject` / `update` API.
  */
-export type InterceptorStack<T> = {
-  use: (fn: InterceptorFn<T>) => number
+export type InterceptorStack<T, TContext = never> = {
+  use: (fn: InterceptorFn<T, TContext>) => number
   eject: (id: number) => void
-  update: (id: number, fn: InterceptorFn<T>) => void
-  run: (value: T) => Promise<T>
+  update: (id: number, fn: InterceptorFn<T, TContext>) => void
+  run: (value: T, context?: TContext) => Promise<T>
 }
 
 /**
  * The three interceptor channels every client instance exposes.
  */
 export type Interceptors<TRequest = Request, TResponse = Response> = {
-  request: InterceptorStack<ResolvedRequest>
-  response: InterceptorStack<TransportResult<unknown, TRequest, TResponse>>
-  error: InterceptorStack<ResponseError<unknown, TRequest, TResponse>>
+  request: InterceptorStack<ResolvedRequest, RequestConfig<unknown, TRequest, TResponse>>
+  response: InterceptorStack<TransportResult<unknown, TRequest, TResponse>, RequestConfig<unknown, TRequest, TResponse>>
+  error: InterceptorStack<ResponseError<unknown, TRequest, TResponse>, RequestConfig<unknown, TRequest, TResponse>>
 }
 
 /**
@@ -426,8 +426,8 @@ function serializeUrl({
 /**
  * Creates a transport-agnostic interceptor channel that runs interceptors in registration order.
  */
-export function createInterceptorStack<T>(): InterceptorStack<T> {
-  let entries: Array<{ id: number; fn: InterceptorFn<T> }> = []
+export function createInterceptorStack<T, TContext = never>(): InterceptorStack<T, TContext> {
+  let entries: Array<{ id: number; fn: InterceptorFn<T, TContext> }> = []
   let counter = 0
   return {
     use(fn) {
@@ -442,10 +442,10 @@ export function createInterceptorStack<T>(): InterceptorStack<T> {
       const entry = entries.find((item) => item.id === id)
       if (entry) entry.fn = fn
     },
-    async run(value) {
+    async run(value, context) {
       let result = value
       for (const entry of entries) {
-        result = await entry.fn(result)
+        result = await entry.fn(result, context)
       }
       return result
     },
@@ -558,7 +558,7 @@ async function resolveRequest<TBody, TRequest, TResponse>({
   const { querySerializer, bodySerializer, pathSerializer } = resolveSerializers({ config, requestConfig })
   const codecs = { ...config.codecs, ...requestConfig.codecs }
 
-  const headers = mergeHeaders(config.headers, applyHeaderStyles(requestConfig.headers, requestConfig.styles?.header))
+  const headers = mergeHeaders(config.headers, applyHeaderStyles(requestConfig.headers as HeadersInit | undefined, requestConfig.styles?.header))
   const { request: requestContentTypeOption, response: responseContentType } = resolveContentType(requestConfig.contentType)
   const requestContentType = requestContentTypeOption ?? getHeader(headers, 'content-type')
   if (responseContentType && !hasHeader(headers, 'accept')) {
@@ -575,7 +575,7 @@ async function resolveRequest<TBody, TRequest, TResponse>({
   })
 
   if (requestConfig.cookies) {
-    const cookie = serializeCookies(requestConfig.cookies, requestConfig.styles?.cookie)
+    const cookie = serializeCookies(requestConfig.cookies as Record<string, unknown>, requestConfig.styles?.cookie)
     if (cookie) headers['Cookie'] = [headers['Cookie'], cookie].filter(Boolean).join('; ')
   }
 
@@ -604,7 +604,7 @@ async function resolveRequest<TBody, TRequest, TResponse>({
 
   const url = serializeUrl({
     parts: [requestConfig.baseURL ?? config.baseURL, requestConfig.url],
-    pathParams: requestConfig.path ?? {},
+    pathParams: (requestConfig.path ?? {}) as Record<string, unknown>,
     search: querySerializer(query, requestConfig.styles?.query),
     pathSerializer,
     pathStyles: requestConfig.styles?.path,
@@ -640,6 +640,7 @@ async function settleResult<TRequest, TResponse>({
   validator,
   onValidationError,
   errorInterceptors,
+  requestConfig,
 }: {
   result: TransportResult<unknown, TRequest, TResponse>
   request: ResolvedRequest
@@ -647,7 +648,8 @@ async function settleResult<TRequest, TResponse>({
   throwOnError: boolean
   validator: { response?: Validator; error?: Validator } | undefined
   onValidationError: ValidationErrorHandler | undefined
-  errorInterceptors: InterceptorStack<ResponseError<unknown, TRequest, TResponse>>
+  errorInterceptors: InterceptorStack<ResponseError<unknown, TRequest, TResponse>, RequestConfig<unknown, TRequest, TResponse>>
+  requestConfig: RequestConfig<unknown, TRequest, TResponse>
 }): Promise<CallResult<TRequest, TResponse>> {
   const isSuccess = result.status >= 200 && result.status < 300
   const contentType = result.contentType ?? getResponseContentType(result.headers)
@@ -684,7 +686,7 @@ async function settleResult<TRequest, TResponse>({
       request: result.request,
       response: result.response,
     })
-    await errorInterceptors.run(responseError)
+    await errorInterceptors.run(responseError, requestConfig)
     throw responseError
   }
   return { status: result.status, data: undefined, error, contentType, request: result.request, response: result.response }
@@ -700,17 +702,17 @@ export function createClientCore<TRequest = Request, TResponse = Response>(
   let config: ClientConfig<TRequest, TResponse> = { ...initialConfig }
 
   const interceptors: Interceptors<TRequest, TResponse> = {
-    request: createInterceptorStack<ResolvedRequest>(),
-    response: createInterceptorStack<TransportResult<unknown, TRequest, TResponse>>(),
-    error: createInterceptorStack<ResponseError<unknown, TRequest, TResponse>>(),
+    request: createInterceptorStack<ResolvedRequest, RequestConfig<unknown, TRequest, TResponse>>(),
+    response: createInterceptorStack<TransportResult<unknown, TRequest, TResponse>, RequestConfig<unknown, TRequest, TResponse>>(),
+    error: createInterceptorStack<ResponseError<unknown, TRequest, TResponse>, RequestConfig<unknown, TRequest, TResponse>>(),
   }
 
   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 resolvedRequest = await interceptors.request.run(request)
-    const result = await interceptors.response.run(await transport(resolvedRequest))
+    const resolvedRequest = await interceptors.request.run(request, requestConfig)
+    const result = await interceptors.response.run(await transport(resolvedRequest), requestConfig)
 
     return settleResult({
       result,
@@ -720,6 +722,7 @@ export function createClientCore<TRequest = Request, TResponse = Response>(
       validator: requestConfig.validator,
       onValidationError: requestConfig.onValidationError ?? config.onValidationError,
       errorInterceptors: interceptors.error,
+      requestConfig,
     })
   }) as ClientInstance<TRequest, TResponse>
 
@@ -733,7 +736,7 @@ export function createClientCore<TRequest = Request, TResponse = Response>(
     const query: Record<string, unknown> = { ...((requestConfig.query ?? requestConfig.params) as Record<string, unknown> | undefined) }
     return serializeUrl({
       parts: [requestConfig.baseURL ?? config.baseURL, requestConfig.url],
-      pathParams: requestConfig.path ?? {},
+      pathParams: (requestConfig.path ?? {}) as Record<string, unknown>,
       search: querySerializer(query, requestConfig.styles?.query),
       pathSerializer,
       pathStyles: requestConfig.styles?.path,