@kubb/adapter-oas 5.0.0-beta.53 → 5.0.0-beta.55

package/src/resolvers.ts

@@ -1,13 +1,12 @@
 import { pascalCase } from '@internals/utils'
 import { Diagnostics } from '@kubb/core'
 import type { ast } from '@kubb/core'
-import type { ParameterObject, ServerObject } from 'oas/types'
-import { isRef } from 'oas/types'
-import { matchesMimeType } from 'oas/utils'
 import { formatMap, SCHEMA_REF_PREFIX, specialCasedFormats, structuralKeys } from './constants.ts'
 import { isReference } from './guards.ts'
+import { isJsonMimeType } from './mime.ts'
+import { getRequestContent, getResponseByStatusCode } from './operation.ts'
 import { dereferenceWithRef, resolveRef } from './refs.ts'
-import type { ContentType, Document, MediaTypeObject, Operation, ResponseObject, SchemaObject } from './types.ts'
+import type { ContentType, Document, MediaTypeObject, Operation, ParameterObject, ResponseObject, SchemaObject, ServerObject } from './types.ts'
 
 /**
  * Replaces `{variable}` placeholders in an OpenAPI server URL with provided values.
@@ -133,7 +132,7 @@ function getResponseBody(responseBody: boolean | ResponseObject, contentType?: s
   let availableContentType: string | undefined
   const contentTypes = Object.keys(body.content)
   for (const mt of contentTypes) {
-    if (matchesMimeType.json(mt)) {
+    if (isJsonMimeType(mt)) {
       availableContentType = mt
       break
     }
@@ -172,7 +171,7 @@ export function getResponseSchema(document: Document, operation: Operation, stat
     }
   }
 
-  const responseBody = getResponseBody(operation.getResponseByStatusCode(statusCode), options.contentType)
+  const responseBody = getResponseBody(getResponseByStatusCode({ document, operation, statusCode }), options.contentType)
 
   if (responseBody === false) {
     return {}
@@ -200,7 +199,7 @@ export function getRequestSchema(document: Document, operation: Operation, optio
     operation.schema.requestBody = dereferenceWithRef(document, operation.schema.requestBody)
   }
 
-  const requestBody = operation.getRequestBody(options.contentType)
+  const requestBody = getRequestContent({ document, operation, mediaType: options.contentType })
 
   if (requestBody === false) {
     return null
@@ -271,7 +270,7 @@ export function flattenSchema(schema: SchemaObject | null): SchemaObject | null
   if (!schema?.allOf || schema.allOf.length === 0) return schema ?? null
 
   const allOfFragments = schema.allOf as Array<SchemaObject>
-  if (allOfFragments.some((item) => isRef(item))) return schema
+  if (allOfFragments.some((item) => isReference(item))) return schema
   if (allOfFragments.some(hasStructuralKeywords)) return schema
 
   const merged: SchemaObject = { ...schema }
@@ -575,7 +574,7 @@ export function getResponseBodyContentTypes(document: Document, operation: Opera
     }
   }
 
-  const responseObj = operation.getResponseByStatusCode(statusCode)
+  const responseObj = getResponseByStatusCode({ document, operation, statusCode })
   if (!responseObj || typeof responseObj !== 'object' || isReference(responseObj)) return []
 
   const body = responseObj as { content?: Record<string, unknown> }

package/src/stream.ts

@@ -1,7 +1,7 @@
 import { ast } from '@kubb/core'
-import type BaseOas from 'oas'
 import { SCHEMA_REF_PREFIX } from './constants.ts'
 import { buildDiscriminatorChildMap, patchDiscriminatorNode } from './discriminator.ts'
+import { getOperations } from './operation.ts'
 import type { SchemaParser } from './parser.ts'
 import { resolveServerUrl } from './resolvers.ts'
 import { reportSchemaDiagnostics } from './schemaDiagnostics.ts'
@@ -116,7 +116,7 @@ export function preScan({
   schemas,
   parseSchema,
   parseOperation,
-  baseOas,
+  document,
   parserOptions,
   discriminator,
   dedupe,
@@ -124,7 +124,7 @@ export function preScan({
   schemas: Record<string, SchemaObject>
   parseSchema: (entry: { schema: SchemaObject; name: string }, options: ast.ParserOptions) => ast.SchemaNode
   parseOperation: SchemaParser['parseOperation']
-  baseOas: BaseOas
+  document: Document
   parserOptions: ast.ParserOptions
   discriminator: AdapterOas['options']['discriminator']
   dedupe: boolean
@@ -157,12 +157,9 @@ export function preScan({
     // One extra parse pass over operations so duplicates in request/response bodies are seen.
     // Reuses the already-parsed `allNodes` for schemas, no second schema parse.
     const operationNodes: Array<ast.OperationNode> = []
-    for (const methods of Object.values(baseOas.getPaths())) {
-      for (const operation of Object.values(methods)) {
-        if (!operation) continue
-        const operationNode = parseOperation(parserOptions, operation)
-        if (operationNode) operationNodes.push(operationNode)
-      }
+    for (const operation of getOperations(document)) {
+      const operationNode = parseOperation(parserOptions, operation)
+      if (operationNode) operationNodes.push(operationNode)
     }
 
     dedupePlan = createDedupePlan({ schemaNodes: allNodes, operationNodes, schemaNames: Object.keys(schemas), circularNames })
@@ -172,11 +169,16 @@ export function preScan({
     }
   }
 
-  return { refAliasMap, enumNames, circularNames, discriminatorChildMap, dedupePlan }
+  // Enum names that duplicate an earlier schema's content are never emitted, so they are not
+  // advertised to plugins either.
+  const aliasNames = dedupePlan?.aliasNames
+  const emittedEnumNames = aliasNames && aliasNames.size > 0 ? enumNames.filter((name) => !aliasNames.has(name)) : enumNames
+
+  return { refAliasMap, enumNames: emittedEnumNames, circularNames, discriminatorChildMap, dedupePlan }
 }
 
 /**
- * Creates a lazy `InputStreamNode` from already-resolved adapter state.
+ * Creates a lazy `InputNode<true>` from already-resolved adapter state.
  *
  * The schema and operation iterables each start a fresh parse pass on every
  * `[Symbol.asyncIterator]()` call. This lets multiple plugins consume the same
@@ -187,7 +189,7 @@ export function preScan({
  *
  * @example
  * ```ts
- * const streamNode = createInputStream({ schemas, parseSchema, parseOperation, baseOas, parserOptions, refAliasMap, discriminatorChildMap, meta })
+ * const streamNode = createInputStream({ schemas, parseSchema, parseOperation, document, parserOptions, refAliasMap, discriminatorChildMap, meta })
  * for await (const schema of streamNode.schemas) {
  *   // each call to for-await restarts from the first schema
  * }
@@ -197,7 +199,7 @@ export function createInputStream({
   schemas,
   parseSchema,
   parseOperation,
-  baseOas,
+  document,
   parserOptions,
   refAliasMap,
   discriminatorChildMap,
@@ -207,20 +209,20 @@ export function createInputStream({
   schemas: Record<string, SchemaObject>
   parseSchema: SchemaParser['parseSchema']
   parseOperation: SchemaParser['parseOperation']
-  baseOas: BaseOas
+  document: Document
   parserOptions: ast.ParserOptions
   refAliasMap: Map<string, ast.SchemaNode>
   discriminatorChildMap: Map<string, DiscriminatorTarget> | null
   dedupePlan: ast.DedupePlan | null
   meta: ast.InputMeta
-}): ast.InputStreamNode {
+}): ast.InputNode<true> {
   // Rewrites a top-level schema against the dedupe plan: a structurally identical sibling
   // becomes a `ref` alias to the canonical one (keeping its own name); otherwise nested
   // duplicates are collapsed while the schema's own root is preserved.
   const rewriteTopLevelSchema = (node: ast.SchemaNode): ast.SchemaNode => {
     if (!dedupePlan) return node
 
-    const canonical = dedupePlan.canonicalBySignature.get(ast.schemaSignature(node))
+    const canonical = dedupePlan.canonicalBySignature.get(ast.signatureOf(node))
     if (canonical && canonical.name !== node.name) {
       return ast.createSchema({
         type: 'ref',
@@ -231,7 +233,7 @@ export function createInputStream({
       })
     }
 
-    return ast.applyDedupe(node, dedupePlan.canonicalBySignature, true)
+    return ast.applyDedupe(node, dedupePlan, true)
   }
 
   const schemasIterable: AsyncIterable<ast.SchemaNode> = {
@@ -243,6 +245,11 @@ export function createInputStream({
         }
 
         for (const [name, schema] of Object.entries(schemas)) {
+          // A top-level schema whose content duplicates an earlier one is not emitted: every
+          // ref to it is repointed at the first schema with that content, so its model would
+          // be dead code.
+          if (dedupePlan?.aliasNames.has(name)) continue
+
           // Inline ref aliases: replace the alias entry with its target's parsed node
           // (keeping the alias name). Skip the first parse entirely for alias entries
           // since that result is never used.
@@ -263,12 +270,9 @@ export function createInputStream({
   const operationsIterable: AsyncIterable<ast.OperationNode> = {
     [Symbol.asyncIterator]() {
       return (async function* () {
-        for (const methods of Object.values(baseOas.getPaths())) {
-          for (const operation of Object.values(methods)) {
-            if (!operation) continue
-            const node = parseOperation(parserOptions, operation)
-            if (node) yield dedupePlan ? ast.applyDedupe(node, dedupePlan.canonicalBySignature) : node
-          }
+        for (const operation of getOperations(document)) {
+          const node = parseOperation(parserOptions, operation)
+          if (node) yield dedupePlan ? ast.applyDedupe(node, dedupePlan) : node
         }
       })()
     },

package/src/types.ts

@@ -1,16 +1,10 @@
-// external packages
-
 import type { AdapterFactoryOptions } from '@kubb/core'
 import type { ast } from '@kubb/core'
-import type { Operation as OASOperation } from 'oas/operation'
-import type {
-  DiscriminatorObject as OASDiscriminatorObject,
-  OASDocument,
-  MediaTypeObject as OASMediaTypeObject,
-  ResponseObject as OASResponseObject,
-  SchemaObject as OASSchemaObject,
-} from 'oas/types'
-import type { OpenAPIV3 } from 'openapi-types'
+import type { JSONSchema4, JSONSchema6, JSONSchema7 } from 'json-schema'
+import type { OpenAPIV3, OpenAPIV3_1 } from 'openapi-types'
+import type { Operation } from './operation.ts'
+
+export type { Operation }
 
 /**
  * Content-type string for selecting request/response schemas from an OpenAPI spec.
@@ -36,7 +30,18 @@ export type ContentType = 'application/json' | (string & {})
  * }
  * ```
  */
-export type SchemaObject = OASSchemaObject & {
+export type SchemaObject = {
+  externalDocs?: unknown
+  xml?: unknown
+  $schema?: string
+  deprecated?: boolean
+  example?: unknown
+  examples?: Array<unknown>
+  nullable?: boolean
+  readOnly?: boolean
+  writeOnly?: boolean
+  discriminator?: DiscriminatorObject
+  'x-readme-ref-name'?: string
   /**
    * OAS 3.0 vendor extension: marks a schema as nullable without using `type: ['null', ...]`.
    */
@@ -66,7 +71,7 @@ export type SchemaObject = OASSchemaObject & {
    * Enum values for this schema (narrowed from `unknown[]`).
    */
   enum?: Array<string | number | boolean | null>
-}
+} & (OpenAPIV3.SchemaObject | OpenAPIV3_1.SchemaObject | JSONSchema4 | JSONSchema6 | JSONSchema7)
 
 /**
  * HTTP method as a lowercase string (`'get' | 'post' | ...`).
@@ -76,17 +81,22 @@ export type HttpMethod = Lowercase<ast.HttpMethod>
 /**
  * Normalized OpenAPI document after parsing.
  */
-export type Document = OASDocument
+export type Document = (OpenAPIV3.Document | OpenAPIV3_1.Document) & Record<string, unknown>
+
+/**
+ * Single operation object (the `get`/`post`/… entry on a path item) plus any vendor extensions.
+ */
+export type OperationObject = (OpenAPIV3.OperationObject | OpenAPIV3_1.OperationObject) & Record<string, unknown>
 
 /**
- * API operation extracted from an OpenAPI document.
+ * Path item object holding the operations and shared parameters for a single URL path.
  */
-export type Operation = OASOperation
+export type PathItemObject = OpenAPIV3.PathItemObject | OpenAPIV3_1.PathItemObject
 
 /**
  * Discriminator object for `oneOf`/`anyOf` schemas in OpenAPI.
  */
-export type DiscriminatorObject = OASDiscriminatorObject
+export type DiscriminatorObject = OpenAPIV3.DiscriminatorObject | OpenAPIV3_1.DiscriminatorObject
 
 /**
  * OpenAPI reference object pointing to a schema definition via `$ref`.
@@ -96,12 +106,29 @@ export type ReferenceObject = OpenAPIV3.ReferenceObject
 /**
  * OpenAPI response object from a spec that contains schema, status code, and headers.
  */
-export type ResponseObject = OASResponseObject
+export type ResponseObject = OpenAPIV3.ResponseObject | OpenAPIV3_1.ResponseObject
+
+/**
+ * OpenAPI request body object that maps content types to their media type objects.
+ */
+export type RequestBodyObject = OpenAPIV3.RequestBodyObject | OpenAPIV3_1.RequestBodyObject
 
 /**
  * OpenAPI media type object that maps a content-type string to its schema.
  */
-export type MediaTypeObject = OASMediaTypeObject
+export type MediaTypeObject = OpenAPIV3.MediaTypeObject | OpenAPIV3_1.MediaTypeObject
+
+/**
+ * OpenAPI parameter object, narrowed so `in` is always one of the four valid locations.
+ */
+export type ParameterObject = {
+  in: 'cookie' | 'header' | 'path' | 'query'
+} & (OpenAPIV3.ParameterObject | OpenAPIV3_1.ParameterObject)
+
+/**
+ * OpenAPI server object describing a base URL and its `{variable}` substitutions.
+ */
+export type ServerObject = OpenAPIV3.ServerObject | OpenAPIV3_1.ServerObject
 
 /**
  * Configuration options for the OpenAPI adapter. Controls spec validation,