@kubb/ast 5.0.0-beta.55 → 5.0.0-beta.57

package/src/nodes/property.ts

@@ -1,3 +1,4 @@
+import { defineNode, syncOptionality } from '../node.ts'
 import type { BaseNode } from './base.ts'
 import type { SchemaNode } from './schema.ts'
 
@@ -32,3 +33,38 @@ export type PropertyNode = BaseNode & {
    */
   required: boolean
 }
+
+/**
+ * Loosely-typed property accepted by `createProperty`, with `required` optional.
+ */
+export type UserPropertyNode = Pick<PropertyNode, 'name' | 'schema'> & Partial<Omit<PropertyNode, 'kind' | 'name' | 'schema'>>
+
+/**
+ * Definition for the {@link PropertyNode}. `required` defaults to `false` and the
+ * schema's `optional`/`nullish` flags are kept in sync with it.
+ */
+export const propertyDef = defineNode<PropertyNode, UserPropertyNode>({
+  kind: 'Property',
+  build: (props) => {
+    const required = props.required ?? false
+    return { ...props, required, schema: syncOptionality(props.schema, required) }
+  },
+  children: ['schema'],
+  visitorKey: 'property',
+  rebuild: true,
+})
+
+/**
+ * Creates a `PropertyNode`.
+ *
+ * @example
+ * ```ts
+ * const property = createProperty({
+ *   name: 'status',
+ *   required: true,
+ *   schema: createSchema({ type: 'string', nullable: true }),
+ * })
+ * // required=true, no optional/nullish
+ * ```
+ */
+export const createProperty = propertyDef.create

package/src/nodes/requestBody.ts

@@ -1,5 +1,6 @@
+import { defineNode } from '../node.ts'
 import type { BaseNode } from './base.ts'
-import type { ContentNode } from './content.ts'
+import { type ContentNode, createContent, type UserContent } from './content.ts'
 
 /**
  * AST node representing an operation request body.
@@ -40,3 +41,24 @@ export type RequestBodyNode = BaseNode & {
    */
   content?: Array<ContentNode>
 }
+
+/**
+ * Loosely-typed request body accepted by `createOperation`, normalized into a {@link RequestBodyNode}.
+ */
+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>({
+  kind: 'RequestBody',
+  build: (props) => ({ ...props, content: props.content?.map(createContent) }),
+  children: ['content'],
+})
+
+/**
+ * Creates a `RequestBodyNode`, normalizing each content entry into a `ContentNode`.
+ */
+export const createRequestBody = requestBodyDef.create

package/src/nodes/response.ts

@@ -1,6 +1,8 @@
+import { defineNode } from '../node.ts'
 import type { BaseNode } from './base.ts'
-import type { ContentNode } from './content.ts'
+import { type ContentNode, createContent, type UserContent } from './content.ts'
 import type { StatusCode } from './http.ts'
+import type { SchemaNode } from './schema.ts'
 
 /**
  * AST node representing one operation response variant.
@@ -48,3 +50,39 @@ export type ResponseNode = BaseNode & {
    */
   content?: Array<ContentNode>
 }
+
+type ResponseInput = Pick<ResponseNode, 'statusCode'> &
+  Partial<Omit<ResponseNode, 'kind' | 'statusCode' | 'content'>> & {
+    content?: Array<UserContent>
+    schema?: SchemaNode
+    mediaType?: string | null
+    keysToOmit?: Array<string> | null
+  }
+
+/**
+ * Definition for the {@link ResponseNode}. A single legacy `schema` (with optional
+ * `mediaType`/`keysToOmit`) is normalized into one `content` entry.
+ */
+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) }
+  },
+  children: ['content'],
+  visitorKey: 'response',
+})
+
+/**
+ * Creates a `ResponseNode`.
+ *
+ * @example
+ * ```ts
+ * const response = createResponse({
+ *   statusCode: '200',
+ *   content: [{ contentType: 'application/json', schema: createSchema({ type: 'object', properties: [] }) }],
+ * })
+ * ```
+ */
+export const createResponse = responseDef.create

package/src/nodes/schema.ts

@@ -1,3 +1,5 @@
+import type { InferSchemaNode } from '../infer.ts'
+import { defineNode, type DistributiveOmit } from '../node.ts'
 import type { BaseNode } from './base.ts'
 import type { PropertyNode } from './property.ts'
 
@@ -657,3 +659,73 @@ export type SchemaNode =
   | Ipv4SchemaNode
   | Ipv6SchemaNode
   | ScalarSchemaNode
+
+type CreateSchemaObjectInput = Omit<ObjectSchemaNode, 'kind' | 'properties' | 'primitive'> & { properties?: Array<PropertyNode>; primitive?: 'object' }
+type CreateSchemaInput = CreateSchemaObjectInput | DistributiveOmit<Exclude<SchemaNode, ObjectSchemaNode>, 'kind'>
+type CreateSchemaOutput<T extends CreateSchemaInput> = InferSchemaNode<T> & {
+  kind: 'Schema'
+}
+
+/**
+ * Maps schema `type` to its underlying `primitive`.
+ * Primitive types map to themselves. Special string formats map to `'string'`.
+ * Complex types (`ref`, `enum`, `union`, `intersection`, `tuple`, `blob`) are left unset.
+ */
+const TYPE_TO_PRIMITIVE: Partial<Record<SchemaNode['type'], PrimitiveSchemaType>> = {
+  string: 'string',
+  number: 'number',
+  integer: 'integer',
+  bigint: 'bigint',
+  boolean: 'boolean',
+  null: 'null',
+  any: 'any',
+  unknown: 'unknown',
+  void: 'void',
+  never: 'never',
+  object: 'object',
+  array: 'array',
+  date: 'date',
+  uuid: 'string',
+  email: 'string',
+  url: 'string',
+  datetime: 'string',
+  time: 'string',
+}
+
+/**
+ * Definition for the {@link SchemaNode}. Object schemas default `properties` to an
+ * empty array, and `primitive` is inferred from `type` when not explicitly provided.
+ */
+export const schemaDef = defineNode<SchemaNode, CreateSchemaInput>({
+  kind: 'Schema',
+  build: (props) => {
+    if (props.type === 'object') {
+      return { properties: [], primitive: 'object' as const, ...props }
+    }
+
+    return { primitive: TYPE_TO_PRIMITIVE[props.type as keyof typeof TYPE_TO_PRIMITIVE], ...props }
+  },
+  children: ['properties', 'items', 'members', 'additionalProperties'],
+  visitorKey: 'schema',
+})
+
+/**
+ * Creates a `SchemaNode`, narrowed to the variant of `props.type`.
+ *
+ * @example
+ * ```ts
+ * const scalar = createSchema({ type: 'string' })
+ * // { kind: 'Schema', type: 'string', primitive: 'string' }
+ * ```
+ *
+ * @example
+ * ```ts
+ * const object = createSchema({ type: 'object' })
+ * // { kind: 'Schema', type: 'object', primitive: 'object', properties: [] }
+ * ```
+ */
+export function createSchema<T extends CreateSchemaInput>(props: T): CreateSchemaOutput<T>
+export function createSchema(props: CreateSchemaInput): SchemaNode
+export function createSchema(props: CreateSchemaInput): SchemaNode {
+  return schemaDef.create(props)
+}

package/src/registry.ts

@@ -0,0 +1,70 @@
+import type { NodeDef } from './node.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'
+import { functionParameterDef, functionParametersDef, indexedAccessTypeDef, objectBindingPatternDef, typeLiteralDef } from './nodes/function.ts'
+import type { Node, NodeKind } from './nodes/index.ts'
+import { inputDef } from './nodes/input.ts'
+import { operationDef } from './nodes/operation.ts'
+import { outputDef } from './nodes/output.ts'
+import { parameterDef } from './nodes/parameter.ts'
+import { propertyDef } from './nodes/property.ts'
+import { requestBodyDef } from './nodes/requestBody.ts'
+import { responseDef } from './nodes/response.ts'
+import { schemaDef } from './nodes/schema.ts'
+
+/**
+ * Every node definition. Adding a node means adding its `defineNode` to one
+ * `nodes/*.ts` file and listing it here. The visitor tables below derive from it.
+ */
+export const nodeDefs = [
+  inputDef,
+  outputDef,
+  operationDef,
+  requestBodyDef,
+  contentDef,
+  responseDef,
+  schemaDef,
+  propertyDef,
+  parameterDef,
+  functionParameterDef,
+  functionParametersDef,
+  typeLiteralDef,
+  indexedAccessTypeDef,
+  objectBindingPatternDef,
+  constDef,
+  typeDef,
+  functionDef,
+  arrowFunctionDef,
+  textDef,
+  breakDef,
+  jsxDef,
+  importDef,
+  exportDef,
+  sourceDef,
+  fileDef,
+] satisfies ReadonlyArray<NodeDef>
+
+/**
+ * Child node fields per node kind, in traversal order (Babel's `VISITOR_KEYS`).
+ * Derived from each definition's `children`.
+ */
+export const VISITOR_KEYS = Object.fromEntries(nodeDefs.flatMap((def) => (def.children ? [[def.kind, def.children] as const] : []))) as Partial<
+  Record<NodeKind, ReadonlyArray<string>>
+>
+
+/**
+ * Maps a node kind to the matching visitor callback name. Derived from each
+ * definition's `visitorKey`.
+ */
+export const VISITOR_KEY_BY_KIND = Object.fromEntries(nodeDefs.flatMap((def) => (def.visitorKey ? [[def.kind, def.visitorKey] as const] : []))) as Partial<
+  Record<NodeKind, NonNullable<NodeDef['visitorKey']>>
+>
+
+/**
+ * Per-kind builders rerun after children are rebuilt. Derived from each
+ * definition's `rebuild` flag.
+ */
+export 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>>

package/src/transformers.ts

@@ -1,7 +1,7 @@
 import { isScalarPrimitive } from './constants.ts'
-import { createProperty, createSchema } from './factory.ts'
 import { narrowSchema } from './guards.ts'
-import type { SchemaNode } from './nodes/schema.ts'
+import { createProperty } from './nodes/property.ts'
+import { createSchema, type SchemaNode } from './nodes/schema.ts'
 import { enumPropName } from './utils/index.ts'
 
 /**

package/src/types.ts

@@ -1,6 +1,6 @@
 export type { DedupeCanonical, DedupeLookups, DedupePlan } from './dedupe.ts'
 export type { SchemaDialect } from './dialect.ts'
-export type { DistributiveOmit } from './factory.ts'
+export type { DistributiveOmit } from './node.ts'
 export type { InferSchemaNode, ParserOptions } from './infer.ts'
 export type {
   ArraySchemaNode,
@@ -20,6 +20,7 @@ export type {
   HttpMethod,
   HttpOperationNode,
   ImportNode,
+  IndexedAccessTypeNode,
   InputMeta,
   InputNode,
   IntersectionSchemaNode,
@@ -28,13 +29,12 @@ export type {
   Node,
   NodeKind,
   NumberSchemaNode,
+  ObjectBindingPatternNode,
   ObjectSchemaNode,
   OperationNode,
   OutputNode,
-  ParameterGroupNode,
   ParameterLocation,
   ParameterNode,
-  ParamsTypeNode,
   PrimitiveSchemaType,
   PropertyNode,
   RefSchemaNode,
@@ -48,6 +48,8 @@ export type {
   StringSchemaNode,
   TextNode,
   TimeSchemaNode,
+  TypeExpression,
+  TypeLiteralNode,
   TypeNode,
   UnionSchemaNode,
   UrlSchemaNode,