@kubb/adapter-oas 5.0.0-beta.28 → 5.0.0-beta.29

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/adapter-oas",
-  "version": "5.0.0-beta.28",
+  "version": "5.0.0-beta.29",
   "description": "OpenAPI and Swagger adapter for Kubb. Parses and validates OAS 2.0/3.x specifications into a @kubb/ast RootNode for downstream code generation plugins.",
   "keywords": [
     "adapter",
@@ -47,7 +47,7 @@
     "oas": "^32.1.18",
     "oas-normalize": "^16.0.4",
     "swagger2openapi": "^7.0.8",
-    "@kubb/core": "5.0.0-beta.28"
+    "@kubb/core": "5.0.0-beta.29"
   },
   "devDependencies": {
     "@types/swagger2openapi": "^7.0.4",

package/src/parser.ts

@@ -8,11 +8,11 @@ import {
   buildSchemaNode,
   flattenSchema,
   getDateType,
-  getMediaType,
   getParameters,
   getPrimitiveType,
   getRequestBodyContentTypes,
   getRequestSchema,
+  getResponseBodyContentTypes,
   getResponseSchema,
   getSchemas,
   getSchemaType,
@@ -931,28 +931,37 @@ export function createSchemaParser(ctx: OasParserContext) {
 
     const responses: Array<ast.ResponseNode> = operation.getResponseStatusCodes().map((statusCode) => {
       const responseObj = operation.getResponseByStatusCode(statusCode)
-      const responseSchema = getResponseSchema(document, operation, statusCode, { contentType: ctx.contentType })
 
       // Use `Status<code>` (matching plugin-ts's resolveResponseStatusName convention) so the
       // qualified names for nested enums don't collide with top-level component schemas that
       // happen to be named `<operation><statusCode>` (e.g. `GetMaintenance200`).
       const responseName = operationName ? `${operationName}Status${statusCode}` : undefined
-      const schema =
-        responseSchema && Object.keys(responseSchema).length > 0
-          ? parseSchema({ schema: responseSchema, name: responseName }, options)
-          : ast.createSchema({
-              type: typeOptionMap.get(options.emptySchemaType)!,
-            })
+      const { description } = getResponseMeta(responseObj)
+
+      const parseEntrySchema = (contentType?: string) => {
+        const raw = getResponseSchema(document, operation, statusCode, { contentType })
+        const node =
+          raw && Object.keys(raw).length > 0
+            ? parseSchema({ schema: raw, name: responseName }, options)
+            : ast.createSchema({ type: typeOptionMap.get(options.emptySchemaType)! })
+        return { schema: node, keysToOmit: collectPropertyKeysByFlag(raw, 'writeOnly') }
+      }
 
-      const { description, content } = getResponseMeta(responseObj)
-      const mediaType = content ? getMediaType(Object.keys(content)[0] ?? '') : getMediaType(operation.contentType ?? '')
+      // Build one entry per declared response content type so plugins can union the variants.
+      // When a global contentType is configured, restrict to that single type (mirrors requestBody).
+      const responseContentTypes = ctx.contentType ? [ctx.contentType] : getResponseBodyContentTypes(document, operation, statusCode)
+      const content = responseContentTypes.map((contentType) => ({ contentType, ...parseEntrySchema(contentType) }))
+
+      // Body-less responses keep a single fallback entry so the response still resolves to a
+      // (void/any) schema, matching how `requestBody` only carries schemas inside `content`.
+      if (content.length === 0) {
+        content.push({ contentType: operation.contentType || 'application/json', ...parseEntrySchema(ctx.contentType) })
+      }
 
       return ast.createResponse({
         statusCode: statusCode as ast.StatusCode,
         description,
-        schema,
-        mediaType,
-        keysToOmit: collectPropertyKeysByFlag(responseSchema, 'writeOnly'),
+        content,
       })
     })
 

package/src/resolvers.ts

@@ -541,3 +541,33 @@ export function getRequestBodyContentTypes(document: Document, operation: Operat
   // Do not bail out on isReference — the content is already present on the merged object.
   return body.content ? Object.keys(body.content) : []
 }
+
+/**
+ * Returns all response content type keys for an operation at a given status code.
+ *
+ * Response `$ref`s are resolved in-place first — the same mutation `getResponseSchema` performs —
+ * so the returned list reflects the available content types even for referenced responses.
+ *
+ * @example
+ * ```ts
+ * getResponseBodyContentTypes(document, operation, 200)
+ * // ['application/json', 'application/xml']
+ * ```
+ */
+export function getResponseBodyContentTypes(document: Document, operation: Operation, statusCode: string | number): Array<string> {
+  if (operation.schema.responses) {
+    const responses = operation.schema.responses
+    for (const key in responses) {
+      const schema = responses[key]
+      if (schema && isReference(schema)) {
+        responses[key] = resolveRef<any>(document, schema.$ref)
+      }
+    }
+  }
+
+  const responseObj = operation.getResponseByStatusCode(statusCode)
+  if (!responseObj || typeof responseObj !== 'object' || isReference(responseObj)) return []
+
+  const body = responseObj as { content?: Record<string, unknown> }
+  return body.content ? Object.keys(body.content) : []
+}