@kubb/plugin-fetch 5.0.0-beta.100

package/templates/serializers.ts

@@ -0,0 +1,428 @@
+export type HeaderValue = string | number | boolean | null | undefined | object
+export type HeadersInit = Array<[string, HeaderValue]> | Record<string, HeaderValue>
+
+/**
+ * The OpenAPI query-parameter serialization style. `form` is the default; `spaceDelimited` and
+ * `pipeDelimited` join arrays with a space or pipe, and `deepObject` renders objects as
+ * `key[prop]=value`.
+ */
+export type QueryStyle = 'form' | 'spaceDelimited' | 'pipeDelimited' | 'deepObject'
+
+/**
+ * The serialization metadata shared by the styled parameter locations: the OpenAPI `style` (typed per
+ * location through `TStyle`), `explode`, and `allowReserved` (keeps RFC 3986 reserved characters
+ * unencoded, used by query and request bodies).
+ */
+export type SerializationStyle<TStyle = string> = {
+  style?: TStyle
+  explode?: boolean
+  allowReserved?: boolean
+}
+
+/**
+ * The per-parameter query serialization metadata carried by the generated request.
+ */
+export type QueryParamStyle = SerializationStyle<QueryStyle>
+
+/**
+ * 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
+ * into repeated keys and nested objects use the `deepObject` style.
+ */
+export type QuerySerializer = (params: Record<string, unknown>, options?: Record<string, QueryParamStyle>) => string
+
+/**
+ * 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 = {
+  explode?: boolean
+}
+
+/**
+ * The per-parameter header serialization metadata carried by the generated request. Headers use the
+ * OpenAPI `simple` style, so only `explode` is configurable.
+ *
+ * @example
+ * ```ts
+ * // styles.header: { 'X-Ids': { explode: false } }, header [3, 4] -> 'X-Ids: 3,4'
+ * // styles.header: { 'X-Filter': { explode: true } }, header { role: 'admin' } -> 'X-Filter: role=admin'
+ * ```
+ */
+export type HeaderParamStyle = {
+  explode?: boolean
+}
+
+/**
+ * The per-property `encoding` metadata for an `application/x-www-form-urlencoded` or
+ * `multipart/form-data` request body. `contentType` overrides the part's media type; `style` /
+ * `explode` / `allowReserved` follow the OpenAPI query rules for urlencoded bodies.
+ */
+export type BodyEncoding = SerializationStyle<QueryStyle> & {
+  contentType?: string
+}
+
+/**
+ * Serializes the request body. JSON by default; `FormData`, `URLSearchParams`, `Blob`,
+ * `ArrayBuffer`, and string bodies pass through untouched. The optional `encoding` argument carries
+ * the per-property OpenAPI `encoding` metadata for form bodies.
+ */
+export type BodySerializer = (args: { body: unknown; contentType?: string; encoding?: Record<string, BodyEncoding> }) => BodyInit | undefined
+
+/**
+ * The OpenAPI path-parameter serialization style. `simple` is the default and emits the bare value;
+ * `label` prefixes a `.` and `matrix` prefixes a `;name=` segment.
+ */
+export type PathStyle = 'simple' | 'label' | 'matrix'
+
+/**
+ * The per-parameter serialization metadata carried by the generated request. `style` selects the
+ * OpenAPI style and `explode` controls how arrays and objects expand.
+ */
+export type PathParamStyle = SerializationStyle<PathStyle>
+
+/**
+ * Serializes a single path parameter for interpolation into the URL, honoring the OpenAPI `style` /
+ * `explode` passed as `options`. Defaults to `simple` style with `explode: false`: primitives are
+ * URL-encoded, arrays join their members with commas, and objects flatten to `key,value` pairs.
+ */
+export type PathSerializer = (args: { name: string; value: unknown; options?: PathParamStyle }) => string
+
+/**
+ * The per-concern serializers, grouped so they can be set in one place and overridden per client or
+ * per call. Each field falls back to the matching `default*Serializer` when omitted.
+ */
+export type Serializers = {
+  query?: QuerySerializer
+  body?: BodySerializer
+  path?: PathSerializer
+}
+
+/**
+ * The per-parameter OpenAPI `style` / `explode` metadata a generated request carries, grouped by
+ * location and keyed by parameter name. Mirrors the `serializer` grouping and feeds the default
+ * serializers; `body` carries the form `encoding` for a urlencoded or multipart body.
+ */
+export type Styles = {
+  path?: Record<string, PathParamStyle>
+  query?: Record<string, QueryParamStyle>
+  header?: Record<string, HeaderParamStyle>
+  cookie?: Record<string, CookieParamStyle>
+  body?: Record<string, BodyEncoding>
+}
+
+function isFormBody(body: unknown): body is BodyInit {
+  return (
+    body instanceof FormData ||
+    body instanceof URLSearchParams ||
+    body instanceof Blob ||
+    body instanceof ArrayBuffer ||
+    ArrayBuffer.isView(body) ||
+    typeof body === 'string'
+  )
+}
+
+export function isDefaultJsonBody(body: unknown): boolean {
+  return body !== undefined && body !== null && !isFormBody(body)
+}
+
+function appendFormDataValue({ formData, key, value, contentType }: { formData: FormData; key: string; value: unknown; contentType?: string }): void {
+  if (value === undefined || value === null) return
+  if (value instanceof Blob) formData.append(key, value)
+  else if (typeof value === 'object' && !(value instanceof Date)) {
+    const json = JSON.stringify(value)
+    // A part's media type can only be set by wrapping the value in a typed Blob.
+    formData.append(key, contentType ? new Blob([json], { type: contentType }) : json)
+  } else formData.append(key, toValue(value))
+}
+
+/**
+ * Default body serializer: passes binary/form bodies through and JSON-serializes everything else.
+ * For `multipart/form-data` plain objects become `FormData` and for
+ * `application/x-www-form-urlencoded` they become `URLSearchParams`. When `encoding` is supplied each
+ * urlencoded property follows its OpenAPI `style` / `explode` / `allowReserved`.
+ *
+ * @example
+ * ```ts
+ * defaultBodySerializer({ body: { name: 'odie' } }) // '{"name":"odie"}'
+ * defaultBodySerializer({ body: { field: 'x' }, contentType: 'multipart/form-data' }) // FormData
+ * defaultBodySerializer({ body: { tags: ['a', 'b'] }, contentType: 'application/x-www-form-urlencoded', encoding: { tags: { explode: false } } }) // 'tags=a,b'
+ * defaultBodySerializer({ body: { meta: { a: 1 } }, contentType: 'multipart/form-data', encoding: { meta: { contentType: 'application/json' } } }) // FormData with a typed Blob part
+ * ```
+ */
+export const defaultBodySerializer: BodySerializer = ({ body, contentType, encoding }) => {
+  if (body === undefined || body === null) return undefined
+  if (isFormBody(body)) return body as BodyInit
+  if (contentType?.includes('multipart/form-data')) {
+    const formData = new FormData()
+    for (const [key, value] of Object.entries(body as Record<string, unknown>)) {
+      const partContentType = encoding?.[key]?.contentType
+      if (Array.isArray(value)) for (const item of value) appendFormDataValue({ formData, key, value: item, contentType: partContentType })
+      else appendFormDataValue({ formData, key, value, contentType: partContentType })
+    }
+    return formData
+  }
+  if (contentType?.includes('application/x-www-form-urlencoded')) {
+    if (encoding) return serializeUrlencodedBody(body as Record<string, unknown>, encoding)
+    return new URLSearchParams(body as Record<string, string>)
+  }
+  return JSON.stringify(body)
+}
+
+function serializeUrlencodedBody(body: Record<string, unknown>, encoding: Record<string, BodyEncoding>): string {
+  const parts: Array<string> = []
+  for (const [key, value] of Object.entries(body)) {
+    const propertyEncoding = encoding[key]
+    parts.push(...(propertyEncoding ? serializeStyledQueryParam({ key, value, options: propertyEncoding }) : serializeDefaultQueryParam(key, value)))
+  }
+  return parts.join('&')
+}
+
+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)))
+    return explode ? items.map((item) => `${name}=${item}`).join('; ') : `${name}=${items.join(',')}`
+  }
+  if (isRecord(value)) {
+    const entries = Object.entries(value).filter(([, item]) => notNullish(item))
+    if (explode) return entries.map(([key, item]) => `${key}=${encodeURIComponent(toValue(item))}`).join('; ')
+    return `${name}=${entries
+      .flatMap(([key, item]) => [key, item])
+      .map((item) => encodeURIComponent(toValue(item)))
+      .join(',')}`
+  }
+  return `${name}=${encodeURIComponent(toValue(value))}`
+}
+
+/**
+ * Serializes cookie parameters into a `Cookie` header value using the OpenAPI `form` style, joined
+ * with `; `. Values are URL-encoded and `explode` is honored per parameter.
+ *
+ * @example
+ * ```ts
+ * serializeCookies({ session: 'abc', ids: [1, 2] }) // 'session=abc; ids=1,2'
+ * serializeCookies({ ids: [1, 2] }, { ids: { explode: true } }) // 'ids=1; ids=2'
+ * ```
+ */
+export function serializeCookies(cookies: Record<string, unknown>, styles?: Record<string, CookieParamStyle>): string {
+  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 }))
+  }
+  return parts.join('; ')
+}
+
+function appendQueryValue({ search, key, value }: { search: URLSearchParams; key: string; value: unknown }): void {
+  if (value === undefined || value === null) return
+  if (Array.isArray(value)) {
+    for (const item of value) appendQueryValue({ search, key, value: item })
+    return
+  }
+  if (isRecord(value)) {
+    for (const [prop, propValue] of Object.entries(value)) {
+      appendQueryValue({ search, key: `${key}[${prop}]`, value: propValue })
+    }
+    return
+  }
+  search.append(key, toValue(value))
+}
+
+const queryDelimiters: Record<QueryStyle, string> = { form: ',', spaceDelimited: '%20', pipeDelimited: '|', deepObject: ',' }
+
+function notNullish(value: unknown): boolean {
+  return value !== undefined && value !== null
+}
+
+/**
+ * Renders a primitive parameter value as a string, serializing `Date` to ISO-8601 so dates are
+ * stable across path, query, cookie, and header locations rather than locale-dependent.
+ */
+function toValue(value: unknown): string {
+  return value instanceof Date ? value.toISOString() : String(value)
+}
+
+/**
+ * Percent-encodes a value, keeping RFC 3986 reserved characters intact (used when `allowReserved` is set).
+ */
+function encodeReserved(value: unknown): string {
+  return encodeURI(toValue(value))
+}
+
+/**
+ * Percent-encodes a value, escaping reserved characters (the default query/path encoder).
+ */
+function encodeComponent(value: unknown): string {
+  return encodeURIComponent(toValue(value))
+}
+
+/**
+ * Whether a value should expand into bracketed/keyed parts. Arrays and `Date` are excluded so they
+ * are serialized as a unit (a `Date` becomes an ISO string, not its enumerable own properties).
+ */
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value) && !(value instanceof Date)
+}
+
+/**
+ * Expands an object or array into `deepObject` query parts, recursing into nested values so
+ * `{ a: { b: { c: 1 } } }` becomes `a[b][c]=1`. Primitives terminate the recursion.
+ */
+function serializeDeepObject({ key, value, encode }: { key: string; value: unknown; encode: (value: unknown) => string }): Array<string> {
+  if (value === undefined || value === null) return []
+  if (Array.isArray(value)) return value.flatMap((item, index) => serializeDeepObject({ key: `${key}[${index}]`, value: item, encode }))
+  if (isRecord(value)) {
+    return Object.entries(value)
+      .filter(([, item]) => notNullish(item))
+      .flatMap(([prop, item]) => serializeDeepObject({ key: `${key}[${prop}]`, value: item, encode }))
+  }
+  return [`${encode(key)}=${encode(value)}`]
+}
+
+function serializeStyledQueryArray({
+  key,
+  value,
+  options,
+  encode,
+}: {
+  key: string
+  value: Array<unknown>
+  options: QueryParamStyle
+  encode: (value: unknown) => string
+}): Array<string> {
+  const items = value.filter(notNullish)
+  if (options.explode ?? true) return items.map((item) => `${encode(key)}=${encode(item)}`)
+  return [`${encode(key)}=${items.map(encode).join(queryDelimiters[options.style ?? 'form'])}`]
+}
+
+function serializeStyledQueryObject({
+  key,
+  value,
+  options,
+  encode,
+}: {
+  key: string
+  value: Record<string, unknown>
+  options: QueryParamStyle
+  encode: (value: unknown) => string
+}): Array<string> {
+  if ((options.style ?? 'form') === 'deepObject') return serializeDeepObject({ key, value, encode })
+  const entries = Object.entries(value).filter(([, item]) => notNullish(item))
+  if (options.explode ?? true) return entries.map(([prop, item]) => `${encode(prop)}=${encode(item)}`)
+  return [
+    `${encode(key)}=${entries
+      .flatMap(([prop, item]) => [prop, item])
+      .map(encode)
+      .join(',')}`,
+  ]
+}
+
+function serializeStyledQueryParam({ key, value, options }: { key: string; value: unknown; options: QueryParamStyle }): Array<string> {
+  if (value === undefined || value === null) return []
+  const encode = options.allowReserved ? encodeReserved : encodeComponent
+  if (Array.isArray(value)) return serializeStyledQueryArray({ key, value, options, encode })
+  if (isRecord(value)) return serializeStyledQueryObject({ key, value, options, encode })
+  return [`${encode(key)}=${encode(value)}`]
+}
+
+function serializeDefaultQueryParam(key: string, value: unknown): Array<string> {
+  const search = new URLSearchParams()
+  appendQueryValue({ search, key, value })
+  const result = search.toString()
+  return result ? [result] : []
+}
+
+/**
+ * Default query serializer. Members with `options` metadata follow their OpenAPI `style` / `explode`
+ * / `allowReserved`. Members without it keep the defaults: arrays explode into repeated keys and
+ * nested objects use the `deepObject` style (`key[prop]=value`).
+ *
+ * @example
+ * ```ts
+ * defaultQuerySerializer({ id: [3, 4, 5] }) // 'id=3&id=4&id=5'
+ * defaultQuerySerializer({ id: [3, 4, 5] }, { id: { style: 'form', explode: false } }) // 'id=3,4,5'
+ * defaultQuerySerializer({ id: [3, 4, 5] }, { id: { style: 'spaceDelimited', explode: false } }) // 'id=3%204%205'
+ * defaultQuerySerializer({ id: [3, 4, 5] }, { id: { style: 'pipeDelimited', explode: false } }) // 'id=3|4|5'
+ * defaultQuerySerializer({ a: { b: 1 } }, { a: { style: 'deepObject' } }) // 'a%5Bb%5D=1'
+ * defaultQuerySerializer({ a: { b: { c: 1 } } }, { a: { style: 'deepObject' } }) // 'a%5Bb%5D%5Bc%5D=1'
+ * ```
+ */
+export const defaultQuerySerializer: QuerySerializer = (params, options) => {
+  const parts: Array<string> = []
+  for (const [key, value] of Object.entries(params)) {
+    const paramOptions = options?.[key]
+    parts.push(...(paramOptions ? serializeStyledQueryParam({ key, value, options: paramOptions }) : serializeDefaultQueryParam(key, value)))
+  }
+  return parts.join('&')
+}
+
+function serializePathPrimitive({ name, value, style }: { name: string; value: unknown; style: PathStyle }): string {
+  const encoded = encodeComponent(value)
+  if (style === 'label') return `.${encoded}`
+  if (style === 'matrix') return `;${name}=${encoded}`
+  return encoded
+}
+
+function serializePathArray({ name, value, style, explode }: { name: string; value: Array<unknown>; style: PathStyle; explode: boolean }): string {
+  const items = value.map(encodeComponent)
+  if (style === 'label') return `.${items.join(explode ? '.' : ',')}`
+  if (style === 'matrix') return explode ? items.map((item) => `;${name}=${item}`).join('') : `;${name}=${items.join(',')}`
+  return items.join(',')
+}
+
+function serializePathObject({ name, value, style, explode }: { name: string; value: Record<string, unknown>; style: PathStyle; explode: boolean }): string {
+  const members = Object.entries(value).map(([key, item]) =>
+    explode ? `${encodeComponent(key)}=${encodeComponent(item)}` : `${encodeComponent(key)},${encodeComponent(item)}`,
+  )
+  if (style === 'label') return `.${members.join(explode ? '.' : ',')}`
+  if (style === 'matrix') return explode ? members.map((member) => `;${member}`).join('') : `;${name}=${members.join(',')}`
+  return members.join(',')
+}
+
+/**
+ * Default path serializer honoring the OpenAPI `style` / `explode` metadata. Without metadata it
+ * falls back to `simple` style with `explode: false`. Replaces the previous `String(value)`
+ * interpolation, which emitted `[object Object]` for object path params.
+ *
+ * @example
+ * ```ts
+ * defaultPathSerializer({ name: 'id', value: [3, 4, 5] }) // '3,4,5'
+ * defaultPathSerializer({ name: 'id', value: [3, 4, 5], options: { style: 'label', explode: true } }) // '.3.4.5'
+ * defaultPathSerializer({ name: 'id', value: [3, 4, 5], options: { style: 'matrix', explode: true } }) // ';id=3;id=4;id=5'
+ * defaultPathSerializer({ name: 'pt', value: { x: 1, y: 2 } }) // 'x,1,y,2'
+ * ```
+ */
+export const defaultPathSerializer: PathSerializer = ({ name, value, options }) => {
+  if (value === undefined || value === null) return ''
+  const style = options?.style ?? 'simple'
+  const explode = options?.explode ?? false
+  if (Array.isArray(value)) return serializePathArray({ name, value, style, explode })
+  if (isRecord(value)) return serializePathObject({ name, value, style, explode })
+  return serializePathPrimitive({ name, value, style })
+}
+
+function serializeHeaderValue(value: unknown, explode: boolean): string {
+  if (Array.isArray(value)) return value.filter(notNullish).map(toValue).join(',')
+  if (!isRecord(value)) return toValue(value)
+  const entries = Object.entries(value).filter(([, item]) => notNullish(item))
+  if (explode) return entries.map(([key, item]) => `${key}=${toValue(item)}`).join(',')
+  return entries
+    .flatMap(([key, item]) => [key, item])
+    .map(toValue)
+    .join(',')
+}
+
+/**
+ * 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
+ * through untouched.
+ */
+export function applyHeaderStyles(headers: HeadersInit | undefined, styles: Record<string, HeaderParamStyle> | undefined): HeadersInit | undefined {
+  if (!headers || !styles) return headers
+  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]
+    return [key, serializeHeaderValue(value, style.explode ?? false)] as [string, HeaderValue]
+  })
+}

package/templates/standardSchema.ts

@@ -0,0 +1,54 @@
+/**
+ * A Standard Schema-compatible validator: a minimal duck-type covering Zod v3/v4, valibot, and
+ * arktype schemas. Only the `~standard.validate` method is required at runtime.
+ */
+export type StandardSchemaValidator<TOutput = unknown> = {
+  readonly '~standard': {
+    validate(value: unknown): StandardSchemaResult<TOutput> | Promise<StandardSchemaResult<TOutput>>
+  }
+}
+
+/**
+ * The two possible outcomes of a Standard Schema `validate` call. A successful result carries
+ * `value`; a failed result carries `issues`.
+ */
+export type StandardSchemaResult<TOutput> = { readonly value: TOutput; readonly issues?: undefined } | { readonly issues: ReadonlyArray<StandardSchemaIssue> }
+
+/**
+ * One validation issue from a Standard Schema `validate` call.
+ */
+export type StandardSchemaIssue = {
+  readonly message?: string
+  readonly path?: ReadonlyArray<PropertyKey | { readonly key: PropertyKey }>
+}
+
+/**
+ * Thrown by `validateStandardSchema` when validation fails. Carries the raw `issues` array from
+ * the schema's `validate` result so callers receive a uniform error shape regardless of which
+ * schema library is in use.
+ */
+export class ParseError extends Error {
+  readonly issues: ReadonlyArray<StandardSchemaIssue>
+
+  constructor({ issues, message }: { issues: ReadonlyArray<StandardSchemaIssue>; message?: string }) {
+    super(message ?? 'Validation failed')
+    this.name = 'ParseError'
+    this.issues = issues
+  }
+}
+
+/**
+ * Validates `value` against a Standard Schema-compatible `schema`. Returns the parsed output on
+ * success; throws `ParseError` with the schema's `issues` on failure. Handles both sync and async
+ * `validate` implementations transparently.
+ *
+ * @example
+ * const pet = await validateStandardSchema(PetSchema, rawData)
+ */
+export async function validateStandardSchema<TOutput>(schema: StandardSchemaValidator<TOutput>, value: unknown): Promise<TOutput> {
+  const result = await schema['~standard'].validate(value)
+  if (result.issues) {
+    throw new ParseError({ issues: result.issues })
+  }
+  return result.value as TOutput
+}