@kubb/plugin-fetch 5.7.0 → 5.7.2

package/dist/templates/serializers.d.ts

@@ -22,10 +22,14 @@ export type SerializationStyle<TStyle = string> = {
   explode?: boolean;
   allowReserved?: boolean;
 };
+/** The media type of a parameter described with `content`; JSON sends one JSON-encoded value. */
+export type ParamContentType = {
+  contentType?: string;
+};
 /**
  * The per-parameter query serialization metadata carried by the generated request.
  */
-export type QueryParamStyle = SerializationStyle<QueryStyle>;
+export type QueryParamStyle = SerializationStyle<QueryStyle> & ParamContentType;
 /**
  * Serializes the query object into a search string. The optional second argument carries the
  * per-parameter OpenAPI `style` / `explode` / `allowReserved` metadata; without it arrays explode
@@ -36,7 +40,7 @@ export type QuerySerializer = (params: Record<string, unknown>, options?: Record
  * The per-parameter cookie serialization metadata carried by the generated request. Cookies use the
  * OpenAPI `form` style, so only `explode` is configurable.
  */
-export type CookieParamStyle = {
+export type CookieParamStyle = ParamContentType & {
   explode?: boolean;
 };
 /**
@@ -49,7 +53,7 @@ export type CookieParamStyle = {
  * // styles.header: { 'X-Filter': { explode: true } }, header { role: 'admin' } -> 'X-Filter: role=admin'
  * ```
  */
-export type HeaderParamStyle = {
+export type HeaderParamStyle = ParamContentType & {
   explode?: boolean;
 };
 /**

package/kubb-extension.json

@@ -194,6 +194,47 @@
       "label": "SDK Name",
       "description": "Root client name for the generated SDK",
       "type": "text"
+    },
+    {
+      "key": "returnType",
+      "path": ["returnType"],
+      "label": "Return Type",
+      "description": "What a generated function resolves to. full is the whole result with status and error, data is only the success body when it throws, and plain is the client's own promise",
+      "type": "select",
+      "default": "full",
+      "choices": [
+        {
+          "value": "full"
+        },
+        {
+          "value": "data"
+        },
+        {
+          "value": "plain"
+        }
+      ]
+    },
+    {
+      "key": "throwOnErrorDefault",
+      "path": ["throwOnErrorDefault"],
+      "label": "Throw on Error",
+      "description": "Throw when a request fails. A per-call throwOnError overrides it",
+      "type": "boolean",
+      "default": true
+    },
+    {
+      "key": "banner",
+      "path": ["output", "banner"],
+      "label": "Banner",
+      "description": "Text added at the top of every generated file",
+      "type": "text"
+    },
+    {
+      "key": "footer",
+      "path": ["output", "footer"],
+      "label": "Footer",
+      "description": "Text added at the end of every generated file",
+      "type": "text"
     }
   ]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/plugin-fetch",
-  "version": "5.7.0",
+  "version": "5.7.2",
   "description": "Generate a slim, type-safe HTTP client with Kubb based on the native Fetch api.",
   "keywords": [
     "api-client",
@@ -80,17 +80,17 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@kubb/plugin-ts": "^5.0.14",
-    "@kubb/plugin-zod": "^5.4.12"
+    "@kubb/plugin-ts": "^5.0.16",
+    "@kubb/plugin-zod": "^5.5.0"
   },
   "devDependencies": {
     "@internals/client": "0.0.0",
     "@internals/shared": "0.0.0",
-    "kubb": "^5.10.3",
-    "typescript": "^6.0.3"
+    "kubb": "^5.12.8",
+    "typescript": "^7.0.2"
   },
   "peerDependencies": {
-    "kubb": "^5.10.3"
+    "kubb": "^5.12.8"
   },
   "engines": {
     "node": ">=22.12"

package/src/plugin.ts

@@ -1,7 +1,7 @@
 import path from 'node:path'
 import { createSdkGenerator, defaultMacros, isValidatorEnabled, resolverClient } from '@internals/client'
 import { createGroupConfig } from '@internals/shared'
-import { addGenerator, assertPluginOption, defineExtension, injectFile, Resolver, setMacros, setResolver, useConfig } from 'kubb/kit'
+import { addGenerator, defineExtension, injectFile, Resolver, setMacros, setResolver, useConfig } from 'kubb/kit'
 import { compatibility } from '../kubb-extension.json'
 import { version } from '../package.json'
 import { pluginTsName } from '@kubb/plugin-ts'
@@ -74,27 +74,6 @@ export const pluginFetch = defineExtension<PluginFetch>({
       resolver: userResolver ? Resolver.merge<ResolverClient>(resolverClient, userResolver) : resolverClient,
     }
 
-    const allowedReturnTypes = ['full', 'data', 'plain'] satisfies Array<ResolvedOptions['returnType']>
-    assertPluginOption({ plugin: pluginFetchName, option: 'returnType', value: returnType, allowed: allowedReturnTypes })
-    // An override replaces `returnType` per operation, so its values are checked too.
-    for (const [index, entry] of override.entries()) {
-      if (entry.options.returnType === undefined) continue
-      assertPluginOption({
-        plugin: pluginFetchName,
-        option: `override[${index}].options.returnType`,
-        value: entry.options.returnType,
-        allowed: allowedReturnTypes,
-      })
-    }
-    if (resolved.sdk) {
-      assertPluginOption({
-        plugin: pluginFetchName,
-        option: 'sdk.mode',
-        value: resolved.sdk.mode,
-        allowed: ['tag', 'flat'] satisfies Array<NonNullable<ResolvedOptions['sdk']>['mode']>,
-      })
-    }
-
     setResolver(resolved.resolver)
     setMacros([...defaultMacros, ...(options.macros ?? [])])
 

package/templates/serializers.ts

@@ -25,10 +25,15 @@ export type SerializationStyle<TStyle = string> = {
   allowReserved?: boolean
 }
 
+/** The media type of a parameter described with `content`; JSON sends one JSON-encoded value. */
+export type ParamContentType = {
+  contentType?: string
+}
+
 /**
  * The per-parameter query serialization metadata carried by the generated request.
  */
-export type QueryParamStyle = SerializationStyle<QueryStyle>
+export type QueryParamStyle = SerializationStyle<QueryStyle> & ParamContentType
 
 /**
  * Serializes the query object into a search string. The optional second argument carries the
@@ -41,7 +46,7 @@ export type QuerySerializer = (params: Record<string, unknown>, options?: Record
  * The per-parameter cookie serialization metadata carried by the generated request. Cookies use the
  * OpenAPI `form` style, so only `explode` is configurable.
  */
-export type CookieParamStyle = {
+export type CookieParamStyle = ParamContentType & {
   explode?: boolean
 }
 
@@ -55,7 +60,7 @@ export type CookieParamStyle = {
  * // styles.header: { 'X-Filter': { explode: true } }, header { role: 'admin' } -> 'X-Filter: role=admin'
  * ```
  */
-export type HeaderParamStyle = {
+export type HeaderParamStyle = ParamContentType & {
   explode?: boolean
 }
 
@@ -195,6 +200,11 @@ function serializeUrlencodedBody(body: Record<string, unknown>, encoding: Record
   return parts.join('&')
 }
 
+function isJsonMediaType(contentType: string | undefined): boolean {
+  const type = contentType?.split(';')[0]?.trim().toLowerCase()
+  return type === 'application/json' || !!type?.endsWith('+json')
+}
+
 function serializeCookie({ name, value, explode }: { name: string; value: unknown; explode: boolean }): string {
   if (Array.isArray(value)) {
     const items = value.filter(notNullish).map((item) => encodeURIComponent(toValue(item)))
@@ -225,7 +235,12 @@ export function serializeCookies(cookies: Record<string, unknown>, styles?: Reco
   const parts: Array<string> = []
   for (const [name, value] of Object.entries(cookies)) {
     if (value === undefined || value === null) continue
-    parts.push(serializeCookie({ name, value, explode: styles?.[name]?.explode ?? false }))
+    const style = styles?.[name]
+    if (isJsonMediaType(style?.contentType)) {
+      parts.push(`${name}=${encodeURIComponent(JSON.stringify(value, jsonReplacer))}`)
+      continue
+    }
+    parts.push(serializeCookie({ name, value, explode: style?.explode ?? false }))
   }
   return parts.join('; ')
 }
@@ -368,6 +383,10 @@ export const defaultQuerySerializer: QuerySerializer = (params, options) => {
   const parts: Array<string> = []
   for (const [key, value] of Object.entries(params)) {
     const paramOptions = options?.[key]
+    if (notNullish(value) && isJsonMediaType(paramOptions?.contentType)) {
+      parts.push(`${encodeComponent(key)}=${encodeComponent(JSON.stringify(value, jsonReplacer))}`)
+      continue
+    }
     parts.push(...(paramOptions ? serializeStyledQueryParam({ key, value, options: paramOptions }) : serializeDefaultQueryParam(key, value)))
   }
   return parts.join('&')
@@ -429,6 +448,11 @@ function serializeHeaderValue(value: unknown, explode: boolean): string {
     .join(',')
 }
 
+/** Header values must be Latin-1, so non-ASCII characters become JSON `\uXXXX` escapes. */
+function toAsciiJson(value: unknown): string {
+  return JSON.stringify(value, jsonReplacer).replace(/[\u007f-\uffff]/g, (char) => `\\u${char.charCodeAt(0).toString(16).padStart(4, '0')}`)
+}
+
 /**
  * Serializes array and object header parameters with the OpenAPI `simple` style before they are
  * merged. Header values are not URL-encoded. Primitive values and headers without metadata pass
@@ -439,7 +463,9 @@ export function applyHeaderStyles(headers: HeadersInit | undefined, styles: Reco
   const entries = Array.isArray(headers) ? headers : Object.entries(headers)
   return entries.map(([key, value]) => {
     const style = styles[key]
-    if (!style || value === undefined || value === null || typeof value !== 'object') return [key, value] as [string, HeaderValue]
+    if (!style || value === undefined || value === null) return [key, value] as [string, HeaderValue]
+    if (isJsonMediaType(style.contentType)) return [key, toAsciiJson(value)] as [string, HeaderValue]
+    if (typeof value !== 'object') return [key, value] as [string, HeaderValue]
     return [key, serializeHeaderValue(value, style.explode ?? false)] as [string, HeaderValue]
   })
 }