@kubb/adapter-oas 5.0.0-alpha.34 → 5.0.0-alpha.36

package/src/adapter.ts

@@ -1,6 +1,4 @@
-import { collectImports, createImport, createInput } from '@kubb/ast'
-import type { InputNode } from '@kubb/ast/types'
-import { createAdapter } from '@kubb/core'
+import { ast, createAdapter } from '@kubb/core'
 import { DEFAULT_PARSER_OPTIONS } from './constants.ts'
 import { applyDiscriminatorInheritance } from './discriminator.ts'
 import { parseFromConfig, validateDocument } from './factory.ts'
@@ -49,7 +47,7 @@ export const adapterOas = createAdapter<AdapterOas>((options) => {
   // Let-binding so parse() can replace it with a simple reassignment (no clear+loop).
   let nameMapping = new Map<string, string>()
   let parsedDocument: Document | null
-  let inputNode: InputNode | null
+  let inputNode: ast.InputNode | null
 
   return {
     name: adapterOasName,
@@ -75,14 +73,14 @@ export const adapterOas = createAdapter<AdapterOas>((options) => {
       return inputNode
     },
     getImports(node, resolve) {
-      return collectImports({
+      return ast.collectImports({
         node,
         nameMapping,
         resolve: (schemaName) => {
           const result = resolve(schemaName)
           if (!result) return
 
-          return createImport({ name: [result.name], path: result.path })
+          return ast.createImport({ name: [result.name], path: result.path })
         },
       })
     },
@@ -112,7 +110,7 @@ export const adapterOas = createAdapter<AdapterOas>((options) => {
       // Expose the raw document so consumers (e.g. plugin-redoc) can access it.
       parsedDocument = document
 
-      inputNode = createInput({
+      inputNode = ast.createInput({
         ...node,
         meta: {
           title: document.info?.title,

package/src/constants.ts

@@ -1,5 +1,4 @@
-import { schemaTypes } from '@kubb/ast'
-import type { ParserOptions, ScalarSchemaType, SchemaType } from '@kubb/ast/types'
+import { ast } from '@kubb/core'
 
 /**
  * Default parser options applied when no explicit options are provided.
@@ -18,7 +17,7 @@ export const DEFAULT_PARSER_OPTIONS = {
   unknownType: 'any',
   emptySchemaType: 'any',
   enumSuffix: 'enum',
-} as const satisfies ParserOptions
+} as const satisfies ast.ParserOptions
 
 /**
  * OpenAPI version string written into the stub document created during multi-spec merges.
@@ -86,7 +85,7 @@ export const formatMap = {
   int32: 'integer',
   float: 'number',
   double: 'number',
-} as const satisfies Record<string, SchemaType>
+} as const satisfies Record<string, ast.SchemaType>
 
 /**
  * Vendor extension keys that attach human-readable labels to enum values, checked in priority order.
@@ -104,8 +103,8 @@ export const enumExtensionKeys = ['x-enumNames', 'x-enum-varnames'] as const
  * Maps `'any' | 'unknown' | 'void'` option strings to their `ScalarSchemaType` constant.
  * Replaces a plain object lookup with a `Map` for explicit key membership testing via `.has()`.
  */
-export const typeOptionMap = new Map<'any' | 'unknown' | 'void', ScalarSchemaType>([
-  ['any', schemaTypes.any],
-  ['unknown', schemaTypes.unknown],
-  ['void', schemaTypes.void],
+export const typeOptionMap = new Map<'any' | 'unknown' | 'void', ast.ScalarSchemaType>([
+  ['any', ast.schemaTypes.any],
+  ['unknown', ast.schemaTypes.unknown],
+  ['void', ast.schemaTypes.void],
 ])

package/src/discriminator.ts

@@ -1,5 +1,4 @@
-import { createProperty, createSchema, narrowSchema, transform } from '@kubb/ast'
-import type { InputNode } from '@kubb/ast/types'
+import { ast } from '@kubb/core'
 
 type DiscriminatorTarget = { propertyName: string; enumValues: Array<string | number | boolean> }
 
@@ -18,19 +17,19 @@ type DiscriminatorTarget = { propertyName: string; enumValues: Array<string | nu
  * const next = applyDiscriminatorInheritance(root)
  * ```
  */
-export function applyDiscriminatorInheritance(root: InputNode): InputNode {
+export function applyDiscriminatorInheritance(root: ast.InputNode): ast.InputNode {
   const childMap = new Map<string, DiscriminatorTarget>()
 
   for (const schema of root.schemas) {
     // Case 1: top-level schema is a union (oneOf/anyOf with discriminator)
     // Case 2: top-level schema is an intersection wrapping a union (oneOf/anyOf + shared properties)
-    let unionNode = narrowSchema(schema, 'union')
+    let unionNode = ast.narrowSchema(schema, 'union')
 
     if (!unionNode) {
-      const intersectionMembers = narrowSchema(schema, 'intersection')?.members
+      const intersectionMembers = ast.narrowSchema(schema, 'intersection')?.members
       if (intersectionMembers) {
         for (const m of intersectionMembers) {
-          const u = narrowSchema(m, 'union')
+          const u = ast.narrowSchema(m, 'union')
           if (u) {
             unionNode = u
             break
@@ -45,21 +44,21 @@ export function applyDiscriminatorInheritance(root: InputNode): InputNode {
 
     for (const member of members) {
       // Members with a discriminant value are intersections: [RefSchemaNode, ObjectSchemaNode]
-      const intersectionNode = narrowSchema(member, 'intersection')
+      const intersectionNode = ast.narrowSchema(member, 'intersection')
       if (!intersectionNode?.members) continue
 
-      let refNode: ReturnType<typeof narrowSchema<'ref'>> | undefined
-      let objNode: ReturnType<typeof narrowSchema<'object'>> | undefined
+      let refNode: ReturnType<typeof ast.narrowSchema<'ref'>> | undefined
+      let objNode: ReturnType<typeof ast.narrowSchema<'object'>> | undefined
 
       for (const m of intersectionNode.members) {
-        refNode ??= narrowSchema(m, 'ref')
-        objNode ??= narrowSchema(m, 'object')
+        refNode ??= ast.narrowSchema(m, 'ref')
+        objNode ??= ast.narrowSchema(m, 'object')
       }
 
       if (!refNode?.name || !objNode) continue
 
       const prop = objNode.properties.find((p) => p.name === discriminatorPropertyName)
-      const enumNode = prop ? narrowSchema(prop.schema, 'enum') : undefined
+      const enumNode = prop ? ast.narrowSchema(prop.schema, 'enum') : undefined
       if (!enumNode?.enumValues?.length) continue
 
       const enumValues = enumNode.enumValues.filter((v): v is string | number | boolean => v !== null)
@@ -76,19 +75,19 @@ export function applyDiscriminatorInheritance(root: InputNode): InputNode {
 
   if (childMap.size === 0) return root
 
-  return transform(root, {
+  return ast.transform(root, {
     schema(node, { parent }) {
       if (parent?.kind !== 'Input' || !node.name) return
 
       const entry = childMap.get(node.name)
       if (!entry) return
 
-      const objectNode = narrowSchema(node, 'object')
+      const objectNode = ast.narrowSchema(node, 'object')
       if (!objectNode) return
 
       const { propertyName, enumValues } = entry
-      const enumSchema = createSchema({ type: 'enum', enumValues })
-      const newProp = createProperty({ name: propertyName, required: true, schema: enumSchema })
+      const enumSchema = ast.createSchema({ type: 'enum', enumValues })
+      const newProp = ast.createProperty({ name: propertyName, required: true, schema: enumSchema })
 
       const existingIdx = objectNode.properties.findIndex((p) => p.name === propertyName)
       const newProperties = existingIdx >= 0 ? objectNode.properties.map((p, i) => (i === existingIdx ? newProp : p)) : [...objectNode.properties, newProp]