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

package/src/constants.ts

@@ -62,6 +62,11 @@ export const schemaTypes = {
   never: 'never',
 } as const satisfies Record<SchemaType, SchemaType>
 
+/**
+ * Scalar primitive schema types used for union member simplification.
+ */
+export const SCALAR_PRIMITIVE_TYPES = new Set(['string', 'number', 'integer', 'bigint', 'boolean'] as const)
+
 export const httpMethods = {
   get: 'GET',
   post: 'POST',

package/src/index.ts

@@ -1,4 +1,4 @@
-export { httpMethods, mediaTypes, nodeKinds, schemaTypes } from './constants.ts'
+export { httpMethods, mediaTypes, nodeKinds, SCALAR_PRIMITIVE_TYPES, schemaTypes } from './constants.ts'
 export {
   createFunctionParameter,
   createFunctionParameters,
@@ -25,6 +25,7 @@ export {
   narrowSchema,
 } from './guards.ts'
 export { definePrinter } from './printer.ts'
-export { buildRefMap, refMapToObject, resolveRef } from './refs.ts'
+export { buildRefMap, extractRefName, refMapToObject, resolveRef } from './refs.ts'
+export { applyDiscriminatorEnum, mergeAdjacentAnonymousObjects, simplifyUnionMembers } from './transforms.ts'
 export { applyParamsCasing, isPlainStringType } from './utils.ts'
 export { collect, composeTransformers, transform, walk } from './visitor.ts'

package/src/refs.ts

@@ -6,6 +6,14 @@ import type { SchemaNode } from './nodes/schema.ts'
  */
 export type RefMap = Map<string, SchemaNode>
 
+/**
+ * Extracts the final segment from a reference string.
+ * Falls back to the original string when no slash exists.
+ */
+export function extractRefName(ref: string): string {
+  return ref.split('/').at(-1) ?? ref
+}
+
 /**
  * Indexes named schemas from `root.schemas` by name. Unnamed schemas are skipped.
  */

package/src/transforms.ts

@@ -0,0 +1,114 @@
+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'
+
+/**
+ * Replaces the discriminator property's schema inside an object node with
+ * an enum of the provided values.
+ */
+export function applyDiscriminatorEnum({
+  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.
+ */
+export function mergeAdjacentAnonymousObjects(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 subsumed by broader scalar members in the same union.
+ */
+export function simplifyUnionMembers(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
+    }
+
+    if (!enumNode.enumType) {
+      return true
+    }
+
+    if (scalarPrimitives.has(primitive)) {
+      return false
+    }
+
+    if ((primitive === 'integer' || primitive === 'number') && (scalarPrimitives.has('integer') || scalarPrimitives.has('number'))) {
+      return false
+    }
+
+    return true
+  })
+}