@kubb/ast 5.0.0-beta.6 → 5.0.0-beta.61

package/src/nodes/root.ts

@@ -1,64 +0,0 @@
-import type { BaseNode } from './base.ts'
-import type { OperationNode } from './operation.ts'
-import type { SchemaNode } from './schema.ts'
-
-/**
- * Basic metadata for an API document.
- * Adapters fill fields that exist in their source format.
- *
- * @example
- * ```ts
- * const meta: InputMeta = { title: 'Pet API', version: '1.0.0' }
- * ```
- */
-export type InputMeta = {
-  /**
-   * API title (from `info.title` in OAS/AsyncAPI).
-   */
-  title?: string
-  /**
-   * API description (from `info.description` in OAS/AsyncAPI).
-   */
-  description?: string
-  /**
-   * API version string (from `info.version` in OAS/AsyncAPI).
-   */
-  version?: string
-  /**
-   * Resolved API base URL.
-   * For OpenAPI and AsyncAPI, this comes from the selected server URL.
-   */
-  baseURL?: string
-}
-
-/**
- * Input AST node that contains all schemas and operations for one API document.
- * Produced by the adapter and consumed by all Kubb plugins.
- *
- * @example
- * ```ts
- * const input: InputNode = {
- *   kind: 'Input',
- *   schemas: [],
- *   operations: [],
- * }
- * ```
- */
-export type InputNode = BaseNode & {
-  /**
-   * Node kind.
-   */
-  kind: 'Input'
-  /**
-   * All schema nodes in the document.
-   */
-  schemas: Array<SchemaNode>
-  /**
-   * All operation nodes in the document.
-   */
-  operations: Array<OperationNode>
-  /**
-   * Optional document metadata populated by the adapter.
-   */
-  meta?: InputMeta
-}

package/src/refs.ts

@@ -1,67 +0,0 @@
-import type { InputNode } from './nodes/root.ts'
-import type { SchemaNode } from './nodes/schema.ts'
-
-/**
- * Lookup map from schema name to `SchemaNode`.
- */
-export type RefMap = Map<string, SchemaNode>
-
-/**
- * Returns the last path segment of a reference string.
- *
- * Example: `#/components/schemas/Pet` becomes `Pet`.
- *
- * @example
- * ```ts
- * extractRefName('#/components/schemas/Pet') // 'Pet'
- * ```
- */
-export function extractRefName(ref: string): string {
-  return ref.split('/').at(-1) ?? ref
-}
-
-/**
- * Builds a `RefMap` from `input.schemas` using each schema's `name`.
- *
- * Unnamed schemas are skipped.
- *
- * @example
- * ```ts
- * const refMap = buildRefMap(input)
- * const pet = refMap.get('Pet')
- * ```
- */
-export function buildRefMap(input: InputNode): RefMap {
-  const map: RefMap = new Map()
-
-  for (const schema of input.schemas) {
-    if (schema.name) {
-      map.set(schema.name, schema)
-    }
-  }
-  return map
-}
-
-/**
- * Resolves a schema by name from a `RefMap`.
- *
- * @example
- * ```ts
- * const petSchema = resolveRef(refMap, 'Pet')
- * ```
- */
-export function resolveRef(refMap: RefMap, ref: string): SchemaNode | undefined {
-  return refMap.get(ref)
-}
-
-/**
- * Converts a `RefMap` into a plain object.
- *
- * @example
- * ```ts
- * const refsObject = refMapToObject(refMap)
- * ```
- */
-export function refMapToObject(refMap: RefMap): Record<string, SchemaNode> {
-  return Object.fromEntries(refMap)
-}

package/src/resolvers.ts

@@ -1,45 +0,0 @@
-import { pascalCase } from '@internals/utils'
-import { narrowSchema } from './guards.ts'
-import type { SchemaNode } from './nodes/schema.ts'
-import { extractRefName } from './refs.ts'
-import { collect } from './visitor.ts'
-
-export function findDiscriminator(mapping: Record<string, string> | undefined, ref: string | undefined): string | null {
-  if (!mapping || !ref) return null
-  return Object.entries(mapping).find(([, value]) => value === ref)?.[0] ?? null
-}
-
-export function childName(parentName: string | null | undefined, propName: string): string | null {
-  return parentName ? pascalCase([parentName, propName].join(' ')) : null
-}
-
-export function enumPropName(parentName: string | null | undefined, propName: string, enumSuffix: string): string {
-  return pascalCase([parentName, propName, enumSuffix].filter(Boolean).join(' '))
-}
-
-/**
- * Collects import entries for all `ref` schema nodes in `node`.
- */
-export function collectImports<TImport>({
-  node,
-  nameMapping,
-  resolve,
-}: {
-  node: SchemaNode
-  nameMapping: Map<string, string>
-  resolve: (schemaName: string) => TImport | undefined
-}): Array<TImport> {
-  return collect<TImport>(node, {
-    schema(schemaNode): TImport | undefined {
-      const schemaRef = narrowSchema(schemaNode, 'ref')
-      if (!schemaRef?.ref) return
-
-      const rawName = extractRefName(schemaRef.ref)
-      const schemaName = nameMapping.get(rawName) ?? rawName
-      const result = resolve(schemaName)
-      if (!result) return
-
-      return result
-    },
-  })
-}

package/src/transformers.ts

@@ -1,159 +0,0 @@
-import { isScalarPrimitive } from './constants.ts'
-import { createProperty, createSchema } from './factory.ts'
-import { narrowSchema } from './guards.ts'
-import type { SchemaNode } from './nodes/schema.ts'
-import { enumPropName } from './resolvers.ts'
-
-/**
- * Replaces a discriminator property's schema with a string enum of allowed values.
- *
- * If `node` is not an object schema, or if the property does not exist, the input
- * node is returned as-is.
- *
- * @example
- * ```ts
- * const schema = createSchema({
- *   type: 'object',
- *   properties: [createProperty({ name: 'type', required: true, schema: createSchema({ type: 'string' }) })],
- * })
- * const result = setDiscriminatorEnum({ node: schema, propertyName: 'type', values: ['dog', 'cat'] })
- * ```
- */
-export function setDiscriminatorEnum({
-  node,
-  propertyName,
-  values,
-  enumName,
-}: {
-  node: SchemaNode
-  propertyName: string
-  values: Array<string>
-  enumName?: string
-}): SchemaNode {
-  const objectNode = narrowSchema(node, 'object')
-  if (!objectNode?.properties?.length) {
-    return node
-  }
-
-  const hasProperty = objectNode.properties.some((prop) => prop.name === propertyName)
-  if (!hasProperty) {
-    return node
-  }
-
-  return createSchema({
-    ...objectNode,
-    properties: objectNode.properties.map((prop) => {
-      if (prop.name !== propertyName) {
-        return prop
-      }
-
-      return createProperty({
-        ...prop,
-        schema: createSchema({
-          type: 'enum',
-          primitive: 'string',
-          enumValues: values,
-          name: enumName,
-          readOnly: prop.schema.readOnly,
-          writeOnly: prop.schema.writeOnly,
-        }),
-      })
-    }),
-  })
-}
-
-/**
- * Merges adjacent anonymous object members into a single anonymous object member.
- *
- * @example
- * ```ts
- * const merged = mergeAdjacentObjects([
- *   createSchema({ type: 'object', properties: [createProperty({ name: 'a', schema: createSchema({ type: 'string' }) })] }),
- *   createSchema({ type: 'object', properties: [createProperty({ name: 'b', schema: createSchema({ type: 'number' }) })] }),
- * ])
- * ```
- */
-export function mergeAdjacentObjects(members: Array<SchemaNode>): Array<SchemaNode> {
-  return members.reduce<Array<SchemaNode>>((acc, member) => {
-    const objectMember = narrowSchema(member, 'object')
-    if (objectMember && !objectMember.name) {
-      const previous = acc.at(-1)
-      const previousObject = previous ? narrowSchema(previous, 'object') : undefined
-
-      if (previousObject && !previousObject.name) {
-        acc[acc.length - 1] = createSchema({
-          ...previousObject,
-          properties: [...(previousObject.properties ?? []), ...(objectMember.properties ?? [])],
-        })
-        return acc
-      }
-    }
-
-    acc.push(member)
-    return acc
-  }, [])
-}
-
-/**
- * Removes enum members that are covered by broader scalar primitives in the same union.
- *
- * @example
- * ```ts
- * const simplified = simplifyUnion([
- *   createSchema({ type: 'enum', primitive: 'string', enumValues: ['active'] }),
- *   createSchema({ type: 'string' }),
- * ])
- * // keeps only string member
- * ```
- */
-export function simplifyUnion(members: Array<SchemaNode>): Array<SchemaNode> {
-  const scalarPrimitives = new Set(members.filter((member) => isScalarPrimitive(member.type)).map((m) => m.type))
-
-  if (!scalarPrimitives.size) {
-    return members
-  }
-
-  return members.filter((member) => {
-    const enumNode = narrowSchema(member, 'enum')
-    if (!enumNode) {
-      return true
-    }
-
-    const primitive = enumNode.primitive
-    if (!primitive) {
-      return true
-    }
-
-    const enumValueCount = enumNode.namedEnumValues?.length ?? enumNode.enumValues?.length ?? 0
-    if (enumValueCount <= 1) {
-      return true
-    }
-
-    if (scalarPrimitives.has(primitive)) {
-      return false
-    }
-
-    if ((primitive === 'integer' || primitive === 'number') && (scalarPrimitives.has('integer') || scalarPrimitives.has('number'))) {
-      return false
-    }
-
-    return true
-  })
-}
-
-export function setEnumName(propNode: SchemaNode, parentName: string | null | undefined, propName: string, enumSuffix: string): SchemaNode {
-  const enumNode = narrowSchema(propNode, 'enum')
-
-  if (enumNode?.primitive === 'boolean') {
-    return { ...propNode, name: undefined }
-  }
-
-  if (enumNode) {
-    return {
-      ...propNode,
-      name: enumPropName(parentName, propName, enumSuffix),
-    }
-  }
-
-  return propNode
-}