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

package/src/transformers.ts

@@ -1,191 +0,0 @@
-import { isScalarPrimitive } from './constants.ts'
-import { narrowSchema } from './guards.ts'
-import { createProperty } from './nodes/property.ts'
-import { createSchema, type SchemaNode } from './nodes/schema.ts'
-import { enumPropName } from './utils/refs.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* 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
-}
-
-export function mergeAdjacentObjects(members: Array<SchemaNode>): Array<SchemaNode> {
-  return [...mergeAdjacentObjectsLazy(members)]
-}
-
-/**
- * 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: null }
-  }
-
-  if (enumNode) {
-    return {
-      ...propNode,
-      name: enumPropName(parentName, propName, enumSuffix),
-    }
-  }
-
-  return propNode
-}
-
-/**
- * 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
- * ```
- */
-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 })
-}