@kubb/plugin-zod 5.0.0-alpha.34 → 5.0.0-alpha.35

package/src/types.ts

@@ -1,6 +1,5 @@
-import type { OperationParamsResolver } from '@kubb/ast'
-import type { OperationNode, ParameterNode, SchemaNode, StatusCode, Visitor } from '@kubb/ast/types'
 import type {
+  ast,
   CompatibilityPreset,
   Exclude,
   Generator,
@@ -21,7 +20,7 @@ import type { PrinterZodMiniNodes } from './printers/printerZodMini.ts'
  * Extends the base `Resolver` with zod-specific naming helpers.
  */
 export type ResolverZod = Resolver &
-  OperationParamsResolver & {
+  ast.OperationParamsResolver & {
     /**
      * Resolves a camelCase schema function name with a `Schema` suffix.
      */
@@ -56,42 +55,42 @@ export type ResolverZod = Resolver &
      * @example
      * resolver.resolveResponseStatusName(node, 200) // → 'listPetsStatus200Schema'
      */
-    resolveResponseStatusName(this: ResolverZod, node: OperationNode, statusCode: StatusCode): string
+    resolveResponseStatusName(this: ResolverZod, node: ast.OperationNode, statusCode: ast.StatusCode): string
     /**
      * Resolves the name for the collection of all operation responses.
      *
      * @example
      * resolver.resolveResponsesName(node) // → 'listPetsResponsesSchema'
      */
-    resolveResponsesName(this: ResolverZod, node: OperationNode): string
+    resolveResponsesName(this: ResolverZod, node: ast.OperationNode): string
     /**
      * Resolves the name for the union of all operation responses.
      *
      * @example
      * resolver.resolveResponseName(node) // → 'listPetsResponseSchema'
      */
-    resolveResponseName(this: ResolverZod, node: OperationNode): string
+    resolveResponseName(this: ResolverZod, node: ast.OperationNode): string
     /**
      * Resolves the name for an operation's grouped path parameters type.
      *
      * @example
      * resolver.resolvePathParamsName(node, param) // → 'deletePetPathPetIdSchema'
      */
-    resolvePathParamsName(this: ResolverZod, node: OperationNode, param: ParameterNode): string
+    resolvePathParamsName(this: ResolverZod, node: ast.OperationNode, param: ast.ParameterNode): string
     /**
      * Resolves the name for an operation's grouped query parameters type.
      *
      * @example
      * resolver.resolveQueryParamsName(node, param) // → 'findPetsByStatusQueryStatusSchema'
      */
-    resolveQueryParamsName(this: ResolverZod, node: OperationNode, param: ParameterNode): string
+    resolveQueryParamsName(this: ResolverZod, node: ast.OperationNode, param: ast.ParameterNode): string
     /**
      * Resolves the name for an operation's grouped header parameters type.
      *
      * @example
      * resolver.resolveHeaderParamsName(node, param) // → 'deletePetHeaderApiKeySchema'
      */
-    resolveHeaderParamsName(this: ResolverZod, node: OperationNode, param: ParameterNode): string
+    resolveHeaderParamsName(this: ResolverZod, node: ast.OperationNode, param: ast.ParameterNode): string
   }
 
 export type Options = {
@@ -171,7 +170,7 @@ export type Options = {
    * Useful for edge cases like adding `.openapi()` metadata or wrapping
    * schemas with extension helpers (openapi -> zod -> openapi round-trips).
    */
-  wrapOutput?: (arg: { output: string; schema: SchemaNode }) => string | undefined
+  wrapOutput?: (arg: { output: string; schema: ast.SchemaNode }) => string | undefined
   /**
    * How to style your params, by default no casing is applied
    * - 'camelcase' uses camelCase for pathParams, queryParams and headerParams property names
@@ -218,7 +217,7 @@ export type Options = {
    * A single AST visitor applied to each SchemaNode/OperationNode before printing.
    * When a visitor method returns `null` or `undefined`, the preset transformer's result is used instead.
    */
-  transformer?: Visitor
+  transformer?: ast.Visitor
 }
 
 type ResolvedOptions = {

package/src/utils.ts

@@ -1,6 +1,5 @@
 import { stringify, toRegExpString } from '@internals/utils'
-import { createProperty, createSchema, extractRefName } from '@kubb/ast'
-import type { OperationNode, ParameterNode, SchemaNode } from '@kubb/ast/types'
+import { ast } from '@kubb/core'
 import type { PluginZod, ResolverZod } from './types.ts'
 
 /**
@@ -17,7 +16,7 @@ export function shouldCoerce(coercion: PluginZod['resolvedOptions']['coercion']
  * Collects all resolved schema names for an operation's parameters and responses
  * into a single lookup object, useful for building imports and type references.
  */
-export function buildSchemaNames(node: OperationNode, { params, resolver }: { params: Array<ParameterNode>; resolver: ResolverZod }) {
+export function buildSchemaNames(node: ast.OperationNode, { params, resolver }: { params: Array<ast.ParameterNode>; resolver: ResolverZod }) {
   const pathParam = params.find((p) => p.in === 'path')
   const queryParam = params.find((p) => p.in === 'query')
   const headerParam = params.find((p) => p.in === 'header')
@@ -196,14 +195,14 @@ export function applyMiniModifiers({ value, nullable, optional, nullish, default
  * A `visited` set prevents infinite recursion on circular schema graphs.
  */
 export function containsSelfRef(
-  node: SchemaNode,
-  { schemaName, resolver, visited = new Set() }: { schemaName: string; resolver: ResolverZod | undefined; visited?: Set<SchemaNode> },
+  node: ast.SchemaNode,
+  { schemaName, resolver, visited = new Set() }: { schemaName: string; resolver: ResolverZod | undefined; visited?: Set<ast.SchemaNode> },
 ): boolean {
   if (visited.has(node)) return false
   visited.add(node)
 
   if (node.type === 'ref' && node.ref) {
-    const rawName = extractRefName(node.ref) ?? node.name
+    const rawName = ast.extractRefName(node.ref) ?? node.name
     const resolved = rawName ? (resolver?.default(rawName, 'function') ?? rawName) : node.name
     return resolved === schemaName
   }
@@ -224,7 +223,7 @@ export function containsSelfRef(
 }
 
 type BuildGroupedParamsSchemaOptions = {
-  params: Array<ParameterNode>
+  params: Array<ast.ParameterNode>
   optional?: boolean
 }
 
@@ -232,13 +231,13 @@ type BuildGroupedParamsSchemaOptions = {
  * Builds an `object` schema node grouping the given parameter nodes.
  * The `primitive: 'object'` marker ensures the Zod printer emits `z.object(…)` rather than a record.
  */
-export function buildGroupedParamsSchema({ params, optional }: BuildGroupedParamsSchemaOptions): SchemaNode {
-  return createSchema({
+export function buildGroupedParamsSchema({ params, optional }: BuildGroupedParamsSchemaOptions): ast.SchemaNode {
+  return ast.createSchema({
     type: 'object',
     optional,
     primitive: 'object',
     properties: params.map((param) =>
-      createProperty({
+      ast.createProperty({
         name: param.name,
         required: param.required,
         schema: param.schema,

package/src/presets.ts

@@ -1,30 +0,0 @@
-import { definePresets } from '@kubb/core'
-import { zodGenerator } from './generators/zodGenerator.tsx'
-import { zodGeneratorLegacy } from './generators/zodGeneratorLegacy.tsx'
-import { printerZod } from './printers/printerZod.ts'
-import { resolverZod } from './resolvers/resolverZod.ts'
-import { resolverZodLegacy } from './resolvers/resolverZodLegacy.ts'
-import type { ResolverZod } from './types.ts'
-
-/**
- * Built-in preset registry for `@kubb/plugin-zod`.
- *
- * - `default` — uses `resolverZod` and `zodGenerator` (current naming conventions).
- * - `kubbV4` — uses `resolverZodLegacy` and `zodGeneratorLegacy` (Kubb v4 naming conventions).
- *
- * Note: `printerZodMini` is selected at runtime by the generator when `mini: true` is set.
- */
-export const presets = definePresets<ResolverZod>({
-  default: {
-    name: 'default',
-    resolver: resolverZod,
-    generators: [zodGenerator],
-    printer: printerZod,
-  },
-  kubbV4: {
-    name: 'kubbV4',
-    resolver: resolverZodLegacy,
-    generators: [zodGeneratorLegacy],
-    printer: printerZod,
-  },
-})