@kubb/adapter-oas 5.0.0-alpha.16 → 5.0.0-alpha.17

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kubb/adapter-oas",
-  "version": "5.0.0-alpha.16",
+  "version": "5.0.0-alpha.17",
   "description": "OpenAPI / Swagger adapter for Kubb — converts OAS input into a @kubb/ast RootNode.",
   "keywords": [
     "openapi",
@@ -46,8 +46,8 @@
     "openapi-types": "^12.1.3",
     "remeda": "^2.33.6",
     "swagger2openapi": "^7.0.8",
-    "@kubb/ast": "5.0.0-alpha.16",
-    "@kubb/core": "5.0.0-alpha.16"
+    "@kubb/ast": "5.0.0-alpha.17",
+    "@kubb/core": "5.0.0-alpha.17"
   },
   "devDependencies": {
     "@types/swagger2openapi": "^7.0.4",

package/src/adapter.ts

@@ -1,12 +1,11 @@
 import path from 'node:path'
-import { createRoot } from '@kubb/ast'
+import { collectImports, createRoot } from '@kubb/ast'
 import type { AdapterSource } from '@kubb/core'
 import { createAdapter } from '@kubb/core'
 import { DEFAULT_PARSER_OPTIONS } from './constants.ts'
 import { resolveServerUrl } from './oas/resolveServerUrl.ts'
 import { parseFromConfig } from './oas/utils.ts'
 import { createOasParser } from './parser.ts'
-import { getImports } from './refResolver.ts'
 import type { OasAdapter } from './types.ts'
 
 export const adapterOasName = 'oas' satisfies OasAdapter['name']
@@ -65,7 +64,15 @@ export const adapterOas = createAdapter<OasAdapter>((options) => {
       nameMapping,
     },
     getImports(node, resolve) {
-      return getImports({ node, nameMapping, resolve })
+      return collectImports({
+        node,
+        nameMapping,
+        resolve: (schemaName) => {
+          const result = resolve(schemaName)
+          if (!result) return
+          return { name: [result.name], path: result.path }
+        },
+      })
     },
     async parse(source) {
       const fakeConfig = sourceToFakeConfig(source)

package/src/constants.ts

@@ -1,5 +1,4 @@
-import type { SchemaType } from '@kubb/ast/types'
-import type { ParserOptions } from './types.ts'
+import type { ParserOptions, SchemaType } from '@kubb/ast/types'
 
 /**
  * Default values for all `Options` fields.

package/src/parser.ts

@@ -1,18 +1,26 @@
 import { URLPath } from '@internals/utils'
 import {
-  applyDiscriminatorEnum,
+  childName,
+  createDiscriminantNode,
   createOperation,
   createParameter,
   createProperty,
   createResponse,
   createRoot,
   createSchema,
+  enumPropName,
   extractRefName,
+  findDiscriminator,
+  type InferSchemaNode,
   mediaTypes,
-  mergeAdjacentAnonymousObjects,
+  mergeAdjacentObjects,
   narrowSchema,
+  type ParserOptions,
+  resolveNames,
   schemaTypes,
-  simplifyUnionMembers,
+  setDiscriminatorEnum,
+  setEnumName,
+  simplifyUnion,
 } from '@kubb/ast'
 import type {
   DistributiveOmit,
@@ -31,14 +39,9 @@ import type {
   StatusCode,
 } from '@kubb/ast/types'
 import { DEFAULT_PARSER_OPTIONS, enumExtensionKeys, formatMap } from './constants.ts'
-import { createDiscriminantNode, resolveDiscriminatorValue } from './discriminator.ts'
-import type { InferSchemaNode } from './infer.ts'
-import { applyEnumName, resolveChildName, resolveEnumPropName } from './naming.ts'
 import type { Oas } from './oas/Oas.ts'
 import type { contentType, Operation, ReferenceObject, SchemaObject } from './oas/types.ts'
 import { flattenSchema, isDiscriminator, isNullable, isReference } from './oas/utils.ts'
-import { resolveRefs as resolveRefsNode } from './refResolver.ts'
-import type { ParserOptions } from './types.ts'
 
 /**
  * Construction-time options for `createOasParser`.
@@ -119,7 +122,7 @@ export type OasParser = {
    * Map from original `$ref` paths to their collision-resolved schema names.
    * e.g. `'#/components/schemas/Order'` → `'OrderSchema'`
    *
-   * Pass this to the standalone `getImports()` to resolve imports without holding
+   * Pass this to the standalone `collectImports()` to resolve imports without holding
    * a reference to the full parser or OAS instance.
    */
   nameMapping: Map<string, string>
@@ -306,7 +309,7 @@ export function createOasParser(oas: Oas, { contentType }: OasParserOptions = {}
         const inOneOf = parentUnion.some((oneOfItem) => isReference(oneOfItem) && oneOfItem.$ref === childRef)
         const inMapping = Object.values(deref.discriminator.mapping ?? {}).some((v) => v === childRef)
         if (inOneOf || inMapping) {
-          const discriminatorValue = resolveDiscriminatorValue(deref.discriminator.mapping, childRef)
+          const discriminatorValue = findDiscriminator(deref.discriminator.mapping, childRef)
           if (discriminatorValue) {
             filteredDiscriminantValues.push({ propertyName: deref.discriminator.propertyName, value: discriminatorValue })
           }
@@ -351,13 +354,13 @@ export function createOasParser(oas: Oas, { contentType }: OasParserOptions = {}
     // Inject a synthetic single-property object for each discriminant value collected from
     // filtered discriminator parents so that child schemas carry the narrowed literal type.
     for (const { propertyName, value } of filteredDiscriminantValues) {
-      allOfMembers.push(createDiscriminantNode(propertyName, value))
+      allOfMembers.push(createDiscriminantNode({ propertyName, value }))
     }
 
-    // Merge consecutive anonymous object members within the synthetic portion — see `mergeAdjacentAnonymousObjects`.
+    // Merge consecutive anonymous object members within the synthetic portion — see `mergeAdjacentObjects`.
     return createSchema({
       type: 'intersection',
-      members: [...mergeAdjacentAnonymousObjects(allOfMembers.slice(0, syntheticStart)), ...mergeAdjacentAnonymousObjects(allOfMembers.slice(syntheticStart))],
+      members: [...mergeAdjacentObjects(allOfMembers.slice(0, syntheticStart)), ...mergeAdjacentObjects(allOfMembers.slice(syntheticStart))],
       ...renderSchemaBase(schema, name, nullable, defaultValue),
     })
   }
@@ -371,6 +374,21 @@ export function createOasParser(oas: Oas, { contentType }: OasParserOptions = {}
    * adding common fields next to a discriminated union.
    */
   function convertUnion({ schema, name, nullable, defaultValue, rawOptions }: SchemaContext): SchemaNode {
+    function pickDiscriminatorPropertyNode(node: SchemaNode, propertyName: string): SchemaNode | undefined {
+      const objectNode = narrowSchema(node, 'object')
+      const discriminatorProperty = objectNode?.properties?.find((property) => property.name === propertyName)
+
+      if (!discriminatorProperty) {
+        return undefined
+      }
+
+      return createSchema({
+        type: 'object',
+        primitive: 'object',
+        properties: [discriminatorProperty],
+      })
+    }
+
     const unionMembers = [...(schema.oneOf ?? []), ...(schema.anyOf ?? [])]
     const unionBase = {
       ...renderSchemaBase(schema, name, nullable, defaultValue),
@@ -391,44 +409,53 @@ export function createOasParser(oas: Oas, { contentType }: OasParserOptions = {}
       : undefined
 
     if (sharedPropertiesNode || discriminator?.mapping) {
-      return createSchema({
+      const members = unionMembers.map((s) => {
+        const ref = isReference(s) ? s.$ref : undefined
+        const discriminatorValue = findDiscriminator(discriminator?.mapping, ref)
+        const memberNode = convertSchema({ schema: s as SchemaObject }, rawOptions)
+
+        if (!discriminatorValue || !discriminator) {
+          return memberNode
+        }
+
+        const narrowedDiscriminatorNode = sharedPropertiesNode
+          ? pickDiscriminatorPropertyNode(
+              setDiscriminatorEnum({
+                node: sharedPropertiesNode,
+                propertyName: discriminator.propertyName,
+                values: [discriminatorValue],
+              }),
+              discriminator.propertyName,
+            )
+          : undefined
+
+        return createSchema({
+          type: 'intersection',
+          members: [memberNode, narrowedDiscriminatorNode ?? createDiscriminantNode({ propertyName: discriminator.propertyName, value: discriminatorValue })],
+        })
+      })
+
+      const unionNode = createSchema({
         type: 'union',
         ...unionBase,
-        members: unionMembers.map((s) => {
-          const ref = isReference(s) ? s.$ref : undefined
-          const discriminatorValue = resolveDiscriminatorValue(discriminator?.mapping, ref)
-          const memberNode = convertSchema({ schema: s as SchemaObject }, rawOptions)
-
-          if (sharedPropertiesNode) {
-            const narrowedProperties =
-              discriminatorValue && discriminator
-                ? applyDiscriminatorEnum({
-                    node: sharedPropertiesNode,
-                    propertyName: discriminator.propertyName,
-                    values: [discriminatorValue],
-                  })
-                : sharedPropertiesNode
-
-            return createSchema({
-              type: 'intersection',
-              members: [memberNode, narrowedProperties],
-            })
-          }
+        members,
+      })
 
-          if (!discriminatorValue || !discriminator) return memberNode
+      if (!sharedPropertiesNode) {
+        return unionNode
+      }
 
-          return createSchema({
-            type: 'intersection',
-            members: [memberNode, createDiscriminantNode(discriminator.propertyName, discriminatorValue)],
-          })
-        }),
+      return createSchema({
+        type: 'intersection',
+        ...renderSchemaBase(schema, name, nullable, defaultValue),
+        members: [unionNode, sharedPropertiesNode],
       })
     }
 
     return createSchema({
       type: 'union',
       ...unionBase,
-      members: simplifyUnionMembers(unionMembers.map((s) => convertSchema({ schema: s as SchemaObject }, rawOptions))),
+      members: simplifyUnion(unionMembers.map((s) => convertSchema({ schema: s as SchemaObject }, rawOptions))),
     })
   }
 
@@ -549,7 +576,7 @@ export function createOasParser(oas: Oas, { contentType }: OasParserOptions = {}
     // x-enumNames / x-enum-varnames: named variants with explicit labels take priority.
     const extensionKey = enumExtensionKeys.find((key) => key in schema)
     if (extensionKey || enumPrimitive === 'number' || enumPrimitive === 'integer' || enumPrimitive === 'boolean') {
-      const enumType = (enumPrimitive === 'number' || enumPrimitive === 'integer' ? 'number' : enumPrimitive === 'boolean' ? 'boolean' : 'string') as
+      const enumPrimitiveType = (enumPrimitive === 'number' || enumPrimitive === 'integer' ? 'number' : enumPrimitive === 'boolean' ? 'boolean' : 'string') as
         | 'number'
         | 'boolean'
         | 'string'
@@ -559,11 +586,11 @@ export function createOasParser(oas: Oas, { contentType }: OasParserOptions = {}
 
       return createSchema({
         ...enumBase,
-        enumType,
+        primitive: enumPrimitiveType,
         namedEnumValues: sourceValues.map((label, index) => ({
           name: String(label),
           value: extensionKey ? (filteredValues[index] ?? label) : label,
-          format: enumType,
+          primitive: enumPrimitiveType,
         })),
       })
     }
@@ -595,13 +622,13 @@ export function createOasParser(oas: Oas, { contentType }: OasParserOptions = {}
           const resolvedPropSchema = propSchema as SchemaObject
           const propNullable = isNullable(resolvedPropSchema)
 
-          const childName = resolveChildName(name, propName)
-          const propNode = convertSchema({ schema: resolvedPropSchema, name: childName }, rawOptions)
-          let schemaNode = applyEnumName(propNode, name, propName, options.enumSuffix)
+          const resolvedChildName = childName(name, propName)
+          const propNode = convertSchema({ schema: resolvedPropSchema, name: resolvedChildName }, rawOptions)
+          let schemaNode = setEnumName(propNode, name, propName, options.enumSuffix)
 
           const tupleNode = narrowSchema(schemaNode, 'tuple')
           if (tupleNode?.items) {
-            const namedItems = tupleNode.items.map((item) => applyEnumName(item, name, propName, options.enumSuffix))
+            const namedItems = tupleNode.items.map((item) => setEnumName(item, name, propName, options.enumSuffix))
             if (namedItems.some((item, i) => item !== tupleNode.items![i])) {
               schemaNode = { ...tupleNode, items: namedItems }
             }
@@ -657,8 +684,8 @@ export function createOasParser(oas: Oas, { contentType }: OasParserOptions = {}
     if (isDiscriminator(schema) && schema.discriminator.mapping) {
       const discPropName = schema.discriminator.propertyName
       const values = Object.keys(schema.discriminator.mapping)
-      const enumName = name ? resolveEnumPropName(name, discPropName, options.enumSuffix) : undefined
-      return applyDiscriminatorEnum({ node: objectNode, propertyName: discPropName, values, enumName })
+      const enumName = name ? enumPropName(name, discPropName, options.enumSuffix) : undefined
+      return setDiscriminatorEnum({ node: objectNode, propertyName: discPropName, values, enumName })
     }
 
     return objectNode
@@ -697,7 +724,7 @@ export function createOasParser(oas: Oas, { contentType }: OasParserOptions = {}
     const rawItems = schema.items as SchemaObject | undefined
     // When the items schema contains an inline enum, derive a named identifier
     // so generators can emit a standalone enum declaration.
-    const itemName = rawItems?.enum?.length && name ? resolveEnumPropName(undefined, name, options.enumSuffix) : undefined
+    const itemName = rawItems?.enum?.length && name ? enumPropName(undefined, name, options.enumSuffix) : undefined
     const items = rawItems ? [convertSchema({ schema: rawItems, name: itemName }, rawOptions)] : []
 
     return createSchema({
@@ -991,7 +1018,7 @@ export function createOasParser(oas: Oas, { contentType }: OasParserOptions = {}
     node: SchemaNode,
     resolveName: (ref: string) => string | undefined,
     resolveEnumName?: (name: string) => string | undefined,
-  ): SchemaNode => resolveRefsNode({ node, nameMapping, resolveName, resolveEnumName })
+  ): SchemaNode => resolveNames({ node, nameMapping, resolveName, resolveEnumName })
 
   return {
     parse,

package/src/types.ts

@@ -1,33 +1,8 @@
+import type { ParserOptions } from '@kubb/ast/types'
 import type { AdapterFactoryOptions } from '@kubb/core'
 import type { Oas as OasClass } from './oas/Oas.ts'
 import type { contentType } from './oas/types.ts'
 
-/**
- * Controls how various OAS constructs are mapped to Kubb AST nodes.
- */
-export type ParserOptions = {
-  /**
-   * How `format: 'date-time'` schemas are represented. `false` falls through to a plain string.
-   */
-  dateType: false | 'string' | 'stringOffset' | 'stringLocal' | 'date'
-  /**
-   * Whether `type: 'integer'` and `format: 'int64'` produce `number` or `bigint` nodes.
-   */
-  integerType?: 'number' | 'bigint'
-  /**
-   * AST type used when no schema type can be inferred.
-   */
-  unknownType: 'any' | 'unknown' | 'void'
-  /**
-   * AST type used for completely empty schemas (`{}`).
-   */
-  emptySchemaType: 'any' | 'unknown' | 'void'
-  /**
-   * Suffix appended to derived enum names when building property schema names.
-   */
-  enumSuffix: 'enum' | (string & {})
-}
-
 export type OasAdapterOptions = {
   /**
    * Validate the OpenAPI spec before parsing.

package/src/discriminator.ts

@@ -1,25 +0,0 @@
-import { createProperty, createSchema } from '@kubb/ast'
-import type { SchemaNode } from '@kubb/ast/types'
-
-export function resolveDiscriminatorValue(mapping: Record<string, string> | undefined, ref: string | undefined): string | undefined {
-  if (!mapping || !ref) return undefined
-  return Object.entries(mapping).find(([, value]) => value === ref)?.[0]
-}
-
-export function createDiscriminantNode(propertyName: string, value: string): SchemaNode {
-  return createSchema({
-    type: 'object',
-    primitive: 'object',
-    properties: [
-      createProperty({
-        name: propertyName,
-        schema: createSchema({
-          type: 'enum',
-          primitive: 'string',
-          enumValues: [value],
-        }),
-        required: true,
-      }),
-    ],
-  })
-}

package/src/infer.ts

@@ -1,85 +0,0 @@
-import type {
-  ArraySchemaNode,
-  DateSchemaNode,
-  DatetimeSchemaNode,
-  EnumSchemaNode,
-  IntersectionSchemaNode,
-  NumberSchemaNode,
-  ObjectSchemaNode,
-  RefSchemaNode,
-  ScalarSchemaNode,
-  SchemaNode,
-  StringSchemaNode,
-  TimeSchemaNode,
-  UnionSchemaNode,
-} from '@kubb/ast/types'
-import type { SchemaObject } from './oas/types.ts'
-import type { ParserOptions } from './types.ts'
-
-/**
- * Maps each `dateType` option value to the AST node produced by `format: 'date-time'`.
- */
-type DateTimeNodeByDateType = {
-  date: DateSchemaNode
-  string: DatetimeSchemaNode
-  stringOffset: DatetimeSchemaNode
-  stringLocal: DatetimeSchemaNode
-  false: StringSchemaNode
-}
-
-/**
- * Resolves the AST node produced by `format: 'date-time'` based on the `dateType` option.
- */
-type ResolveDateTimeNode<TDateType extends ParserOptions['dateType']> = DateTimeNodeByDateType[TDateType extends keyof DateTimeNodeByDateType
-  ? TDateType
-  : 'string']
-
-/**
- * Single source of truth: ordered list of `[shape, SchemaNode]` pairs.
- * `InferSchemaNode` walks this tuple in order and returns the node type of the first matching entry.
- * Parameterized over `TDateType` so `format: 'date-time'` resolves to the correct node based on the option.
- */
-type SchemaNodeMap<TDateType extends ParserOptions['dateType'] = 'string'> = [
-  [{ $ref: string }, RefSchemaNode],
-  [{ allOf: ReadonlyArray<unknown>; properties: object }, IntersectionSchemaNode],
-  [{ allOf: readonly [unknown, unknown, ...unknown[]] }, IntersectionSchemaNode],
-  [{ allOf: ReadonlyArray<unknown> }, SchemaNode],
-  [{ oneOf: ReadonlyArray<unknown> }, UnionSchemaNode],
-  [{ anyOf: ReadonlyArray<unknown> }, UnionSchemaNode],
-  [{ const: null }, ScalarSchemaNode],
-  [{ const: string | number | boolean }, EnumSchemaNode],
-  [{ type: ReadonlyArray<string> }, UnionSchemaNode],
-  [{ type: 'array'; enum: ReadonlyArray<unknown> }, ArraySchemaNode],
-  [{ enum: ReadonlyArray<unknown> }, EnumSchemaNode],
-  [{ type: 'object' }, ObjectSchemaNode],
-  [{ additionalProperties: boolean | {} }, ObjectSchemaNode],
-  [{ type: 'array' }, ArraySchemaNode],
-  [{ items: object }, ArraySchemaNode],
-  [{ prefixItems: ReadonlyArray<unknown> }, ArraySchemaNode],
-  [{ type: string; format: 'date-time' }, ResolveDateTimeNode<TDateType>],
-  [{ type: string; format: 'date' }, DateSchemaNode],
-  [{ type: string; format: 'time' }, TimeSchemaNode],
-  [{ format: 'date-time' }, ResolveDateTimeNode<TDateType>],
-  [{ format: 'date' }, DateSchemaNode],
-  [{ format: 'time' }, TimeSchemaNode],
-  [{ type: 'string' }, StringSchemaNode],
-  [{ type: 'number' }, NumberSchemaNode],
-  [{ type: 'integer' }, NumberSchemaNode],
-  [{ type: 'bigint' }, NumberSchemaNode],
-  [{ type: string }, ScalarSchemaNode],
-  [{ minLength: number }, StringSchemaNode],
-  [{ maxLength: number }, StringSchemaNode],
-  [{ pattern: string }, StringSchemaNode],
-  [{ minimum: number }, NumberSchemaNode],
-  [{ maximum: number }, NumberSchemaNode],
-]
-
-export type InferSchemaNode<
-  TSchema extends SchemaObject,
-  TDateType extends ParserOptions['dateType'] = 'string',
-  TEntries extends ReadonlyArray<[object, SchemaNode]> = SchemaNodeMap<TDateType>,
-> = TEntries extends [infer TEntry extends [object, SchemaNode], ...infer TRest extends ReadonlyArray<[object, SchemaNode]>]
-  ? TSchema extends TEntry[0]
-    ? TEntry[1]
-    : InferSchemaNode<TSchema, TDateType, TRest>
-  : SchemaNode

package/src/naming.ts

@@ -1,25 +0,0 @@
-import { pascalCase } from '@internals/utils'
-import { narrowSchema } from '@kubb/ast'
-import type { SchemaNode } from '@kubb/ast/types'
-
-export function resolveChildName(parentName: string | undefined, propName: string): string | undefined {
-  return parentName ? pascalCase([parentName, propName].join(' ')) : undefined
-}
-
-export function resolveEnumPropName(parentName: string | undefined, propName: string, enumSuffix: string): string {
-  return pascalCase([parentName, propName, enumSuffix].filter(Boolean).join(' '))
-}
-
-export function applyEnumName(propNode: SchemaNode, parentName: string | undefined, propName: string, enumSuffix: string): SchemaNode {
-  const enumNode = narrowSchema(propNode, 'enum')
-
-  if (enumNode?.primitive === 'boolean') {
-    return { ...propNode, name: undefined }
-  }
-
-  if (enumNode) {
-    return { ...propNode, name: resolveEnumPropName(parentName, propName, enumSuffix) }
-  }
-
-  return propNode
-}

package/src/refResolver.ts

@@ -1,65 +0,0 @@
-import { collect, extractRefName, narrowSchema, schemaTypes, transform } from '@kubb/ast'
-import type { SchemaNode } from '@kubb/ast/types'
-import type { KubbFile } from '@kubb/fabric-core/types'
-
-/**
- * Collects import entries for all `ref` schema nodes in `node`.
- */
-export function getImports({
-  node,
-  nameMapping,
-  resolve,
-}: {
-  node: SchemaNode
-  nameMapping: Map<string, string>
-  resolve: (schemaName: string) => { name: string; path: string } | undefined
-}): Array<KubbFile.Import> {
-  return collect<KubbFile.Import>(node, {
-    schema(schemaNode): KubbFile.Import | undefined {
-      if (schemaNode.type !== 'ref' || !schemaNode.ref) return
-
-      const rawName = extractRefName(schemaNode.ref)
-      const schemaName = nameMapping.get(rawName) ?? rawName
-      const result = resolve(schemaName)
-      if (!result) return
-
-      return { name: [result.name], path: result.path }
-    },
-  })
-}
-
-/**
- * Walks a schema tree and resolves `ref`/`enum` names through callbacks.
- */
-export function resolveRefs({
-  node,
-  nameMapping,
-  resolveName,
-  resolveEnumName,
-}: {
-  node: SchemaNode
-  nameMapping: Map<string, string>
-  resolveName: (ref: string) => string | undefined
-  resolveEnumName?: (name: string) => string | undefined
-}): SchemaNode {
-  return transform(node, {
-    schema(schemaNode) {
-      const schemaRef = narrowSchema(schemaNode, schemaTypes.ref)
-
-      if (schemaRef && (schemaRef.ref || schemaRef.name)) {
-        const rawRef = schemaRef.ref ?? schemaRef.name!
-        const resolved = resolveName(nameMapping.get(rawRef) ?? rawRef)
-        if (resolved) {
-          return { ...schemaNode, name: resolved }
-        }
-      }
-
-      if (schemaNode.type === 'enum' && schemaNode.name) {
-        const resolved = (resolveEnumName ?? resolveName)(schemaNode.name)
-        if (resolved) {
-          return { ...schemaNode, name: resolved }
-        }
-      }
-    },
-  }) as SchemaNode
-}