@kubb/ast 5.0.0-beta.3 → 5.0.0-beta.31

package/src/nodes/root.ts

@@ -3,32 +3,62 @@ 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.
+ * Metadata for an API document, populated by the adapter and available to every generator.
+ *
+ * All fields are plain JSON-serializable values — no `Set`, no `Map`, no class instances.
+ * Computed fields (`circularNames`, `enumNames`) are pre-calculated once during the adapter
+ * pre-scan so generators never need to iterate the full schema list themselves.
  *
  * @example
  * ```ts
- * const meta: InputMeta = { title: 'Pet API', version: '1.0.0' }
+ * const meta: InputMeta = { title: 'Pet Store', version: '1.0.0', baseURL: 'https://petstore.swagger.io/v2', circularNames: [], enumNames: [] }
  * ```
  */
 export type InputMeta = {
   /**
-   * API title (from `info.title` in OAS/AsyncAPI).
+   * API title from `info.title` in the source document.
    */
   title?: string
   /**
-   * API description (from `info.description` in OAS/AsyncAPI).
+   * API description from `info.description` in the source document.
    */
   description?: string
   /**
-   * API version string (from `info.version` in OAS/AsyncAPI).
+   * API version string from `info.version` in the source document.
    */
   version?: string
   /**
-   * Resolved API base URL.
-   * For OpenAPI and AsyncAPI, this comes from the selected server URL.
+   * Resolved base URL from the first matching server entry in the source document.
+   */
+  baseURL?: string | null
+  /**
+   * Names of schemas that participate in a circular reference chain.
+   * Computed once during the adapter pre-scan — use this instead of calling
+   * `findCircularSchemas` per generator call.
+   *
+   * Convert to a `Set` once at the start of a generator, not per-schema,
+   * to keep lookup O(1) without repeated allocations.
+   *
+   * @example Wrap a circular schema in z.lazy()
+   * ```ts
+   * const circular = new Set(meta.circularNames)
+   * if (circular.has(schema.name)) { ... }
+   * ```
    */
-  baseURL?: string
+  circularNames: ReadonlyArray<string>
+  /**
+   * Names of schemas whose type is `enum`.
+   * Computed once during the adapter pre-scan — use this instead of filtering
+   * schemas per generator call.
+   *
+   * Convert to a `Set` once at the start of a generator when you need repeated
+   * membership checks, rather than calling `.includes()` per schema.
+   *
+   * @example Check if a referenced schema is an enum
+   * `const enums = new Set(meta.enumNames)`
+   * `const isEnum = enums.has(schemaName)`
+   */
+  enumNames: ReadonlyArray<string>
 }
 
 /**
@@ -58,7 +88,39 @@ export type InputNode = BaseNode & {
    */
   operations: Array<OperationNode>
   /**
-   * Optional document metadata populated by the adapter.
+   * Document metadata populated by the adapter.
+   */
+  meta: InputMeta
+}
+
+/**
+ * Streaming variant of `InputNode` for memory-efficient processing of large API specs.
+ *
+ * `schemas` and `operations` are `AsyncIterable` rather than arrays — each `for await`
+ * loop creates a fresh parse pass from the cached in-memory document, so multiple
+ * consumers (plugins) can iterate independently without keeping all nodes in memory.
+ *
+ * @example
+ * ```ts
+ * for await (const schema of inputStreamNode.schemas) {
+ *   // only this one SchemaNode is live here; previous ones are GC-eligible
+ * }
+ * ```
+ */
+export type InputStreamNode = {
+  kind: 'Input'
+  /**
+   * Lazily parsed schema nodes. Each `for await` creates a fresh parse pass, so
+   * multiple plugins can iterate independently without sharing state.
+   */
+  schemas: AsyncIterable<SchemaNode>
+  /**
+   * Lazily parsed operation nodes. Each `for await` creates a fresh parse pass, so
+   * multiple plugins can iterate independently without sharing state.
+   */
+  operations: AsyncIterable<OperationNode>
+  /**
+   * Document metadata available immediately, before the first yielded node.
    */
   meta?: InputMeta
 }

package/src/nodes/schema.ts

@@ -154,6 +154,10 @@ type SchemaNodeBase = BaseNode & {
    * For example, this is `'string'` for a `uuid` schema.
    */
   primitive?: PrimitiveSchemaType
+  /**
+   * Schema `format` value.
+   */
+  format?: string
 }
 
 /**
@@ -364,8 +368,9 @@ export type RefSchemaNode = SchemaNodeBase & {
   type: 'ref'
   /**
    * Referenced schema name.
+   * `null` means Kubb has processed this and determined there is no applicable name.
    */
-  name?: string
+  name?: string | null
   /**
    * Original `$ref` path, for example, `#/components/schemas/Order`.
    * Used to resolve names later.
@@ -378,12 +383,13 @@ export type RefSchemaNode = SchemaNodeBase & {
   /**
    * The fully-parsed schema that this ref resolves to.
    * Populated during OAS parsing when the referenced definition can be resolved.
-   * `undefined` when the ref cannot be resolved or is part of a circular chain.
+   * `null` when the ref cannot be resolved or is part of a circular chain.
+   * `undefined` when resolution has not been attempted.
    *
    * Useful for inspecting the referenced schema's structure (e.g. `primitive`, `properties`)
    * without following the reference manually.
    */
-  schema?: SchemaNode
+  schema?: SchemaNode | null
 }
 
 /**

package/src/printer.ts

@@ -18,7 +18,7 @@ export type PrinterHandlerContext<TOutput, TOptions extends object> = {
    * Recursively transform a nested `SchemaNode` to `TOutput` using the node-level handlers.
    * Use `this.transform` inside `nodes` handlers and inside the `print` override.
    */
-  transform: (node: SchemaNode) => TOutput | null | undefined
+  transform: (node: SchemaNode) => TOutput | null
   /**
    * Options for this printer instance.
    */
@@ -40,7 +40,7 @@ export type PrinterHandlerContext<TOutput, TOptions extends object> = {
 export type PrinterHandler<TOutput, TOptions extends object, T extends SchemaType = SchemaType> = (
   this: PrinterHandlerContext<TOutput, TOptions>,
   node: SchemaNodeByType[T],
-) => TOutput | null | undefined
+) => TOutput | null
 
 /**
  * Partial map of per-node-type handler overrides for a printer.
@@ -108,13 +108,13 @@ export type Printer<T extends PrinterFactoryOptions = PrinterFactoryOptions> = {
    * Always dispatches through the `nodes` map; never calls the `print` override.
    * Use this when you need the raw output (e.g. `ts.TypeNode`) without declaration wrapping.
    */
-  transform: (node: SchemaNode) => T['output'] | null | undefined
+  transform: (node: SchemaNode) => T['output'] | null
   /**
    * 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.
    */
-  print: (node: SchemaNode) => T['printOutput'] | null | undefined
+  print: (node: SchemaNode) => T['printOutput'] | null
 }
 
 /**
@@ -147,24 +147,28 @@ type PrinterBuilder<T extends PrinterFactoryOptions> = (options: T['options']) =
    */
   print?: (this: PrinterHandlerContext<T['output'], T['options']>, node: SchemaNode) => T['printOutput'] | null
 }
-
 /**
- * Creates a schema printer factory.
- *
- * This function wraps a builder and makes options optional at call sites.
+ * Defines a schema printer: a function that takes a `SchemaNode` and emits
+ * code in your target language. Each plugin that produces code from schemas
+ * (TypeScript types, Zod schemas, Faker factories) ships a printer built
+ * with this helper.
  *
  * 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)_ — top-level override exposed as `printer.print`
- *   - Inside this function, use `this.transform(node)` to dispatch to the `nodes` map
- *   - This keeps recursion safe and avoids self-calls
  *
- * When no `print` override is provided, `printer.print` falls back to `printer.transform` (the node-level dispatcher).
+ * - `name` — unique identifier for the printer.
+ * - `options` — stored on the returned printer instance.
+ * - `nodes` — map of `SchemaType` → handler. Handlers return the rendered
+ *   output (a string, a TypeScript AST node, ...) for that schema type.
+ * - `print` (optional) — top-level override exposed as `printer.print`.
+ *   Use `this.transform(node)` inside it to dispatch to `nodes` recursively.
  *
- * @example Basic usage — Zod schema printer
+ * Without a `print` override, `printer.print` falls back to `printer.transform`
+ * (the node-level dispatcher).
+ *
+ * @example Tiny Zod printer
  * ```ts
+ * import { definePrinter, type PrinterFactoryOptions } from '@kubb/ast'
+ *
  * type PrinterZod = PrinterFactoryOptions<'zod', { strict?: boolean }, string>
  *
  * export const zodPrinter = definePrinter<PrinterZod>((options) => ({
@@ -173,7 +177,9 @@ type PrinterBuilder<T extends PrinterFactoryOptions> = (options: T['options']) =
  *   nodes: {
  *     string: () => 'z.string()',
  *     object(node) {
- *       const props = node.properties.map(p => `${p.name}: ${this.transform(p.schema)}`).join(', ')
+ *       const props = node.properties
+ *         .map((p) => `${p.name}: ${this.transform(p.schema)}`)
+ *         .join(', ')
  *       return `z.object({ ${props} })`
  *     },
  *   },
@@ -194,7 +200,7 @@ export function definePrinter<T extends PrinterFactoryOptions = PrinterFactoryOp
  * )
  * ```
  */
-export function createPrinterFactory<TNode, TKey extends string, TNodeByKey extends Partial<Record<TKey, TNode>>>(getKey: (node: TNode) => TKey | undefined) {
+export function createPrinterFactory<TNode, TKey extends string, TNodeByKey extends Partial<Record<TKey, TNode>>>(getKey: (node: TNode) => TKey | null) {
   return function <T extends PrinterFactoryOptions>(
     build: (options: T['options']) => {
       name: T['name']
@@ -202,40 +208,40 @@ export function createPrinterFactory<TNode, TKey extends string, TNodeByKey exte
       nodes: Partial<{
         [K in TKey]: (
           this: {
-            transform: (node: TNode) => T['output'] | null | undefined
+            transform: (node: TNode) => T['output'] | null
             options: T['options']
           },
           node: TNodeByKey[K],
-        ) => T['output'] | null | undefined
+        ) => T['output'] | null
       }>
       print?: (
         this: {
-          transform: (node: TNode) => T['output'] | null | undefined
+          transform: (node: TNode) => T['output'] | null
           options: T['options']
         },
         node: TNode,
-      ) => T['printOutput'] | null | undefined
+      ) => T['printOutput'] | null
     },
   ): (options?: T['options']) => {
     name: T['name']
     options: T['options']
-    transform: (node: TNode) => T['output'] | null | undefined
-    print: (node: TNode) => T['printOutput'] | null | undefined
+    transform: (node: TNode) => T['output'] | null
+    print: (node: TNode) => T['printOutput'] | null
   } {
     return (options) => {
       const { name, options: resolvedOptions, nodes, print: printOverride } = build(options ?? ({} as T['options']))
 
       const context = {
         options: resolvedOptions,
-        transform: (node: TNode): T['output'] | null | undefined => {
+        transform: (node: TNode): T['output'] | null => {
           const key = getKey(node)
-          if (key === undefined) return null
+          if (key === null) return null
 
           const handler = nodes[key]
 
           if (!handler) return null
 
-          return (handler as (this: typeof context, node: TNode) => T['output'] | null | undefined).call(context, node)
+          return (handler as (this: typeof context, node: TNode) => T['output'] | null).call(context, node)
         },
       }
 
@@ -243,7 +249,7 @@ export function createPrinterFactory<TNode, TKey extends string, TNodeByKey exte
         name,
         options: resolvedOptions,
         transform: context.transform,
-        print: (printOverride ? printOverride.bind(context) : context.transform) as (node: TNode) => T['printOutput'] | null | undefined,
+        print: (printOverride ? printOverride.bind(context) : context.transform) as (node: TNode) => T['printOutput'] | null,
       }
     }
   }

package/src/refs.ts

@@ -45,13 +45,15 @@ export function buildRefMap(input: InputNode): RefMap {
 /**
  * Resolves a schema by name from a `RefMap`.
  *
+ * Returns `null` when the ref is not found.
+ *
  * @example
  * ```ts
  * const petSchema = resolveRef(refMap, 'Pet')
  * ```
  */
-export function resolveRef(refMap: RefMap, ref: string): SchemaNode | undefined {
-  return refMap.get(ref)
+export function resolveRef(refMap: RefMap, ref: string): SchemaNode | null {
+  return refMap.get(ref) ?? null
 }
 
 /**

package/src/resolvers.ts

@@ -27,17 +27,17 @@ export function collectImports<TImport>({
 }: {
   node: SchemaNode
   nameMapping: Map<string, string>
-  resolve: (schemaName: string) => TImport | undefined
+  resolve: (schemaName: string) => TImport | null
 }): Array<TImport> {
   return collect<TImport>(node, {
-    schema(schemaNode): TImport | undefined {
+    schema(schemaNode): TImport | null {
       const schemaRef = narrowSchema(schemaNode, 'ref')
-      if (!schemaRef?.ref) return
+      if (!schemaRef?.ref) return null
 
       const rawName = extractRefName(schemaRef.ref)
       const schemaName = nameMapping.get(rawName) ?? rawName
       const result = resolve(schemaName)
-      if (!result) return
+      if (!result) return null
 
       return result
     },

package/src/signature.ts

@@ -0,0 +1,135 @@
+import { createHash } from 'node:crypto'
+import type { SchemaNode } from './nodes/index.ts'
+import { extractRefName } from './refs.ts'
+
+/**
+ * The shape-affecting flags shared by every node kind: base primitive, format, and `nullable`.
+ * Documentation and usage-slot flags (`optional`/`nullish`/`readOnly`/`writeOnly`) are
+ * intentionally excluded — they describe the property slot, not the type.
+ */
+function flagsDescriptor(node: SchemaNode): string {
+  return `${node.primitive ?? ''};${node.format ?? ''};${node.nullable ? 1 : 0}`
+}
+
+function refTargetName(node: Extract<SchemaNode, { type: 'ref' }>): string {
+  if (node.ref) return extractRefName(node.ref)
+  return node.name ?? ''
+}
+
+/**
+ * Builds the local, shape-only descriptor for a node: its kind, flags, constraints, and its
+ * children's signatures. {@link signatureOf} hashes this string; children contribute their
+ * fixed-length signature rather than their own full descriptor, which keeps the result bounded.
+ */
+function describeShape(node: SchemaNode, signatures: Map<SchemaNode, string>): string {
+  const flags = flagsDescriptor(node)
+
+  switch (node.type) {
+    case 'object': {
+      const props = (node.properties ?? []).map((prop) => `${prop.name}${prop.required ? '!' : '?'}${signatureOf(prop.schema, signatures)}`).join(',')
+      let additional = ''
+      if (typeof node.additionalProperties === 'boolean') {
+        additional = `ab:${node.additionalProperties}`
+      } else if (node.additionalProperties) {
+        additional = `as:${signatureOf(node.additionalProperties, signatures)}`
+      }
+      const pattern = node.patternProperties
+        ? Object.keys(node.patternProperties)
+            .sort()
+            .map((key) => `${key}=${signatureOf(node.patternProperties![key]!, signatures)}`)
+            .join(',')
+        : ''
+      return `object|${flags}|p[${props}]|${additional}|pp[${pattern}]|mn:${node.minProperties ?? ''}|mx:${node.maxProperties ?? ''}`
+    }
+    case 'array':
+    case 'tuple': {
+      const items = (node.items ?? []).map((item) => signatureOf(item, signatures)).join(',')
+      const rest = node.rest ? signatureOf(node.rest, signatures) : ''
+      return `${node.type}|${flags}|i[${items}]|r:${rest}|mn:${node.min ?? ''}|mx:${node.max ?? ''}|u:${node.unique ? 1 : 0}`
+    }
+    case 'union': {
+      const members = (node.members ?? []).map((member) => signatureOf(member, signatures)).join(',')
+      return `union|${flags}|s:${node.strategy ?? ''}|d:${node.discriminatorPropertyName ?? ''}|m[${members}]`
+    }
+    case 'intersection': {
+      const members = (node.members ?? []).map((member) => signatureOf(member, signatures)).join(',')
+      return `intersection|${flags}|m[${members}]`
+    }
+    case 'enum': {
+      let values = ''
+      if (node.namedEnumValues?.length) {
+        values = node.namedEnumValues.map((entry) => `${entry.name}=${entry.primitive}:${String(entry.value)}`).join(',')
+      } else if (node.enumValues?.length) {
+        values = node.enumValues.map((value) => `${value === null ? 'null' : typeof value}:${String(value)}`).join(',')
+      }
+      return `enum|${flags}|v[${values}]`
+    }
+    case 'ref':
+      return `ref|${flags}|->${refTargetName(node)}`
+    case 'string':
+      return `string|${flags}|mn:${node.min ?? ''}|mx:${node.max ?? ''}|pt:${node.pattern ?? ''}`
+    case 'number':
+    case 'integer':
+    case 'bigint':
+      return `${node.type}|${flags}|mn:${node.min ?? ''}|mx:${node.max ?? ''}|emn:${node.exclusiveMinimum ?? ''}|emx:${node.exclusiveMaximum ?? ''}|mo:${node.multipleOf ?? ''}`
+    case 'url':
+      return `url|${flags}|path:${node.path ?? ''}|mn:${node.min ?? ''}|mx:${node.max ?? ''}`
+    case 'uuid':
+    case 'email':
+      return `${node.type}|${flags}|mn:${node.min ?? ''}|mx:${node.max ?? ''}`
+    case 'datetime':
+      return `datetime|${flags}|o:${node.offset ? 1 : 0}|l:${node.local ? 1 : 0}`
+    case 'date':
+    case 'time':
+      return `${node.type}|${flags}|rep:${node.representation}`
+    default:
+      return `${node.type}|${flags}`
+  }
+}
+
+/**
+ * Hash-consing: each node's signature is a fixed-length digest of its local shape plus its
+ * children's digests (a Merkle hash). Children contribute their 64-char hash instead of their
+ * full nested descriptor, so a signature stays bounded regardless of subtree depth, and the
+ * digest is identical across calls because it depends only on content — never on traversal
+ * order. This keeps the keys built during planning consistent with the ones recomputed later
+ * during streaming. `signatures` memoizes node → digest within a single computation.
+ */
+export function signatureOf(node: SchemaNode, signatures: Map<SchemaNode, string>): string {
+  const cached = signatures.get(node)
+  if (cached !== undefined) return cached
+  const signature = createHash('sha256').update(describeShape(node, signatures)).digest('hex')
+  signatures.set(node, signature)
+  return signature
+}
+
+/**
+ * Computes a deterministic, shape-only signature (a fixed-length content hash) for a schema node.
+ *
+ * Two schemas share a signature when they are structurally identical, ignoring
+ * documentation (`name`, `title`, `description`, `example`, `default`, `deprecated`)
+ * and usage-slot flags (`optional`, `nullish`, `readOnly`, `writeOnly`). `nullable`
+ * is kept because it changes the produced type. `ref` nodes compare by target name,
+ * which also keeps the algorithm terminating on circular shapes.
+ *
+ * @example Two enums with different descriptions share a signature
+ * ```ts
+ * schemaSignature(createSchema({ type: 'enum', primitive: 'string', enumValues: ['a', 'b'], description: 'x' })) ===
+ *   schemaSignature(createSchema({ type: 'enum', primitive: 'string', enumValues: ['a', 'b'] }))
+ * ```
+ */
+export function schemaSignature(node: SchemaNode): string {
+  return signatureOf(node, new Map())
+}
+
+/**
+ * Returns `true` when two schema nodes are structurally identical under shape-only equality.
+ *
+ * @example
+ * ```ts
+ * isSchemaEqual(a, b) // a and b produce the same TypeScript type
+ * ```
+ */
+export function isSchemaEqual(a: SchemaNode, b: SchemaNode): boolean {
+  return schemaSignature(a) === schemaSignature(b)
+}

package/src/transformers.ts

@@ -73,25 +73,30 @@ export function setDiscriminatorEnum({
  * ])
  * ```
  */
-export function mergeAdjacentObjects(members: Array<SchemaNode>): Array<SchemaNode> {
-  return members.reduce<Array<SchemaNode>>((acc, member) => {
+export function* mergeAdjacentObjectsLazy(members: Iterable<SchemaNode>): Generator<SchemaNode, void, undefined> {
+  let acc: SchemaNode | undefined
+
+  for (const member of members) {
     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 ?? [])],
+    if (objectMember && !objectMember.name && acc !== undefined) {
+      const accObject = narrowSchema(acc, 'object')
+      if (accObject && !accObject.name) {
+        acc = createSchema({
+          ...accObject,
+          properties: [...(accObject.properties ?? []), ...(objectMember.properties ?? [])],
         })
-        return acc
+        continue
       }
     }
+    if (acc !== undefined) yield acc
+    acc = member
+  }
 
-    acc.push(member)
-    return acc
-  }, [])
+  if (acc !== undefined) yield acc
+}
+
+export function mergeAdjacentObjects(members: Array<SchemaNode>): Array<SchemaNode> {
+  return [...mergeAdjacentObjectsLazy(members)]
 }
 
 /**
@@ -145,7 +150,7 @@ export function setEnumName(propNode: SchemaNode, parentName: string | null | un
   const enumNode = narrowSchema(propNode, 'enum')
 
   if (enumNode?.primitive === 'boolean') {
-    return { ...propNode, name: undefined }
+    return { ...propNode, name: null }
   }
 
   if (enumNode) {

package/src/types.ts

@@ -1,4 +1,7 @@
 export type { VisitorDepth } from './constants.ts'
+export type { BuildDedupePlanOptions, DedupeCanonical, DedupePlan } from './dedupe.ts'
+export type { SchemaDialect } from './dialect.ts'
+export type { DispatchRule } from './dispatch.ts'
 export type { DistributiveOmit } from './factory.ts'
 export type { InferSchema, InferSchemaNode, ParserOptions } from './infer.ts'
 export type {
@@ -21,11 +24,14 @@ export type {
   FunctionParameterNode,
   FunctionParametersNode,
   FunctionParamNode,
+  GenericOperationNode,
   HttpMethod,
+  HttpOperationNode,
   HttpStatusCode,
   ImportNode,
   InputMeta,
   InputNode,
+  InputStreamNode,
   IntersectionSchemaNode,
   Ipv4SchemaNode,
   Ipv6SchemaNode,
@@ -37,6 +43,8 @@ export type {
   NumberSchemaNode,
   ObjectSchemaNode,
   OperationNode,
+  OperationNodeBase,
+  OperationProtocol,
   OutputNode,
   ParameterGroupNode,
   ParameterLocation,