@kubb/ast 5.0.0-alpha.48 → 5.0.0-alpha.49

package/package.json

@@ -1,23 +1,33 @@
 {
   "name": "@kubb/ast",
-  "version": "5.0.0-alpha.48",
+  "version": "5.0.0-alpha.49",
   "description": "Spec-agnostic AST layer for Kubb. Defines nodes, visitor pattern, and factory functions used across codegen plugins.",
   "keywords": [
-    "kubb",
     "ast",
-    "typescript",
     "codegen",
-    "openapi"
+    "kubb",
+    "openapi",
+    "typescript"
   ],
+  "license": "MIT",
+  "author": "stijnvanhulle",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/kubb-labs/kubb.git",
     "directory": "packages/ast"
   },
-  "license": "MIT",
-  "author": "stijnvanhulle",
-  "sideEffects": false,
+  "files": [
+    "src",
+    "dist",
+    "!/**/**.test.**",
+    "!/**/__tests__/**",
+    "!/**/__snapshots__/**"
+  ],
   "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "import": "./dist/index.js",
@@ -25,32 +35,22 @@
     },
     "./package.json": "./package.json"
   },
-  "types": "./dist/index.d.ts",
-  "files": [
-    "src",
-    "dist",
-    "!/**/**.test.**",
-    "!/**/__tests__/**",
-    "!/**/__snapshots__/**"
-  ],
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
   "devDependencies": {
     "@types/node": "^25.6.0",
     "@internals/utils": "0.0.0"
   },
-  "main": "./dist/index.cjs",
-  "module": "./dist/index.js",
   "engines": {
     "node": ">=22"
   },
-  "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org/"
-  },
   "scripts": {
     "build": "tsdown",
     "clean": "npx rimraf ./dist",
-    "lint": "bun biome lint .",
-    "lint:fix": "bun biome lint --fix --unsafe .",
+    "lint": "oxlint .",
+    "lint:fix": "oxlint --fix .",
     "release": "pnpm publish --no-git-check",
     "release:canary": "bash ../../.github/canary.sh && node ../../scripts/build.js canary && pnpm publish --no-git-check",
     "start": "tsdown --watch",

package/src/factory.ts

@@ -61,7 +61,9 @@ export type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omi
 
 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' }
+type CreateSchemaOutput<T extends CreateSchemaInput> = InferSchemaNode<T> & {
+  kind: 'Schema'
+}
 
 /**
  * Creates an `InputNode` with stable defaults for `schemas` and `operations`.
@@ -208,10 +210,19 @@ export function createSchema(props: CreateSchemaInput): SchemaNode {
   const inferredPrimitive = TYPE_TO_PRIMITIVE[props.type as keyof typeof TYPE_TO_PRIMITIVE]
 
   if (props['type'] === 'object') {
-    return { properties: [], primitive: 'object', ...props, kind: 'Schema' } as CreateSchemaOutput<typeof props>
+    return {
+      properties: [],
+      primitive: 'object',
+      ...props,
+      kind: 'Schema',
+    } as CreateSchemaOutput<typeof props>
   }
 
-  return { primitive: inferredPrimitive, ...props, kind: 'Schema' } as CreateSchemaOutput<typeof props>
+  return {
+    primitive: inferredPrimitive,
+    ...props,
+    kind: 'Schema',
+  } as CreateSchemaOutput<typeof props>
 }
 
 type UserPropertyNode = Pick<PropertyNode, 'name' | 'schema'> & Partial<Omit<PropertyNode, 'kind' | 'name' | 'schema'>>
@@ -369,7 +380,14 @@ export function createFunctionParameter(
 export function createParamsType(
   props:
     | { variant: 'reference'; name: string }
-    | { variant: 'struct'; properties: Array<{ name: string; optional: boolean; type: ParamsTypeNode }> }
+    | {
+        variant: 'struct'
+        properties: Array<{
+          name: string
+          optional: boolean
+          type: ParamsTypeNode
+        }>
+      }
     | { variant: 'member'; base: string; key: string },
 ): ParamsTypeNode {
   return { ...props, kind: 'ParamsType' } as ParamsTypeNode

package/src/index.ts

@@ -34,12 +34,5 @@ export { childName, collectImports, enumPropName, findDiscriminator } from './re
 export { mergeAdjacentObjects, setDiscriminatorEnum, setEnumName, simplifyUnion } from './transformers.ts'
 export type * from './types.ts'
 export type { OperationParamsResolver } from './utils.ts'
-export {
-  caseParams,
-  createDiscriminantNode,
-  createOperationParams,
-  extractStringsFromNodes,
-  isStringType,
-  syncSchemaRef,
-} from './utils.ts'
+export { caseParams, createDiscriminantNode, createOperationParams, extractStringsFromNodes, isStringType, syncSchemaRef } from './utils.ts'
 export { collect, transform, walk } from './visitor.ts'

package/src/mocks.ts

@@ -9,8 +9,16 @@ export function buildSampleTree(): InputNode {
     type: 'object',
     name: 'Pet',
     properties: [
-      createProperty({ name: 'id', schema: createSchema({ type: 'integer' }), required: true }),
-      createProperty({ name: 'name', schema: createSchema({ type: 'string' }), required: true }),
+      createProperty({
+        name: 'id',
+        schema: createSchema({ type: 'integer' }),
+        required: true,
+      }),
+      createProperty({
+        name: 'name',
+        schema: createSchema({ type: 'string' }),
+        required: true,
+      }),
     ],
   })
 
@@ -19,9 +27,19 @@ export function buildSampleTree(): InputNode {
     method: 'GET',
     path: '/pets/{petId}',
     tags: ['pets'],
-    parameters: [createParameter({ name: 'petId', in: 'path', schema: createSchema({ type: 'integer' }), required: true })],
+    parameters: [
+      createParameter({
+        name: 'petId',
+        in: 'path',
+        schema: createSchema({ type: 'integer' }),
+        required: true,
+      }),
+    ],
     responses: [
-      createResponse({ statusCode: '200', schema: createSchema({ type: 'ref', name: 'Pet' }) }),
+      createResponse({
+        statusCode: '200',
+        schema: createSchema({ type: 'ref', name: 'Pet' }),
+      }),
       createResponse({
         statusCode: '404',
         schema: createSchema({ type: 'ref', name: 'Error' }),
@@ -47,14 +65,28 @@ export function buildFixture(): InputNode {
         name: 'Pet',
         type: 'object',
         properties: [
-          createProperty({ name: 'id', schema: createSchema({ type: 'integer' }), required: true }),
-          createProperty({ name: 'name', schema: createSchema({ type: 'string' }), required: true }),
+          createProperty({
+            name: 'id',
+            schema: createSchema({ type: 'integer' }),
+            required: true,
+          }),
+          createProperty({
+            name: 'name',
+            schema: createSchema({ type: 'string' }),
+            required: true,
+          }),
         ],
       }),
       createSchema({
         name: 'NewPet',
         type: 'object',
-        properties: [createProperty({ name: 'name', schema: createSchema({ type: 'string' }), required: true })],
+        properties: [
+          createProperty({
+            name: 'name',
+            schema: createSchema({ type: 'string' }),
+            required: true,
+          }),
+        ],
       }),
       createSchema({
         name: 'PetList',
@@ -65,11 +97,23 @@ export function buildFixture(): InputNode {
         name: 'Error',
         type: 'object',
         properties: [
-          createProperty({ name: 'code', schema: createSchema({ type: 'integer' }), required: true }),
-          createProperty({ name: 'message', schema: createSchema({ type: 'string' }), required: true }),
+          createProperty({
+            name: 'code',
+            schema: createSchema({ type: 'integer' }),
+            required: true,
+          }),
+          createProperty({
+            name: 'message',
+            schema: createSchema({ type: 'string' }),
+            required: true,
+          }),
         ],
       }),
-      createSchema({ name: 'PetOrError', type: 'union', members: [refPet, refError] }),
+      createSchema({
+        name: 'PetOrError',
+        type: 'union',
+        members: [refPet, refError],
+      }),
       createSchema({
         name: 'FullPet',
         type: 'intersection',
@@ -77,7 +121,12 @@ export function buildFixture(): InputNode {
           refPet,
           createSchema({
             type: 'object',
-            properties: [createProperty({ name: 'createdAt', schema: createSchema({ type: 'datetime' }) })],
+            properties: [
+              createProperty({
+                name: 'createdAt',
+                schema: createSchema({ type: 'datetime' }),
+              }),
+            ],
           }),
         ],
       }),
@@ -88,10 +137,24 @@ export function buildFixture(): InputNode {
         method: 'GET',
         path: '/pets',
         tags: ['pets'],
-        parameters: [createParameter({ name: 'limit', in: 'query', schema: createSchema({ type: 'integer' }) })],
+        parameters: [
+          createParameter({
+            name: 'limit',
+            in: 'query',
+            schema: createSchema({ type: 'integer' }),
+          }),
+        ],
         responses: [
-          createResponse({ statusCode: '200', schema: createSchema({ type: 'ref', ref: 'PetList' }), mediaType: 'application/json' }),
-          createResponse({ statusCode: '400', schema: refError, mediaType: 'application/json' }),
+          createResponse({
+            statusCode: '200',
+            schema: createSchema({ type: 'ref', ref: 'PetList' }),
+            mediaType: 'application/json',
+          }),
+          createResponse({
+            statusCode: '400',
+            schema: refError,
+            mediaType: 'application/json',
+          }),
         ],
       }),
       createOperation({
@@ -100,7 +163,13 @@ export function buildFixture(): InputNode {
         path: '/pets',
         tags: ['pets'],
         requestBody: { schema: createSchema({ type: 'ref', ref: 'NewPet' }) },
-        responses: [createResponse({ statusCode: '201', schema: refPet, mediaType: 'application/json' })],
+        responses: [
+          createResponse({
+            statusCode: '201',
+            schema: refPet,
+            mediaType: 'application/json',
+          }),
+        ],
       }),
     ],
   })

package/src/nodes/function.ts

@@ -53,7 +53,11 @@ export type ParamsTypeNode = BaseNode & {
         /**
          * Properties of the struct type.
          */
-        properties: Array<{ name: string; optional: boolean; type: ParamsTypeNode }>
+        properties: Array<{
+          name: string
+          optional: boolean
+          type: ParamsTypeNode
+        }>
       }
     | {
         /**

package/src/printer.ts

@@ -201,11 +201,20 @@ export function createPrinterFactory<TNode, TKey extends string, TNodeByKey exte
       options: T['options']
       nodes: Partial<{
         [K in TKey]: (
-          this: { transform: (node: TNode) => T['output'] | null | undefined; options: T['options'] },
+          this: {
+            transform: (node: TNode) => T['output'] | null | undefined
+            options: T['options']
+          },
           node: TNodeByKey[K],
         ) => T['output'] | null | undefined
       }>
-      print?: (this: { transform: (node: TNode) => T['output'] | null | undefined; options: T['options'] }, node: TNode) => T['printOutput'] | null | undefined
+      print?: (
+        this: {
+          transform: (node: TNode) => T['output'] | null | undefined
+          options: T['options']
+        },
+        node: TNode,
+      ) => T['printOutput'] | null | undefined
     },
   ): (options?: T['options']) => {
     name: T['name']

package/src/transformers.ts

@@ -149,7 +149,10 @@ export function setEnumName(propNode: SchemaNode, parentName: string | null | un
   }
 
   if (enumNode) {
-    return { ...propNode, name: enumPropName(parentName, propName, enumSuffix) }
+    return {
+      ...propNode,
+      name: enumPropName(parentName, propName, enumSuffix),
+    }
   }
 
   return propNode

package/src/utils.ts

@@ -273,7 +273,10 @@ function resolveParamsType({
   resolver: OperationParamsResolver | undefined
 }): ParamsTypeNode {
   if (!resolver) {
-    return createParamsType({ variant: 'reference', name: param.schema.primitive ?? 'unknown' })
+    return createParamsType({
+      variant: 'reference',
+      name: param.schema.primitive ?? 'unknown',
+    })
   }
 
   const individualName = resolver.resolveParamName(node, param)
@@ -289,7 +292,11 @@ function resolveParamsType({
   const groupName = groupLocation ? groupResolvers[groupLocation].call(resolver, node, param) : undefined
 
   if (groupName && groupName !== individualName) {
-    return createParamsType({ variant: 'member', base: groupName, key: param.name })
+    return createParamsType({
+      variant: 'member',
+      base: groupName,
+      key: param.name,
+    })
   }
 
   return createParamsType({ variant: 'reference', name: individualName })
@@ -319,7 +326,11 @@ export function createOperationParams(node: OperationNode, options: CreateOperat
   const headersName = paramNames?.headers ?? 'headers'
   const pathName = paramNames?.path ?? 'pathParams'
 
-  const wrapType = (type: string): ParamsTypeNode => createParamsType({ variant: 'reference', name: typeWrapper ? typeWrapper(type) : type })
+  const wrapType = (type: string): ParamsTypeNode =>
+    createParamsType({
+      variant: 'reference',
+      name: typeWrapper ? typeWrapper(type) : type,
+    })
   // Only reference-variant TypeNodes are wrapped — they hold a plain type name string that needs casing applied.
   // Member and struct TypeNodes are pre-resolved structured expressions and are passed through unchanged.
   const wrapTypeNode = (type: ParamsTypeNode): ParamsTypeNode => (type.kind === 'ParamsType' && type.variant === 'reference' ? wrapType(type.name) : type)
@@ -332,8 +343,22 @@ export function createOperationParams(node: OperationNode, options: CreateOperat
   const bodyType = node.requestBody?.schema ? wrapType(resolver?.resolveDataName(node) ?? 'unknown') : undefined
   const bodyRequired = node.requestBody?.required ?? false
 
-  const queryGroupType = resolver ? resolveGroupType({ node, params: queryParams, groupMethod: resolver.resolveQueryParamsName, resolver }) : undefined
-  const headerGroupType = resolver ? resolveGroupType({ node, params: headerParams, groupMethod: resolver.resolveHeaderParamsName, resolver }) : undefined
+  const queryGroupType = resolver
+    ? resolveGroupType({
+        node,
+        params: queryParams,
+        groupMethod: resolver.resolveQueryParamsName,
+        resolver,
+      })
+    : undefined
+  const headerGroupType = resolver
+    ? resolveGroupType({
+        node,
+        params: headerParams,
+        groupMethod: resolver.resolveHeaderParamsName,
+        resolver,
+      })
+    : undefined
 
   const params: Array<FunctionParameterNode | ParameterGroupNode> = []
 
@@ -341,25 +366,66 @@ export function createOperationParams(node: OperationNode, options: CreateOperat
     const children: Array<FunctionParameterNode> = [
       ...pathParams.map((p) => {
         const type = resolveParamsType({ node, param: p, resolver })
-        return createFunctionParameter({ name: p.name, type: wrapTypeNode(type), optional: !p.required })
+        return createFunctionParameter({
+          name: p.name,
+          type: wrapTypeNode(type),
+          optional: !p.required,
+        })
+      }),
+      ...(bodyType
+        ? [
+            createFunctionParameter({
+              name: dataName,
+              type: bodyType,
+              optional: !bodyRequired,
+            }),
+          ]
+        : []),
+      ...buildGroupParam({
+        name: paramsName,
+        node,
+        params: queryParams,
+        groupType: queryGroupType,
+        resolver,
+        wrapType,
+      }),
+      ...buildGroupParam({
+        name: headersName,
+        node,
+        params: headerParams,
+        groupType: headerGroupType,
+        resolver,
+        wrapType,
       }),
-      ...(bodyType ? [createFunctionParameter({ name: dataName, type: bodyType, optional: !bodyRequired })] : []),
-      ...buildGroupParam({ name: paramsName, node, params: queryParams, groupType: queryGroupType, resolver, wrapType }),
-      ...buildGroupParam({ name: headersName, node, params: headerParams, groupType: headerGroupType, resolver, wrapType }),
     ]
 
     if (children.length) {
-      params.push(createParameterGroup({ properties: children, default: children.every((c) => c.optional) ? '{}' : undefined }))
+      params.push(
+        createParameterGroup({
+          properties: children,
+          default: children.every((c) => c.optional) ? '{}' : undefined,
+        }),
+      )
     }
   } else {
     if (pathParams.length) {
       if (pathParamsType === 'inlineSpread') {
         const spreadType = resolver?.resolvePathParamsName(node, pathParams[0]!) ?? undefined
-        params.push(createFunctionParameter({ name: pathName, type: spreadType ? wrapType(spreadType) : undefined, rest: true }))
+        params.push(
+          createFunctionParameter({
+            name: pathName,
+            type: spreadType ? wrapType(spreadType) : undefined,
+            rest: true,
+          }),
+        )
       } else {
         const pathChildren = pathParams.map((p) => {
           const type = resolveParamsType({ node, param: p, resolver })
-          return createFunctionParameter({ name: p.name, type: wrapTypeNode(type), optional: !p.required })
+          return createFunctionParameter({
+            name: p.name,
+            type: wrapTypeNode(type),
+            optional: !p.required,
+          })
         })
         params.push(
           createParameterGroup({
@@ -372,11 +438,35 @@ export function createOperationParams(node: OperationNode, options: CreateOperat
     }
 
     if (bodyType) {
-      params.push(createFunctionParameter({ name: dataName, type: bodyType, optional: !bodyRequired }))
+      params.push(
+        createFunctionParameter({
+          name: dataName,
+          type: bodyType,
+          optional: !bodyRequired,
+        }),
+      )
     }
 
-    params.push(...buildGroupParam({ name: paramsName, node, params: queryParams, groupType: queryGroupType, resolver, wrapType }))
-    params.push(...buildGroupParam({ name: headersName, node, params: headerParams, groupType: headerGroupType, resolver, wrapType }))
+    params.push(
+      ...buildGroupParam({
+        name: paramsName,
+        node,
+        params: queryParams,
+        groupType: queryGroupType,
+        resolver,
+        wrapType,
+      }),
+    )
+    params.push(
+      ...buildGroupParam({
+        name: headersName,
+        node,
+        params: headerParams,
+        groupType: headerGroupType,
+        resolver,
+        wrapType,
+      }),
+    )
   }
 
   params.push(...extraParams)
@@ -446,7 +536,10 @@ function resolveGroupType({
     return undefined
   }
   const allOptional = params.every((p) => !p.required)
-  return { type: createParamsType({ variant: 'reference', name: groupName }), optional: allOptional }
+  return {
+    type: createParamsType({ variant: 'reference', name: groupName }),
+    optional: allOptional,
+  }
 }
 
 /**
@@ -466,7 +559,11 @@ function toStructType({
 }): ParamsTypeNode {
   return createParamsType({
     variant: 'struct',
-    properties: params.map((p) => ({ name: p.name, optional: !p.required, type: resolveParamsType({ node, param: p, resolver }) })),
+    properties: params.map((p) => ({
+      name: p.name,
+      optional: !p.required,
+      type: resolveParamsType({ node, param: p, resolver }),
+    })),
   })
 }