@kubb/adapter-oas 5.0.0-beta.25 → 5.0.0-beta.27

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/adapter-oas",
-  "version": "5.0.0-beta.25",
+  "version": "5.0.0-beta.27",
   "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",
@@ -43,11 +43,11 @@
     "registry": "https://registry.npmjs.org/"
   },
   "dependencies": {
-    "@redocly/openapi-core": "^2.30.6",
+    "@redocly/openapi-core": "^2.31.2",
     "oas": "^32.1.18",
     "oas-normalize": "^16.0.4",
     "swagger2openapi": "^7.0.8",
-    "@kubb/core": "5.0.0-beta.25"
+    "@kubb/core": "5.0.0-beta.27"
   },
   "devDependencies": {
     "@types/swagger2openapi": "^7.0.4",

package/src/adapter.ts

@@ -153,8 +153,8 @@ export const adapterOas = createAdapter<AdapterOas>((options) => {
     async parse(source) {
       const streamNode = await createStream(source)
 
-      const collect = async <T>(iter: AsyncIterable<T>): Promise<T[]> => {
-        const out: T[] = []
+      const collect = async <T>(iter: AsyncIterable<T>): Promise<Array<T>> => {
+        const out: Array<T> = []
         for await (const item of iter) out.push(item)
         return out
       }

package/src/discriminator.ts

@@ -14,7 +14,7 @@ export type DiscriminatorTarget = {
  * small pre-parsed subset of schemas (only the discriminator parents) rather than on all
  * schemas at once.
  */
-export function buildDiscriminatorChildMap(schemas: ast.SchemaNode[]): Map<string, DiscriminatorTarget> {
+export function buildDiscriminatorChildMap(schemas: Array<ast.SchemaNode>): Map<string, DiscriminatorTarget> {
   const childMap = new Map<string, DiscriminatorTarget>()
 
   for (const schema of schemas) {

package/src/parser.ts

@@ -1,4 +1,4 @@
-import { URLPath } from '@internals/utils'
+import { pascalCase, URLPath } from '@internals/utils'
 import { ast } from '@kubb/core'
 import BaseOas from 'oas'
 import { DEFAULT_PARSER_OPTIONS, enumExtensionKeys, SCHEMA_REF_PREFIX, typeOptionMap } from './constants.ts'
@@ -161,7 +161,7 @@ export function createSchemaParser(ctx: OasParserContext) {
       schema.additionalProperties === undefined
     ) {
       const [memberSchema] = schema.allOf as Array<SchemaObject | ReferenceObject>
-      const memberNode = parseSchema({ schema: memberSchema! as SchemaObject, name: null }, rawOptions)
+      const memberNode = parseSchema({ schema: memberSchema! as SchemaObject, name }, rawOptions)
       const { kind: _kind, ...memberNodeProps } = memberNode
       const mergedNullable = nullable || memberNode.nullable || undefined
       const mergedDefault = schema.default === null && mergedNullable ? undefined : (schema.default ?? memberNode.default)
@@ -208,7 +208,7 @@ export function createSchemaParser(ctx: OasParserContext) {
         }
         return true
       })
-      .map((s) => parseSchema({ schema: s as SchemaObject }, rawOptions))
+      .map((s) => parseSchema({ schema: s as SchemaObject, name }, rawOptions))
 
     const syntheticStart = allOfMembers.length
 
@@ -233,6 +233,7 @@ export function createSchemaParser(ctx: OasParserContext) {
                       properties: { [key]: resolved.properties[key] },
                       required: [key],
                     } as SchemaObject,
+                    name,
                   },
                   rawOptions,
                 ),
@@ -246,6 +247,9 @@ export function createSchemaParser(ctx: OasParserContext) {
 
     if (schema.properties) {
       const { allOf: _allOf, ...schemaWithoutAllOf } = schema
+      // Don't pass `name` here — the result must stay anonymous so it can be merged with the
+      // adjacent synthetic object in `mergeAdjacentObjectsLazy`. Nested enum qualification
+      // happens upstream via `convertObject`'s `setEnumName` propagation.
       allOfMembers.push(parseSchema({ schema: schemaWithoutAllOf }, rawOptions))
     }
 
@@ -301,7 +305,7 @@ export function createSchemaParser(ctx: OasParserContext) {
       const members = unionMembers.map((s) => {
         const ref = isReference(s) ? s.$ref : undefined
         const discriminatorValue = ast.findDiscriminator(discriminator?.mapping, ref)
-        const memberNode = parseSchema({ schema: s as SchemaObject }, rawOptions)
+        const memberNode = parseSchema({ schema: s as SchemaObject, name }, rawOptions)
 
         if (!discriminatorValue || !discriminator) {
           return memberNode
@@ -351,7 +355,7 @@ export function createSchemaParser(ctx: OasParserContext) {
     return ast.createSchema({
       type: 'union',
       ...unionBase,
-      members: ast.simplifyUnion(unionMembers.map((s) => parseSchema({ schema: s as SchemaObject }, rawOptions))),
+      members: ast.simplifyUnion(unionMembers.map((s) => parseSchema({ schema: s as SchemaObject, name }, rawOptions))),
     })
   }
 
@@ -646,7 +650,7 @@ export function createSchemaParser(ctx: OasParserContext) {
    */
   function convertArray({ schema, name, nullable, defaultValue, rawOptions, options }: SchemaContext): ast.SchemaNode {
     const rawItems = schema.items as SchemaObject | undefined
-    const itemName = rawItems?.enum?.length && name ? ast.enumPropName(null, name, options.enumSuffix) : undefined
+    const itemName = rawItems?.enum?.length && name ? ast.enumPropName(null, name, options.enumSuffix) : name
     const items = rawItems ? [parseSchema({ schema: rawItems, name: itemName }, rawOptions)] : []
 
     return ast.createSchema({
@@ -770,7 +774,7 @@ export function createSchemaParser(ctx: OasParserContext) {
     }
 
     if (Array.isArray(schema.type) && schema.type.length > 1) {
-      const nonNullTypes = schema.type.filter((t) => t !== 'null') as string[]
+      const nonNullTypes = schema.type.filter((t) => t !== 'null') as Array<string>
       const arrayNullable = schema.type.includes('null') || nullable || undefined
 
       if (nonNullTypes.length > 1) {
@@ -814,15 +818,17 @@ export function createSchemaParser(ctx: OasParserContext) {
   /**
    * Converts a dereferenced OAS parameter object into a `ParameterNode`.
    */
-  function parseParameter(options: ast.ParserOptions, param: Record<string, unknown>): ast.ParameterNode {
+  function parseParameter(options: ast.ParserOptions, param: Record<string, unknown>, parentName?: string): ast.ParameterNode {
     const required = (param['required'] as boolean | undefined) ?? false
+    const paramName = param['name'] as string
+    const schemaName = parentName && paramName ? pascalCase(`${parentName} ${paramName}`) : undefined
 
     const schema: ast.SchemaNode = param['schema']
-      ? parseSchema({ schema: param['schema'] as SchemaObject }, options)
+      ? parseSchema({ schema: param['schema'] as SchemaObject, name: schemaName }, options)
       : ast.createSchema({ type: typeOptionMap.get(options.unknownType)! })
 
     return ast.createParameter({
-      name: param['name'] as string,
+      name: paramName,
       in: param['in'] as ast.ParameterLocation,
       schema: {
         ...schema,
@@ -871,10 +877,10 @@ export function createSchemaParser(ctx: OasParserContext) {
    * Collects property names whose schema has a truthy boolean flag (`readOnly` or `writeOnly`).
    * `$ref` entries are skipped since their flags live on the dereferenced target.
    */
-  function collectPropertyKeysByFlag(schema: SchemaObject | null, flag: 'readOnly' | 'writeOnly'): string[] | null {
+  function collectPropertyKeysByFlag(schema: SchemaObject | null, flag: 'readOnly' | 'writeOnly'): Array<string> | null {
     if (!schema?.properties) return null
 
-    const keys: string[] = []
+    const keys: Array<string> = []
     for (const key in schema.properties) {
       const prop = schema.properties[key]
       if (prop && !isReference(prop) && (prop as Record<string, unknown>)[flag]) {
@@ -888,8 +894,10 @@ export function createSchemaParser(ctx: OasParserContext) {
    * Converts an OAS `Operation` into an `OperationNode`.
    */
   function parseOperation(options: ast.ParserOptions, operation: Operation): ast.OperationNode {
+    const operationId = operation.getOperationId()
+    const operationName = operationId ? pascalCase(operationId) : undefined
     const parameters: Array<ast.ParameterNode> = getParameters(document, operation).map((param) =>
-      parseParameter(options, param as unknown as Record<string, unknown>),
+      parseParameter(options, param as unknown as Record<string, unknown>, operationName),
     )
 
     // Determine which content types to include in requestBody.content.
@@ -898,6 +906,7 @@ export function createSchemaParser(ctx: OasParserContext) {
     const allContentTypes = ctx.contentType ? [ctx.contentType] : getRequestBodyContentTypes(document, operation)
 
     const requestBodyMeta = getRequestBodyMeta(operation)
+    const requestBodyName = operationName ? `${operationName}Request` : undefined
 
     const content = allContentTypes.flatMap((ct) => {
       const schema = getRequestSchema(document, operation, { contentType: ct })
@@ -905,7 +914,7 @@ export function createSchemaParser(ctx: OasParserContext) {
       return [
         {
           contentType: ct,
-          schema: ast.syncOptionality(parseSchema({ schema }, options), requestBodyMeta.required),
+          schema: ast.syncOptionality(parseSchema({ schema, name: requestBodyName }, options), requestBodyMeta.required),
           keysToOmit: collectPropertyKeysByFlag(schema, 'readOnly'),
         },
       ]
@@ -924,9 +933,13 @@ export function createSchemaParser(ctx: OasParserContext) {
       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 }, options)
+          ? parseSchema({ schema: responseSchema, name: responseName }, options)
           : ast.createSchema({
               type: typeOptionMap.get(options.emptySchemaType)!,
             })
@@ -946,7 +959,7 @@ export function createSchemaParser(ctx: OasParserContext) {
     const urlPath = new URLPath(operation.path)
 
     return ast.createOperation({
-      operationId: operation.getOperationId(),
+      operationId,
       method: operation.method.toUpperCase() as ast.HttpMethod,
       path: urlPath.path,
       tags: operation.getTags().map((tag) => tag.name),

package/src/resolvers.ts

@@ -86,7 +86,7 @@ export type OperationsOptions = {
  * ```
  */
 export function getParameters(document: Document, operation: Operation): Array<ParameterObject> {
-  const resolveParams = (params: unknown[]): Array<ParameterObject> =>
+  const resolveParams = (params: Array<unknown>): Array<ParameterObject> =>
     params.map((p) => dereferenceWithRef(document, p)).filter((p): p is ParameterObject => !!p && typeof p === 'object' && 'in' in p && 'name' in p)
 
   const operationParams = resolveParams(operation.schema?.parameters || [])
@@ -108,7 +108,7 @@ export function getParameters(document: Document, operation: Operation): Array<P
   return Array.from(paramMap.values())
 }
 
-function getResponseBody(responseBody: boolean | ResponseObject, contentType?: string): MediaTypeObject | false | [string, MediaTypeObject, ...string[]] {
+function getResponseBody(responseBody: boolean | ResponseObject, contentType?: string): MediaTypeObject | false | [string, MediaTypeObject, ...Array<string>] {
   if (!responseBody) return false
   if (isReference(responseBody)) return false
 
@@ -260,7 +260,7 @@ function hasStructuralKeywords(fragment: SchemaObject): boolean {
 export function flattenSchema(schema: SchemaObject | null): SchemaObject | null {
   if (!schema?.allOf || schema.allOf.length === 0) return schema ?? null
 
-  const allOfFragments = schema.allOf as SchemaObject[]
+  const allOfFragments = schema.allOf as Array<SchemaObject>
   if (allOfFragments.some((item) => isRef(item))) return schema
   if (allOfFragments.some(hasStructuralKeywords)) return schema
 
@@ -339,13 +339,13 @@ function* collectRefs(schema: unknown): Generator<string, void, undefined> {
  * ```
  */
 export function sortSchemas(schemas: Record<string, SchemaObject>): Record<string, SchemaObject> {
-  const deps = new Map<string, string[]>()
+  const deps = new Map<string, Array<string>>()
 
   for (const [name, schema] of Object.entries(schemas)) {
     deps.set(name, [...new Set(collectRefs(schema))])
   }
 
-  const sorted: string[] = []
+  const sorted: Array<string> = []
   const visited = new Set<string>()
 
   function visit(name: string, stack: Set<string>) {
@@ -402,7 +402,7 @@ function resolveSchemaRef(document: Document, schema: SchemaObject): SchemaObjec
 export function getSchemas(document: Document, { contentType }: GetSchemasOptions): GetSchemasResult {
   const components = document.components
 
-  const candidates: SchemaWithMetadata[] = [
+  const candidates: Array<SchemaWithMetadata> = [
     ...Object.entries((components?.schemas as Record<string, SchemaObject>) ?? {}).map(([name, schema]) => ({
       schema: resolveSchemaRef(document, schema),
       source: 'schemas' as const,
@@ -424,7 +424,7 @@ export function getSchemas(document: Document, { contentType }: GetSchemasOption
     ),
   ]
 
-  const normalizedNames = new Map<string, SchemaWithMetadata[]>()
+  const normalizedNames = new Map<string, Array<SchemaWithMetadata>>()
   for (const item of candidates) {
     const key = pascalCase(item.originalName)
     const bucket = normalizedNames.get(key) ?? []
@@ -529,7 +529,7 @@ export function buildSchemaNode(schema: SchemaObject, name: string | null | unde
  * // ['application/json', 'multipart/form-data']
  * ```
  */
-export function getRequestBodyContentTypes(document: Document, operation: Operation): string[] {
+export function getRequestBodyContentTypes(document: Document, operation: Operation): Array<string> {
   if (operation.schema.requestBody) {
     operation.schema.requestBody = dereferenceWithRef(document, operation.schema.requestBody)
   }

package/src/stream.ts

@@ -8,8 +8,8 @@ import type { AdapterOas, Document, SchemaObject } from './types.ts'
 
 export type PreScanResult = {
   refAliasMap: Map<string, ast.SchemaNode>
-  enumNames: string[]
-  circularNames: string[]
+  enumNames: Array<string>
+  circularNames: Array<string>
   discriminatorChildMap: Map<string, DiscriminatorTarget> | null
 }
 
@@ -74,10 +74,10 @@ export function preScan({
   parserOptions: ast.ParserOptions
   discriminator: AdapterOas['options']['discriminator']
 }): PreScanResult {
-  const allNodes: ast.SchemaNode[] = []
+  const allNodes: Array<ast.SchemaNode> = []
   const refAliasMap = new Map<string, ast.SchemaNode>()
-  const enumNames: string[] = []
-  const discriminatorParentNodes: ast.SchemaNode[] = []
+  const enumNames: Array<string> = []
+  const discriminatorParentNodes: Array<ast.SchemaNode> = []
 
   for (const [name, schema] of Object.entries(schemas)) {
     const node = parseSchema({ schema, name }, parserOptions)