@kubb/plugin-zod 5.0.0-beta.56 → 5.0.0-beta.64

package/src/resolvers/resolverZod.ts

@@ -1,71 +0,0 @@
-import { camelCase, ensureValidVarName, pascalCase, toFilePath } from '@internals/utils'
-import { defineResolver } from '@kubb/core'
-import type { PluginZod } from '../types.ts'
-
-/**
- * Default resolver used by `@kubb/plugin-zod`. Decides the names and file
- * paths for every generated Zod schema. Schemas use camelCase with a
- * `Schema` suffix (`listPetsSchema`); their inferred types use PascalCase
- * with a `SchemaType` suffix (`PetSchemaType`), so the value and the type
- * never share an identifier even when the schema name is all-uppercase.
- *
- * @example Resolve schema and type names
- * ```ts
- * import { resolverZod } from '@kubb/plugin-zod'
- *
- * resolverZod.default('list pets', 'function') // 'listPetsSchema'
- * resolverZod.resolveSchemaTypeName('pet')     // 'PetSchemaType'
- * ```
- */
-export const resolverZod = defineResolver<PluginZod>(() => {
-  return {
-    name: 'default',
-    pluginName: 'plugin-zod',
-    default(name, type) {
-      if (type === 'file') return toFilePath(name, (part) => camelCase(part, { suffix: 'schema' }))
-      return ensureValidVarName(camelCase(name, { suffix: type ? 'schema' : undefined }))
-    },
-    resolveSchemaName(name) {
-      return ensureValidVarName(camelCase(name, { suffix: 'schema' }))
-    },
-    resolveSchemaTypeName(name) {
-      return ensureValidVarName(pascalCase(name, { suffix: 'schema type' }))
-    },
-    resolveInputSchemaName(name) {
-      return this.resolveSchemaName(`${name} input`)
-    },
-    resolveInputSchemaTypeName(name) {
-      return this.resolveSchemaTypeName(`${name} input`)
-    },
-    resolveTypeName(name) {
-      return ensureValidVarName(pascalCase(name, { suffix: 'type' }))
-    },
-    resolvePathName(name, type) {
-      return this.default(name, type)
-    },
-    resolveParamName(node, param) {
-      return this.resolveSchemaName(`${node.operationId} ${param.in} ${param.name}`)
-    },
-    resolveResponseStatusName(node, statusCode) {
-      return this.resolveSchemaName(`${node.operationId} Status ${statusCode}`)
-    },
-    resolveDataName(node) {
-      return this.resolveSchemaName(`${node.operationId} Data`)
-    },
-    resolveResponsesName(node) {
-      return this.resolveSchemaName(`${node.operationId} Responses`)
-    },
-    resolveResponseName(node) {
-      return this.resolveSchemaName(`${node.operationId} Response`)
-    },
-    resolvePathParamsName(node, param) {
-      return this.resolveParamName(node, param)
-    },
-    resolveQueryParamsName(node, param) {
-      return this.resolveParamName(node, param)
-    },
-    resolveHeaderParamsName(node, param) {
-      return this.resolveParamName(node, param)
-    },
-  }
-})

package/src/types.ts

@@ -1,219 +0,0 @@
-import type { ast, Exclude, Generator, Group, Include, Output, OutputOptions, Override, PluginFactoryOptions, Resolver } from '@kubb/core'
-import type { PrinterZodNodes } from './printers/printerZod.ts'
-import type { PrinterZodMiniNodes } from './printers/printerZodMini.ts'
-
-/**
- * Resolver for Zod that provides naming methods for schema types.
- */
-export type ResolverZod = Resolver &
-  ast.OperationParamsResolver & {
-    /**
-     * Resolves a camelCase schema function name with a `Schema` suffix.
-     */
-    resolveSchemaName(this: ResolverZod, name: string): string
-    /**
-     * Resolves the schema type name (inferred type from schema).
-     *
-     * @example Schema type names
-     * `resolver.resolveSchemaTypeName('pet') // → 'PetSchemaType'`
-     */
-    resolveSchemaTypeName(this: ResolverZod, name: string): string
-    /**
-     * Resolves the schema function name for the request (input) direction of a
-     * date-bearing component, where `Date` is encoded back to a wire `string`.
-     *
-     * @example Input schema names
-     * `resolver.resolveInputSchemaName('order') // → 'orderInputSchema'`
-     */
-    resolveInputSchemaName(this: ResolverZod, name: string): string
-    /**
-     * Resolves the inferred type name for the request (input) direction variant.
-     *
-     * @example Input schema type names
-     * `resolver.resolveInputSchemaTypeName('order') // → 'OrderInputSchemaType'`
-     */
-    resolveInputSchemaTypeName(this: ResolverZod, name: string): string
-    /**
-     * Resolves the generated type name from the schema.
-     *
-     * @example Type names
-     * `resolver.resolveTypeName('petSchema') // → 'PetSchemaType'`
-     */
-    resolveTypeName(this: ResolverZod, name: string): string
-    /**
-     * Resolves the output file name for a schema.
-     */
-    resolvePathName(this: ResolverZod, name: string, type?: 'file' | 'function' | 'type' | 'const'): string
-    /**
-     * Resolves the name for an operation response by status code.
-     *
-     * @example Response status names
-     * `resolver.resolveResponseStatusName(node, 200) // → 'listPetsStatus200Schema'`
-     */
-    resolveResponseStatusName(this: ResolverZod, node: ast.OperationNode, statusCode: ast.StatusCode): string
-    /**
-     * Resolves the name for the collection of all operation responses.
-     *
-     * @example Responses collection names
-     * `resolver.resolveResponsesName(node) // → 'listPetsResponsesSchema'`
-     */
-    resolveResponsesName(this: ResolverZod, node: ast.OperationNode): string
-    /**
-     * Resolves the name for the union of all operation responses.
-     *
-     * @example Response union names
-     * `resolver.resolveResponseName(node) // → 'listPetsResponseSchema'`
-     */
-    resolveResponseName(this: ResolverZod, node: ast.OperationNode): string
-    /**
-     * Resolves the name for an operation's grouped path parameters type.
-     *
-     * @example Path parameters names
-     * `resolver.resolvePathParamsName(node, param) // → 'deletePetPathPetIdSchema'`
-     */
-    resolvePathParamsName(this: ResolverZod, node: ast.OperationNode, param: ast.ParameterNode): string
-    /**
-     * Resolves the name for an operation's grouped query parameters type.
-     *
-     * @example Query parameters names
-     * `resolver.resolveQueryParamsName(node, param) // → 'findPetsByStatusQueryStatusSchema'`
-     */
-    resolveQueryParamsName(this: ResolverZod, node: ast.OperationNode, param: ast.ParameterNode): string
-    /**
-     * Resolves the name for an operation's grouped header parameters type.
-     *
-     * @example Header parameters names
-     * `resolver.resolveHeaderParamsName(node, param) // → 'deletePetHeaderApiKeySchema'`
-     */
-    resolveHeaderParamsName(this: ResolverZod, node: ast.OperationNode, param: ast.ParameterNode): string
-  }
-
-/**
- * Where the generated Zod schemas are written and how they are exported, plus the optional
- * `group` strategy. The `group` option organizes `output.mode: 'directory'` output into per-tag or per-path subdirectories.
- *
- * @default { path: 'zod', barrel: { type: 'named' } }
- */
-export type Options = OutputOptions & {
-  /**
-   * Skip operations matching at least one entry in the list.
-   */
-  exclude?: Array<Exclude>
-  /**
-   * Restrict generation to operations matching at least one entry in the list.
-   */
-  include?: Array<Include>
-  /**
-   * Apply a different options object to operations matching a pattern.
-   */
-  override?: Array<Override<ResolvedOptions>>
-  /**
-   * Module specifier used in the `import { z } from '...'` statement.
-   * Use `'zod/mini'` for the tree-shakeable bundle.
-   *
-   * @default mini ? 'zod/mini' : 'zod'
-   */
-  importPath?: 'zod' | 'zod/mini' | (string & {})
-  /**
-   * Tie each Zod schema to its TypeScript type from `@kubb/plugin-ts`. Requires
-   * `@kubb/plugin-ts` in the plugins list. TypeScript fails compilation when the
-   * schema drifts from the type.
-   */
-  typed?: boolean
-  /**
-   * Export a `z.infer<typeof schema>` type alias next to every generated schema.
-   * Lets the Zod schema act as the single source of truth.
-   */
-  inferred?: boolean
-  /**
-   * Wrap schemas in `z.coerce` so input is coerced before validation. Useful for
-   * form data and query params where everything arrives as a string.
-   * - `true` coerces strings, numbers, and dates.
-   * - Object form picks per-primitive coercion.
-   *
-   * @default false
-   * @see https://zod.dev/?id=coercion-for-primitives
-   */
-  coercion?: boolean | { dates?: boolean; strings?: boolean; numbers?: boolean }
-  /**
-   * Emit an `operations.ts` file with request body, query/path params, and per-status
-   * response schemas grouped by operation.
-   */
-  operations?: boolean
-  /**
-   * Validator for `format: uuid` properties.
-   * - `'uuid'` — `z.uuid()`. Standard RFC 4122.
-   * - `'guid'` — `z.guid()`. Accepts Microsoft-style GUIDs.
-   *
-   * @default 'uuid'
-   */
-  guidType?: 'uuid' | 'guid'
-  /**
-   * Switch to Zod Mini's functional API for better tree-shaking. Also defaults
-   * `importPath` to `'zod/mini'`.
-   *
-   * @default false
-   * @beta
-   */
-  mini?: boolean
-  /**
-   * Wrap the generated Zod schema string with extra calls. Receives the raw output
-   * and the originating `SchemaNode`. Useful for round-tripping OpenAPI metadata
-   * back into Zod (e.g. `.openapi(...)`).
-   */
-  wrapOutput?: (arg: { output: string; schema: ast.SchemaNode }) => string | undefined
-  /**
-   * Rename properties inside path/query/header schemas. Body schemas are unaffected.
-   *
-   * @note Must match the value of `paramsCasing` on `@kubb/plugin-ts`.
-   */
-  paramsCasing?: 'camelcase'
-  /**
-   * Custom generators that run alongside the built-in Zod generators.
-   */
-  generators?: Array<Generator<PluginZod>>
-  /**
-   * Override how schema and operation names are built. Methods you omit fall back
-   * to the default `resolverZod`.
-   */
-  resolver?: Partial<ResolverZod> & ThisType<ResolverZod>
-  /**
-   * Replace the Zod handler for a specific schema type (`'integer'`, `'date'`, ...).
-   * When `mini: true`, overrides target the Zod Mini printer instead.
-   */
-  printer?: {
-    nodes?: PrinterZodNodes | PrinterZodMiniNodes
-  }
-  /**
-   * AST visitor applied to each schema or operation node before printing.
-   */
-  transformer?: ast.Visitor
-}
-
-type ResolvedOptions = {
-  output: Output
-  exclude: Array<Exclude>
-  include: Array<Include> | undefined
-  override: Array<Override<ResolvedOptions>>
-  group: Group | null
-  typed: NonNullable<Options['typed']>
-  inferred: NonNullable<Options['inferred']>
-  importPath: NonNullable<Options['importPath']>
-  coercion: NonNullable<Options['coercion']>
-  operations: NonNullable<Options['operations']>
-  guidType: NonNullable<Options['guidType']>
-  mini: NonNullable<Options['mini']>
-  wrapOutput: Options['wrapOutput']
-  paramsCasing: Options['paramsCasing']
-  printer: Options['printer']
-}
-
-export type PluginZod = PluginFactoryOptions<'plugin-zod', Options, ResolvedOptions, ResolverZod>
-
-declare global {
-  namespace Kubb {
-    interface PluginRegistry {
-      'plugin-zod': PluginZod
-    }
-  }
-}

package/src/utils.ts

@@ -1,299 +0,0 @@
-import { extractRefName, stringify, toRegExpString } from '@kubb/ast/utils'
-import { ast } from '@kubb/core'
-import type { PluginZod, ResolverZod } from './types.ts'
-
-/**
- * Returns `true` when the given coercion option enables coercion for the specified type.
- */
-export function shouldCoerce(coercion: PluginZod['resolvedOptions']['coercion'] | undefined, type: 'dates' | 'strings' | 'numbers'): boolean {
-  if (coercion === undefined || coercion === false) return false
-  if (coercion === true) return true
-
-  return !!coercion[type]
-}
-
-/**
- * A codec for a schema node whose runtime type differs from its JSON wire type:
- * the output (response) schema decodes wire → runtime, and the input (request)
- * variant encodes runtime → wire.
- *
- * To support another codec type, append a `Codec` to `codecs` and route that
- * type's printer node handler through `getCodec`.
- */
-export type Codec = {
-  /**
-   * Whether this node is encoded/decoded by this codec.
-   */
-  matches(node: ast.SchemaNode): boolean
-  /**
-   * Output direction (response): decode the wire value into the runtime type.
-   */
-  decode(node: ast.SchemaNode): string
-  /**
-   * Input direction (request): encode the runtime value back to the wire value.
-   */
-  encode(node: ast.SchemaNode): string
-}
-
-/**
- * `dateType: 'date'` fields are typed as `Date` but travel as ISO `string`s.
- * Output decodes `string → Date`; input encodes `Date → string`, preserving the
- * `date` (`YYYY-MM-DD`) vs `date-time` precision carried on `node.format`.
- */
-const dateCodec: Codec = {
-  matches(node) {
-    return node.type === 'date' && node.representation === 'date'
-  },
-  decode(node) {
-    return node.format === 'date' ? 'z.iso.date().transform((value) => new Date(value))' : 'z.iso.datetime().transform((value) => new Date(value))'
-  },
-  encode(node) {
-    return node.format === 'date' ? 'z.date().transform((value) => value.toISOString().slice(0, 10))' : 'z.date().transform((value) => value.toISOString())'
-  },
-}
-
-/**
- * Registered codecs, checked in order.
- */
-const codecs: Array<Codec> = [dateCodec]
-
-/**
- * Returns the codec for this node, or `undefined` when the node needs no
- * encode/decode (its wire and runtime types match).
- */
-export function getCodec(node: ast.SchemaNode | undefined): Codec | undefined {
-  if (!node) return undefined
-  return codecs.find((codec) => codec.matches(node))
-}
-
-/**
- * Returns `true` when the node itself is encoded/decoded by a codec.
- */
-export function hasCodec(node: ast.SchemaNode | undefined): boolean {
-  return getCodec(node) !== undefined
-}
-
-/**
- * Returns `true` when the schema transitively contains a codec node —
- * a value whose runtime type differs from its wire type (see {@link hasCodec}),
- * so it must be decoded (response) or encoded (request) at the validation boundary.
- * `$ref`s are followed via their resolved schema; a `seen` set guards cycles.
- */
-export function containsCodec(node: ast.SchemaNode | undefined, seen: Set<string> = new Set()): boolean {
-  if (!node) return false
-
-  if (hasCodec(node)) return true
-
-  if (node.type === 'ref') {
-    if (!node.ref) return false
-    const refName = extractRefName(node.ref)
-    if (refName) {
-      if (seen.has(refName)) return false
-      seen.add(refName)
-    }
-    const resolved = ast.syncSchemaRef(node)
-    if (resolved.type === 'ref') return false
-    return containsCodec(resolved, seen)
-  }
-
-  const children: Array<ast.SchemaNode | undefined> = []
-  if ('properties' in node && node.properties) children.push(...node.properties.map((prop) => prop.schema))
-  if ('items' in node && node.items) children.push(...node.items)
-  if ('members' in node && node.members) children.push(...node.members)
-  if ('additionalProperties' in node && node.additionalProperties && node.additionalProperties !== true) children.push(node.additionalProperties)
-
-  return children.some((child) => containsCodec(child, seen))
-}
-
-/**
- * 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: 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')
-
-  const responses: Record<number | string, string> = {}
-  const errors: Record<number | string, string> = {}
-
-  for (const res of node.responses) {
-    const name = resolver.resolveResponseStatusName(node, res.statusCode)
-    const statusNum = Number(res.statusCode)
-
-    if (!Number.isNaN(statusNum)) {
-      responses[statusNum] = name
-      if (statusNum >= 400) {
-        errors[statusNum] = name
-      }
-    }
-  }
-
-  responses['default'] = resolver.resolveResponseName(node)
-
-  return {
-    request: node.requestBody?.content?.[0]?.schema ? resolver.resolveDataName(node) : null,
-    parameters: {
-      path: pathParam ? resolver.resolvePathParamsName(node, pathParam) : null,
-      query: queryParam ? resolver.resolveQueryParamsName(node, queryParam) : null,
-      header: headerParam ? resolver.resolveHeaderParamsName(node, headerParam) : null,
-    },
-    responses,
-    errors,
-  }
-}
-
-/**
- * Format a default value as a code-level literal.
- * Objects become `{}`, primitives become their string representation, strings are quoted.
- */
-export function formatDefault(value: unknown): string {
-  if (typeof value === 'string') return stringify(value)
-  if (typeof value === 'object' && value !== null) return '{}'
-
-  return String(value ?? '')
-}
-
-/**
- * Format a primitive enum/literal value.
- * Strings are quoted; numbers and booleans are emitted raw.
- */
-export function formatLiteral(v: string | number | boolean): string {
-  if (typeof v === 'string') return stringify(v)
-
-  return String(v)
-}
-
-/**
- * Numeric constraint limits for Zod schemas (min, max, and exclusive bounds).
- */
-export type NumericConstraints = {
-  min?: number
-  max?: number
-  exclusiveMinimum?: number
-  exclusiveMaximum?: number
-  multipleOf?: number
-}
-
-/**
- * Length constraint limits for string and array schemas (min, max, and regex pattern).
- */
-export type LengthConstraints = {
-  min?: number
-  max?: number
-  pattern?: string
-}
-
-/**
- * Modifier options for applying chainable methods to Zod schema values.
- */
-export type ModifierOptions = {
-  value: string
-  nullable?: boolean
-  optional?: boolean
-  nullish?: boolean
-  defaultValue?: unknown
-  description?: string
-}
-
-/**
- * Build `.min()` / `.max()` / `.gt()` / `.lt()` constraint chains for numbers
- * using the standard chainable Zod v4 API.
- */
-export function numberConstraints({ min, max, exclusiveMinimum, exclusiveMaximum, multipleOf }: NumericConstraints): string {
-  return [
-    min !== undefined ? `.min(${min})` : '',
-    max !== undefined ? `.max(${max})` : '',
-    exclusiveMinimum !== undefined ? `.gt(${exclusiveMinimum})` : '',
-    exclusiveMaximum !== undefined ? `.lt(${exclusiveMaximum})` : '',
-    multipleOf !== undefined ? `.multipleOf(${multipleOf})` : '',
-  ].join('')
-}
-
-/**
- * Build `.min()` / `.max()` / `.regex()` chains for strings/arrays
- * using the standard chainable Zod v4 API.
- */
-export function lengthConstraints({ min, max, pattern }: LengthConstraints): string {
-  return [
-    min !== undefined ? `.min(${min})` : '',
-    max !== undefined ? `.max(${max})` : '',
-    pattern !== undefined ? `.regex(${toRegExpString(pattern, null)})` : '',
-  ].join('')
-}
-
-/**
- * Build `.check(z.minimum(), z.maximum())` for `zod/mini` numeric constraints.
- */
-export function numberChecksMini({ min, max, exclusiveMinimum, exclusiveMaximum, multipleOf }: NumericConstraints): string {
-  const checks: Array<string> = []
-  if (min !== undefined) checks.push(`z.minimum(${min})`)
-  if (max !== undefined) checks.push(`z.maximum(${max})`)
-  if (exclusiveMinimum !== undefined) checks.push(`z.minimum(${exclusiveMinimum}, { exclusive: true })`)
-  if (exclusiveMaximum !== undefined) checks.push(`z.maximum(${exclusiveMaximum}, { exclusive: true })`)
-  if (multipleOf !== undefined) checks.push(`z.multipleOf(${multipleOf})`)
-  return checks.length ? `.check(${checks.join(', ')})` : ''
-}
-
-/**
- * Build `.check(z.minLength(), z.maxLength(), z.regex())` for `zod/mini` length constraints.
- */
-export function lengthChecksMini({ min, max, pattern }: LengthConstraints): string {
-  const checks: Array<string> = []
-  if (min !== undefined) checks.push(`z.minLength(${min})`)
-  if (max !== undefined) checks.push(`z.maxLength(${max})`)
-  if (pattern !== undefined) checks.push(`z.regex(${toRegExpString(pattern, null)})`)
-  return checks.length ? `.check(${checks.join(', ')})` : ''
-}
-
-/**
- * Apply nullable / optional / nullish modifiers and an optional `.describe()` call
- * to a schema value string using the chainable Zod v4 API.
- */
-export function applyModifiers({ value, nullable, optional, nullish, defaultValue, description }: ModifierOptions): string {
-  const withModifier = (() => {
-    if (nullish || (nullable && optional)) return `${value}.nullish()`
-    if (optional) return `${value}.optional()`
-    if (nullable) return `${value}.nullable()`
-    return value
-  })()
-  const withDefault = defaultValue !== undefined ? `${withModifier}.default(${formatDefault(defaultValue)})` : withModifier
-  return description ? `${withDefault}.describe(${stringify(description)})` : withDefault
-}
-
-/**
- * Apply nullable / optional / nullish modifiers using the functional `zod/mini` API
- * (`z.nullable()`, `z.optional()`, `z.nullish()`).
- */
-export function applyMiniModifiers({ value, nullable, optional, nullish, defaultValue }: Omit<ModifierOptions, 'description'>): string {
-  const withModifier = (() => {
-    if (nullish) return `z.nullish(${value})`
-    const withNullable = nullable ? `z.nullable(${value})` : value
-    return optional ? `z.optional(${withNullable})` : withNullable
-  })()
-  return defaultValue !== undefined ? `z._default(${withModifier}, ${formatDefault(defaultValue)})` : withModifier
-}
-
-type BuildGroupedParamsSchemaOptions = {
-  params: Array<ast.ParameterNode>
-  optional?: boolean
-}
-
-/**
- * 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): ast.SchemaNode {
-  return ast.createSchema({
-    type: 'object',
-    optional,
-    primitive: 'object',
-    properties: params.map((param) =>
-      ast.createProperty({
-        name: param.name,
-        required: param.required,
-        schema: param.schema,
-      }),
-    ),
-  })
-}