@kubb/ast 5.0.0-beta.60 → 5.0.0-beta.62

package/src/nodes/requestBody.ts

@@ -1,6 +1,6 @@
-import { defineNode } from '../node.ts'
+import { defineNode } from '../defineNode.ts'
 import type { BaseNode } from './base.ts'
-import { type ContentNode, createContent, type UserContent } from './content.ts'
+import type { ContentNode } from './content.ts'
 
 /**
  * AST node representing an operation request body.
@@ -40,22 +40,15 @@ export type RequestBodyNode = BaseNode & {
 }
 
 /**
- * Loosely-typed request body accepted by `createOperation`, normalized into a {@link RequestBodyNode}.
+ * Definition for the {@link RequestBodyNode}. Content entries are built upfront with
+ * {@link createContent}, mirroring how `parameters` and `responses` take prebuilt nodes.
  */
-export type UserRequestBody = Omit<RequestBodyNode, 'kind' | 'content'> & {
-  content?: Array<UserContent>
-}
-
-/**
- * Definition for the {@link RequestBodyNode}, normalizing each content entry into a `ContentNode`.
- */
-export const requestBodyDef = defineNode<RequestBodyNode, UserRequestBody>({
+export const requestBodyDef = defineNode<RequestBodyNode>({
   kind: 'RequestBody',
-  build: (props) => ({ ...props, content: props.content?.map(createContent) }),
   children: ['content'],
 })
 
 /**
- * Creates a `RequestBodyNode`, normalizing each content entry into a `ContentNode`.
+ * Creates a `RequestBodyNode`.
  */
 export const createRequestBody = requestBodyDef.create

package/src/nodes/response.ts

@@ -1,9 +1,94 @@
-import { defineNode } from '../node.ts'
+import { defineNode } from '../defineNode.ts'
 import type { BaseNode } from './base.ts'
-import { type ContentNode, createContent, type UserContent } from './content.ts'
-import type { StatusCode } from './http.ts'
+import { type ContentNode, createContent } from './content.ts'
 import type { SchemaNode } from './schema.ts'
 
+/**
+ * All supported HTTP status code literals as strings, as used in API specs
+ * (for example, `"200"` and `"404"`).
+ */
+type HttpStatusCode =
+  // 1xx Informational
+  | '100'
+  | '101'
+  | '102'
+  | '103'
+  // 2xx Success
+  | '200'
+  | '201'
+  | '202'
+  | '203'
+  | '204'
+  | '205'
+  | '206'
+  | '207'
+  | '208'
+  | '226'
+  // 3xx Redirection
+  | '300'
+  | '301'
+  | '302'
+  | '303'
+  | '304'
+  | '305'
+  | '307'
+  | '308'
+  // 4xx Client Error
+  | '400'
+  | '401'
+  | '402'
+  | '403'
+  | '404'
+  | '405'
+  | '406'
+  | '407'
+  | '408'
+  | '409'
+  | '410'
+  | '411'
+  | '412'
+  | '413'
+  | '414'
+  | '415'
+  | '416'
+  | '417'
+  | '418'
+  | '421'
+  | '422'
+  | '423'
+  | '424'
+  | '425'
+  | '426'
+  | '428'
+  | '429'
+  | '431'
+  | '451'
+  // 5xx Server Error
+  | '500'
+  | '501'
+  | '502'
+  | '503'
+  | '504'
+  | '505'
+  | '506'
+  | '507'
+  | '508'
+  | '510'
+  | '511'
+
+/**
+ * Response status code literal used by operations.
+ *
+ * Includes specific HTTP status code strings and `"default"` for catch-all responses.
+ *
+ * @example
+ * ```ts
+ * const status: StatusCode = '200'
+ * const fallback: StatusCode = 'default'
+ * ```
+ */
+export type StatusCode = HttpStatusCode | 'default'
+
 /**
  * AST node representing one operation response variant.
  *
@@ -16,7 +101,7 @@ import type { SchemaNode } from './schema.ts'
  * const response: ResponseNode = {
  *   kind: 'Response',
  *   statusCode: '200',
- *   content: [{ contentType: 'application/json', schema: createSchema({ type: 'string' }) }],
+ *   content: [{ kind: 'Content', contentType: 'application/json', schema: createSchema({ type: 'string' }) }],
  * }
  * ```
  */
@@ -53,7 +138,7 @@ export type ResponseNode = BaseNode & {
 
 type ResponseInput = Pick<ResponseNode, 'statusCode'> &
   Partial<Omit<ResponseNode, 'kind' | 'statusCode' | 'content'>> & {
-    content?: Array<UserContent>
+    content?: Array<ContentNode>
     schema?: SchemaNode
     mediaType?: string | null
     keysToOmit?: Array<string> | null
@@ -67,8 +152,8 @@ export const responseDef = defineNode<ResponseNode, ResponseInput>({
   kind: 'Response',
   build: (props) => {
     const { schema, mediaType, keysToOmit, content, ...rest } = props
-    const entries = content ?? (schema ? [{ contentType: mediaType ?? 'application/json', schema, keysToOmit: keysToOmit ?? null }] : undefined)
-    return { ...rest, content: entries?.map(createContent) }
+    const entries = content ?? (schema ? [createContent({ contentType: mediaType ?? 'application/json', schema, keysToOmit: keysToOmit ?? null })] : undefined)
+    return { ...rest, content: entries }
   },
   children: ['content'],
   visitorKey: 'response',
@@ -81,7 +166,7 @@ export const responseDef = defineNode<ResponseNode, ResponseInput>({
  * ```ts
  * const response = createResponse({
  *   statusCode: '200',
- *   content: [{ contentType: 'application/json', schema: createSchema({ type: 'object', properties: [] }) }],
+ *   content: [createContent({ contentType: 'application/json', schema: createSchema({ type: 'object', properties: [] }) })],
  * })
  * ```
  */

package/src/nodes/schema.ts

@@ -1,5 +1,5 @@
 import type { InferSchemaNode } from '../infer.ts'
-import { defineNode, type DistributiveOmit } from '../node.ts'
+import { defineNode, type DistributiveOmit } from '../defineNode.ts'
 import type { BaseNode } from './base.ts'
 import type { PropertyNode } from './property.ts'
 

package/src/registry.ts

@@ -1,4 +1,4 @@
-import type { NodeDef } from './node.ts'
+import type { NodeDef } from './defineNode.ts'
 import { arrowFunctionDef, breakDef, constDef, functionDef, jsxDef, textDef, typeDef } from './nodes/code.ts'
 import { contentDef } from './nodes/content.ts'
 import { exportDef, fileDef, importDef, sourceDef } from './nodes/file.ts'

package/src/types.ts

@@ -1,9 +1,9 @@
 export type { DedupeCanonical, DedupeLookups, DedupePlan } from './dedupe.ts'
-export type { SchemaDialect } from './dialect.ts'
-export type { DistributiveOmit } from './node.ts'
+export type { Dialect, SchemaDialect } from './dialect.ts'
+export type { DistributiveOmit, NodeDef } from './defineNode.ts'
 export type { InferSchemaNode, ParserOptions } from './infer.ts'
 export type * from './nodes/index.ts'
 export type { ParentOf, Visitor, VisitorContext } from './visitor.ts'
-export type { Printer, PrinterFactoryOptions, PrinterPartial } from './printer.ts'
+export type { Printer, PrinterFactoryOptions, PrinterPartial } from './definePrinter.ts'
 export type { OperationParamsResolver } from './utils/operationParams.ts'
-export type { UserFileNode } from './factory.ts'
+export type { Enforce, Macro } from './defineMacro.ts'

package/src/utils/extractStringsFromNodes.ts

@@ -8,6 +8,7 @@ import type { CodeNode } from '../nodes/code.ts'
  */
 export function extractStringsFromNodes(nodes: Array<CodeNode> | undefined): string {
   if (!nodes?.length) return ''
+
   return nodes
     .map((node) => {
       // Backward-compat: compiled plugins may still pass bare strings at runtime

package/src/utils/index.ts

@@ -1,8 +1,8 @@
 export { isValidVarName } from '@internals/utils'
 export { buildJSDoc, buildList, buildObject, objectKey } from './codegen.ts'
 export { extractStringsFromNodes } from './extractStringsFromNodes.ts'
-export { childName, enumPropName, extractRefName, isStringType, resolveGroupType, resolveRefName } from './refs.ts'
-export { syncSchemaRef } from '../transformers.ts'
+export { childName, enumPropName, extractRefName, isStringType, resolveGroupType, resolveRefName, syncSchemaRef } from './refs.ts'
+export { mergeAdjacentObjectsLazy } from './schemaMerge.ts'
 export { getNestedAccessor, jsStringEscape, stringify, stringifyObject, toRegExpString, trimQuotes } from './strings.ts'
 export { collectUsedSchemaNames, containsCircularRef, findCircularSchemas } from './schemaGraph.ts'
 export { lazyGetter, mapSchemaItems, mapSchemaMembers, mapSchemaProperties } from './schemaTraversal.ts'

package/src/utils/operationParams.ts

@@ -206,7 +206,7 @@ export function resolveParamType({
   const groupName = groupLocation ? groupResolvers[groupLocation].call(resolver, node, param) : undefined
 
   if (groupName && groupName !== individualName) {
-    return createIndexedAccessType({ objectType: groupName, indexType: param.name })
+    return createIndexedAccessType({ target: groupName, key: param.name })
   }
 
   return individualName

package/src/utils/refs.ts

@@ -1,7 +1,7 @@
 import { pascalCase } from '@internals/utils'
 import { narrowSchema } from '../guards.ts'
 import type { OperationNode, ParameterNode, SchemaNode } from '../nodes/index.ts'
-import type { SchemaType } from '../nodes/schema.ts'
+import { createSchema, type SchemaType } from '../nodes/schema.ts'
 import type { OperationParamsResolver, ParamGroupType } from './operationParams.ts'
 
 const plainStringTypes = new Set<SchemaType>(['string', 'uuid', 'email', 'url', 'datetime'] as const)
@@ -63,6 +63,32 @@ export function enumPropName(parentName: string | null | undefined, propName: st
   return pascalCase([parentName, propName, enumSuffix].filter(Boolean).join(' '))
 }
 
+/**
+ * Merges a ref node with its resolved schema, giving usage-site fields precedence.
+ *
+ * Usage-site fields (`description`, `readOnly`, `nullable`, `deprecated`) on the ref node override
+ * the same fields in the resolved `node.schema`. Non-ref nodes are returned unchanged.
+ *
+ * @example
+ * ```ts
+ * const ref = createSchema({ type: 'ref', ref: '#/components/schemas/Pet', description: 'A cute pet' })
+ * const merged = syncSchemaRef(ref) // merges with resolved Pet schema
+ * ```
+ */
+export function syncSchemaRef(node: SchemaNode): SchemaNode {
+  const ref = narrowSchema(node, 'ref')
+
+  if (!ref) return node
+  if (!ref.schema) return node
+
+  const { kind: _kind, type: _type, name: _name, ref: _ref, schema: _schema, ...overrides } = ref
+
+  // Filter out undefined override values so they don't shadow the resolved schema's fields.
+  const definedOverrides = Object.fromEntries(Object.entries(overrides).filter(([, v]) => v !== undefined))
+
+  return createSchema({ ...ref.schema, ...definedOverrides })
+}
+
 /**
  * Type guard that returns `true` when a schema emits as a plain `string` type.
  *

package/src/utils/schemaMerge.ts

@@ -0,0 +1,34 @@
+import { narrowSchema } from '../guards.ts'
+import { createSchema, type SchemaNode } from '../nodes/schema.ts'
+
+/**
+ * Merges a run of adjacent anonymous object members into one. Named or non-object members break the
+ * run and pass through. Stays a construction-time helper, not a macro, so callers keep control of the
+ * member boundaries (such as keeping synthetic discriminant objects out of a run).
+ *
+ * @example
+ * ```ts
+ * const merged = [...mergeAdjacentObjectsLazy([objectA, objectB])]
+ * ```
+ */
+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 && acc !== undefined) {
+      const accObject = narrowSchema(acc, 'object')
+      if (accObject && !accObject.name) {
+        acc = createSchema({
+          ...accObject,
+          properties: [...(accObject.properties ?? []), ...(objectMember.properties ?? [])],
+        })
+        continue
+      }
+    }
+    if (acc !== undefined) yield acc
+    acc = member
+  }
+
+  if (acc !== undefined) yield acc
+}

package/src/visitor.ts

@@ -1,6 +1,6 @@
 import type { VisitorDepth } from './constants.ts'
 import { visitorDepths, WALK_CONCURRENCY } from './constants.ts'
-import type { NodeDef } from './node.ts'
+import type { NodeDef } from './defineNode.ts'
 import type {
   ContentNode,
   InputNode,
@@ -32,14 +32,6 @@ const VISITOR_KEY_BY_KIND = Object.fromEntries(nodeDefs.flatMap((def) => (def.vi
   Record<NodeKind, NonNullable<NodeDef['visitorKey']>>
 >
 
-/**
- * Per-kind builders rerun after children are rebuilt. Derived from each
- * definition's `rebuild` flag.
- */
-const nodeRebuilders = Object.fromEntries(
-  nodeDefs.flatMap((def) => (def.rebuild ? [[def.kind, def.create as unknown as (node: Node) => Node] as const] : [])),
-) as Partial<Record<NodeKind, (node: Node) => Node>>
-
 /**
  * Creates a small async concurrency limiter.
  *
@@ -443,10 +435,7 @@ export function transform(node: Node, options: TransformOptions): Node {
   // Structural sharing: when the visitor and child rebuild both left this node
   // untouched, return the original reference so callers can detect "nothing
   // changed" by identity and ancestors can avoid reallocating.
-  if (rebuilt === node) return node
-
-  const rebuild = nodeRebuilders[rebuilt.kind]
-  return rebuild ? rebuild(rebuilt) : rebuilt
+  return rebuilt
 }
 
 /**

package/dist/extractStringsFromNodes-WMYJ8nQL.d.ts

@@ -1,82 +0,0 @@
-import { n as __name } from "./chunk-CNktS9qV.js";
-import { Pt as CodeNode, _t as SchemaNode } from "./index-BzjwdK2M.js";
-
-//#region src/transformers.d.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'] })
- * ```
- */
-declare function setDiscriminatorEnum({
-  node,
-  propertyName,
-  values,
-  enumName
-}: {
-  node: SchemaNode;
-  propertyName: string;
-  values: Array<string>;
-  enumName?: string;
-}): SchemaNode;
-/**
- * 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' }) })] }),
- * ])
- * ```
- */
-declare function mergeAdjacentObjectsLazy(members: Iterable<SchemaNode>): Generator<SchemaNode, void, undefined>;
-/**
- * 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
- * ```
- */
-declare function simplifyUnion(members: Array<SchemaNode>): Array<SchemaNode>;
-declare function setEnumName(propNode: SchemaNode, parentName: string | null | undefined, propName: string, enumSuffix: string): SchemaNode;
-/**
- * Merges a ref node with its resolved schema, giving usage-site fields precedence.
- *
- * Usage-site fields (`description`, `readOnly`, `nullable`, `deprecated`) on the ref node override
- * the same fields in the resolved `node.schema`. Non-ref nodes are returned unchanged.
- *
- * @example
- * ```ts
- * // Ref with description override
- * const ref = createSchema({ type: 'ref', ref: '#/components/schemas/Pet', description: 'A cute pet' })
- * const merged = syncSchemaRef(ref)  // merges with resolved Pet schema
- * ```
- */
-declare function syncSchemaRef(node: SchemaNode): SchemaNode;
-//#endregion
-//#region src/utils/extractStringsFromNodes.d.ts
-/**
- * Extracts all string content from a `CodeNode` tree recursively.
- *
- * Collects text node values, identifier references in string fields (`params`, `generics`, `returnType`, `type`),
- * and nested node content. Used to build the full source string for import filtering.
- */
-declare function extractStringsFromNodes(nodes: Array<CodeNode> | undefined): string;
-//#endregion
-export { simplifyUnion as a, setEnumName as i, mergeAdjacentObjectsLazy as n, syncSchemaRef as o, setDiscriminatorEnum as r, extractStringsFromNodes as t };
-//# sourceMappingURL=extractStringsFromNodes-WMYJ8nQL.d.ts.map