@kubb/ast 5.0.0-alpha.16 → 5.0.0-alpha.17

package/src/{printer.ts → printers/printer.ts}

@@ -1,9 +1,17 @@
-import type { SchemaNode, SchemaNodeByType, SchemaType } from './nodes/index.ts'
+import type { SchemaNode, SchemaNodeByType, SchemaType } from '../nodes/index.ts'
 
 /**
- * Handler context for `definePrinter` — mirrors `PluginContext` from `@kubb/core`.
- * Available as `this` inside each node handler and the optional root-level `print`.
- * `this.print` always dispatches to the `nodes` handlers (node-level printer).
+ * Runtime context passed as `this` to printer handlers.
+ *
+ * `this.print` always dispatches to node-level handlers from `nodes`.
+ *
+ * @example
+ * ```ts
+ * const context: PrinterHandlerContext<string, {}> = {
+ *   options: {},
+ *   print: () => 'value',
+ * }
+ * ```
  */
 export type PrinterHandlerContext<TOutput, TOptions extends object> = {
   /**
@@ -17,8 +25,16 @@ export type PrinterHandlerContext<TOutput, TOptions extends object> = {
 }
 
 /**
- * Handler for a specific `SchemaNode` variant identified by `SchemaType` key `T`.
- * Use a regular function (not an arrow function) so that `this` is available.
+ * Handler for one schema node type.
+ *
+ * Use a regular function (not an arrow function) if you need `this`.
+ *
+ * @example
+ * ```ts
+ * const handler: PrinterHandler<string, {}, 'string'> = function () {
+ *   return 'string'
+ * }
+ * ```
  */
 export type PrinterHandler<TOutput, TOptions extends object, T extends SchemaType = SchemaType> = (
   this: PrinterHandlerContext<TOutput, TOptions>,
@@ -26,13 +42,17 @@ export type PrinterHandler<TOutput, TOptions extends object, T extends SchemaTyp
 ) => TOutput | null | undefined
 
 /**
- * Shape of the type parameter passed to `definePrinter`.
- * Mirrors `AdapterFactoryOptions` / `PluginFactoryOptions` from `@kubb/core`.
+ * Generic shape used by `definePrinter`.
  *
  * - `TName`        — unique string identifier (e.g. `'zod'`, `'ts'`)
- * - `TOptions`     — options passed to and stored on the printer
+ * - `TOptions`     — options passed to and stored on the printer instance
  * - `TOutput`      — the type emitted by node handlers
- * - `TPrintOutput` — the type emitted by the public `print` override (defaults to `TOutput`)
+ * - `TPrintOutput` — type returned by public `print` (defaults to `TOutput`)
+ *
+ * @example
+ * ```ts
+ * type MyPrinter = PrinterFactoryOptions<'my', { strict: boolean }, string>
+ * ```
  */
 export type PrinterFactoryOptions<TName extends string = string, TOptions extends object = object, TOutput = unknown, TPrintOutput = TOutput> = {
   name: TName
@@ -42,7 +62,12 @@ export type PrinterFactoryOptions<TName extends string = string, TOptions extend
 }
 
 /**
- * The object returned by calling a `definePrinter` instance.
+ * Printer instance returned by a printer factory.
+ *
+ * @example
+ * ```ts
+ * const printer = definePrinter((options: {}) => ({ name: 'x', options, nodes: {} }))({})
+ * ```
  */
 export type Printer<T extends PrinterFactoryOptions = PrinterFactoryOptions> = {
   /**
@@ -55,16 +80,25 @@ export type Printer<T extends PrinterFactoryOptions = PrinterFactoryOptions> = {
   options: T['options']
   /**
    * Public printer. If the builder provides a root-level `print`, this calls that
-   * higher-level function (which may produce full declarations). Otherwise falls back
-   * to the node-level dispatcher
+   * higher-level function (which may produce full declarations).
+   * Otherwise, falls back to the node-level dispatcher.
    */
   print: (node: SchemaNode) => T['printOutput'] | null | undefined
 }
 
 /**
- * Builder function passed to `definePrinter`. Receives the resolved options and returns the
- * printer configuration: a unique `name`, the stored `options`, node-level `nodes` handlers,
- * and an optional root-level `print` override.
+ * Builder function passed to `definePrinter`.
+ *
+ * It receives resolved options and returns:
+ * - `name`
+ * - `options`
+ * - `nodes` handlers
+ * - optional top-level `print` override
+ *
+ * @example
+ * ```ts
+ * const build = (options: {}) => ({ name: 'x' as const, options, nodes: {} })
+ * ```
  */
 type PrinterBuilder<T extends PrinterFactoryOptions> = (options: T['options']) => {
   name: T['name']
@@ -84,16 +118,17 @@ type PrinterBuilder<T extends PrinterFactoryOptions> = (options: T['options']) =
 }
 
 /**
- * Creates a named printer factory. Mirrors the `createPlugin` / `createAdapter` pattern
- * from `@kubb/core` — wraps a builder to make options optional and separates raw options
- * from resolved options.
+ * Creates a schema printer factory.
+ *
+ * This function wraps a builder and makes options optional at call sites.
  *
  * The builder receives resolved options and returns:
  * - `name` — a unique identifier for the printer
  * - `options` — options stored on the returned printer instance
  * - `nodes` — a map of `SchemaType` → handler functions that convert a `SchemaNode` to `TOutput`
- * - `print` _(optional)_ — a root-level override that becomes the public `printer.print`.
- *   Inside it, `this.print(node)` still dispatches to the `nodes` map — safe recursion, no infinite loop.
+ * - `print` _(optional)_ — top-level override exposed as `printer.print`
+ *   - Inside this function, `this.print(node)` still dispatches to the `nodes` map
+ *   - This keeps recursion safe and avoids self-calls
  *
  * When no `print` override is provided, `printer.print` is the node-level dispatcher directly.
  *
@@ -113,33 +148,14 @@ type PrinterBuilder<T extends PrinterFactoryOptions> = (options: T['options']) =
  *   },
  * }))
  * ```
- *
- * @example With a root-level `print` override to wrap output in a full declaration
- * ```ts
- * type TsPrinter = PrinterFactoryOptions<'ts', { typeName?: string }, ts.TypeNode, ts.Node>
- *
- * export const printerTs = definePrinter<TsPrinter>((options) => ({
- *   name: 'ts',
- *   options,
- *   nodes: { string: () => factory.keywordTypeNodes.string },
- *   print(node) {
- *     const type = this.print(node) // calls the node-level dispatcher
- *     if (!type || !this.options.typeName) return type
- *     return factory.createTypeAliasDeclaration(this.options.typeName, type)
- *   },
- * }))
- * ```
  */
 export function definePrinter<T extends PrinterFactoryOptions = PrinterFactoryOptions>(build: PrinterBuilder<T>): (options?: T['options']) => Printer<T> {
   return createPrinterFactory<SchemaNode, SchemaType, SchemaNodeByType>((node) => node.type)(build) as (options?: T['options']) => Printer<T>
 }
 
 /**
- * Generic printer factory. Extracts the core dispatch + context logic so it can be reused
- * for any node type — not just `SchemaNode`. `definePrinter` is built on top of this.
- *
- * @param getKey — derives the handler-map key from a node. Return `undefined` to skip.
- *
+ * Generic printer-factory function used by `definePrinter` and `defineFunctionPrinter`.
+ **
  * @example
  * ```ts
  * export const defineFunctionPrinter = createPrinterFactory<FunctionNode, FunctionNodeType, FunctionNodeByType>(

package/src/refs.ts

@@ -2,20 +2,34 @@ import type { RootNode } from './nodes/root.ts'
 import type { SchemaNode } from './nodes/schema.ts'
 
 /**
- * Schema name to `SchemaNode` mapping.
+ * Lookup map from schema name to `SchemaNode`.
  */
 export type RefMap = Map<string, SchemaNode>
 
 /**
- * Extracts the final segment from a reference string.
- * Falls back to the original string when no slash exists.
+ * 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
 }
 
 /**
- * Indexes named schemas from `root.schemas` by name. Unnamed schemas are skipped.
+ * Builds a `RefMap` from `root.schemas` using each schema's `name`.
+ *
+ * Unnamed schemas are skipped.
+ *
+ * @example
+ * ```ts
+ * const refMap = buildRefMap(root)
+ * const pet = refMap.get('Pet')
+ * ```
  */
 export function buildRefMap(root: RootNode): RefMap {
   const map: RefMap = new Map()
@@ -29,14 +43,24 @@ export function buildRefMap(root: RootNode): RefMap {
 }
 
 /**
- * Looks up a schema by name. Prefer over `RefMap.get()` to keep the resolution strategy swappable.
+ * 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` to a plain object.
+ * 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

@@ -0,0 +1,45 @@
+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 | undefined {
+  if (!mapping || !ref) return undefined
+  return Object.entries(mapping).find(([, value]) => value === ref)?.[0]
+}
+
+export function childName(parentName: string | undefined, propName: string): string | undefined {
+  return parentName ? pascalCase([parentName, propName].join(' ')) : undefined
+}
+
+export function enumPropName(parentName: string | 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

@@ -0,0 +1,196 @@
+import { SCALAR_PRIMITIVE_TYPES } 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'
+import { transform } from './visitor.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) => SCALAR_PRIMITIVE_TYPES.has(member.type as typeof SCALAR_PRIMITIVE_TYPES extends Set<infer T> ? T : never)).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 | 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
+}
+
+/**
+ * Walks a schema tree and resolves `ref`/`enum` names through callbacks.
+ */
+export function resolveNames({
+  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, '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 }
+        }
+      }
+
+      const schemaEnum = narrowSchema(schemaNode, 'enum')
+      if (schemaEnum?.name) {
+        const resolved = (resolveEnumName ?? resolveName)(schemaEnum.name)
+        if (resolved) {
+          return { ...schemaNode, name: resolved }
+        }
+      }
+    },
+  }) as SchemaNode
+}

package/src/types.ts

@@ -1,5 +1,6 @@
 export type { VisitorDepth } from './constants.ts'
 export type { DistributiveOmit } from './factory.ts'
+export type { InferSchema, InferSchemaNode, ParserOptions } from './infer.ts'
 export type {
   ArraySchemaNode,
   BaseNode,
@@ -42,6 +43,6 @@ export type {
   UnionSchemaNode,
   UrlSchemaNode,
 } from './nodes/index.ts'
-export type { Printer, PrinterFactoryOptions } from './printer.ts'
+export type { Printer, PrinterFactoryOptions } from './printers/printer.ts'
 export type { RefMap } from './refs.ts'
 export type { AsyncVisitor, CollectOptions, CollectVisitor, ParentOf, TransformOptions, Visitor, VisitorContext, WalkOptions } from './visitor.ts'

package/src/utils.ts

@@ -7,12 +7,18 @@ import type { SchemaType } from './nodes/schema.ts'
 const plainStringTypes = new Set<SchemaType>(['string', 'uuid', 'email', 'url', 'datetime'] as const)
 
 /**
- * Returns `true` when a schema node will be represented as a plain string in generated code.
+ * Returns `true` when a schema is emitted as a plain TypeScript `string`.
  *
  * - `string`, `uuid`, `email`, `url`, `datetime` are always plain strings.
  * - `date` and `time` are plain strings when their `representation` is `'string'` rather than `'date'`.
+ *
+ * @example
+ * ```ts
+ * isStringType(createSchema({ type: 'uuid' })) // true
+ * isStringType(createSchema({ type: 'date', representation: 'date' })) // false
+ * ```
  */
-export function isPlainStringType(node: SchemaNode): boolean {
+export function isStringType(node: SchemaNode): boolean {
   if (plainStringTypes.has(node.type)) {
     return true
   }
@@ -26,16 +32,23 @@ export function isPlainStringType(node: SchemaNode): boolean {
 }
 
 /**
- * Transforms the `name` field of each parameter node according to the given casing strategy.
+ * Applies casing rules to parameter names and returns a new parameter array.
  *
- * The original `params` array is never mutated — a new array of cloned nodes is returned.
- * When no `casing` is provided the original array is returned as-is.
+ * The input array is not mutated.
+ * If `casing` is not set, the original array is returned unchanged.
  *
  * Use this before passing parameters to schema builders so that property keys
- * in the generated output match the desired casing while the original
- * `OperationNode.parameters` array remains untouched for other consumers.
+ * in generated output match the desired casing while preserving
+ * `OperationNode.parameters` for other consumers.
+ *
+ * @example
+ * ```ts
+ * const params = [createParameter({ name: 'pet_id', in: 'query', schema: createSchema({ type: 'string' }) })]
+ * const cased = caseParams(params, 'camelcase')
+ * // cased[0].name === 'petId'
+ * ```
  */
-export function applyParamsCasing(params: Array<ParameterNode>, casing: 'camelcase' | undefined): Array<ParameterNode> {
+export function caseParams(params: Array<ParameterNode>, casing: 'camelcase' | undefined): Array<ParameterNode> {
   if (!casing) {
     return params
   }
@@ -46,3 +59,19 @@ export function applyParamsCasing(params: Array<ParameterNode>, casing: 'camelca
     return { ...param, name: transformed }
   })
 }
+
+/**
+ * Syncs property/parameter schema optionality flags from `required` and `schema.nullable`.
+ *
+ * - `optional` is set for non-required, non-nullable schemas.
+ * - `nullish` is set for non-required, nullable schemas.
+ */
+export function syncOptionality(required: boolean, schema: SchemaNode): SchemaNode {
+  const nullable = schema.nullable ?? false
+
+  return {
+    ...schema,
+    optional: !required && !nullable ? true : undefined,
+    nullish: !required && nullable ? true : undefined,
+  }
+}