@kubb/ast 5.0.0-alpha.53 → 5.0.0-alpha.54

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/ast",
-  "version": "5.0.0-alpha.53",
+  "version": "5.0.0-alpha.54",
   "description": "Spec-agnostic AST layer for Kubb. Defines nodes, visitor pattern, and factory functions used across codegen plugins.",
   "keywords": [
     "ast",

package/src/mocks.ts

@@ -162,7 +162,7 @@ export function buildFixture(): InputNode {
         method: 'POST',
         path: '/pets',
         tags: ['pets'],
-        requestBody: { schema: createSchema({ type: 'ref', ref: 'NewPet' }) },
+        requestBody: { content: [{ contentType: 'application/json', schema: createSchema({ type: 'ref', ref: 'NewPet' }) }] },
         responses: [
           createResponse({
             statusCode: '201',

package/src/nodes/operation.ts

@@ -68,26 +68,41 @@ export type OperationNode = BaseNode & {
      * Human-readable request body description.
      */
     description?: string
-    /**
-     * Request body schema.
-     * For OpenAPI, this is the schema from the first `content` entry.
-     */
-    schema?: SchemaNode
-    /**
-     * Property keys to exclude from the generated request body type via `Omit<Type, Keys>`.
-     * Set when a referenced schema has `readOnly` fields that should be omitted in request types.
-     */
-    keysToOmit?: Array<string>
     /**
      * Whether the request body is required (`requestBody.required: true` in the spec).
      * When `false` or absent, the generated `data` parameter should be optional.
      */
     required?: boolean
     /**
-     * Media type of the request body (e.g. `'application/json'`, `'multipart/form-data'`).
-     * Extracted from the first `content` entry of the OpenAPI `requestBody`.
+     * All available content type entries for this request body.
+     *
+     * When the adapter `contentType` option is set, this array contains exactly one entry for
+     * that content type. Otherwise it contains one entry per content type declared in the spec,
+     * so that plugins can generate code for every variant (e.g. separate hooks for
+     * `application/json` and `multipart/form-data`).
+     *
+     * @example
+     * ```ts
+     * // spec has both application/json and multipart/form-data
+     * requestBody.content[0].contentType // 'application/json'
+     * requestBody.content[1].contentType // 'multipart/form-data'
+     * ```
      */
-    contentType?: string
+    content?: Array<{
+      /**
+       * The content type for this entry (e.g. `'application/json'`).
+       */
+      contentType: string
+      /**
+       * Request body schema for this content type.
+       */
+      schema?: SchemaNode
+      /**
+       * Property keys to exclude from the generated request body type via `Omit<Type, Keys>`.
+       * Set when a referenced schema has `readOnly` fields that should be omitted in request types.
+       */
+      keysToOmit?: Array<string>
+    }>
   }
   /**
    * Operation responses.

package/src/utils.ts

@@ -340,7 +340,7 @@ export function createOperationParams(node: OperationNode, options: CreateOperat
   const queryParams = casedParams.filter((p) => p.in === 'query')
   const headerParams = casedParams.filter((p) => p.in === 'header')
 
-  const bodyType = node.requestBody?.schema ? wrapType(resolver?.resolveDataName(node) ?? 'unknown') : undefined
+  const bodyType = node.requestBody?.content?.[0]?.schema ? wrapType(resolver?.resolveDataName(node) ?? 'unknown') : undefined
   const bodyRequired = node.requestBody?.required ?? false
 
   const queryGroupType = resolver

package/src/visitor.ts

@@ -272,7 +272,7 @@ function getChildren(node: Node, recurse: boolean): Array<Node> {
     case 'Output':
       return []
     case 'Operation':
-      return [...node.parameters, ...(node.requestBody?.schema ? [node.requestBody.schema] : []), ...node.responses]
+      return [...node.parameters, ...(node.requestBody?.content?.flatMap((c) => (c.schema ? [c.schema] : [])) ?? []), ...node.responses]
     case 'Schema': {
       const children: Array<Node> = []
 
@@ -440,7 +440,10 @@ export function transform(node: Node, options: TransformOptions): Node {
         requestBody: op.requestBody
           ? {
               ...op.requestBody,
-              schema: op.requestBody.schema ? transform(op.requestBody.schema, { ...options, parent: op }) : undefined,
+              content: op.requestBody.content?.map((c) => ({
+                ...c,
+                schema: c.schema ? transform(c.schema, { ...options, parent: op }) : undefined,
+              })),
             }
           : undefined,
         responses: op.responses.map((r) => transform(r, { ...options, parent: op })),