@kubb/plugin-zod 5.0.0-alpha.9 → 5.0.0-beta.100

package/src/plugin.ts

@@ -1,183 +0,0 @@
-import path from 'node:path'
-import { camelCase, pascalCase } from '@internals/utils'
-import { createPlugin, type Group, getBarrelFiles, getMode, satisfiesDependency } from '@kubb/core'
-import { OperationGenerator, pluginOasName, SchemaGenerator } from '@kubb/plugin-oas'
-import { pluginTsName } from '@kubb/plugin-ts'
-import { operationsGenerator } from './generators'
-import { zodGenerator } from './generators/zodGenerator.tsx'
-import { source as toZodSource } from './templates/ToZod.source.ts'
-import type { PluginZod } from './types.ts'
-
-export const pluginZodName = 'plugin-zod' satisfies PluginZod['name']
-
-export const pluginZod = createPlugin<PluginZod>((options) => {
-  const {
-    output = { path: 'zod', barrelType: 'named' },
-    group,
-    exclude = [],
-    include,
-    override = [],
-    transformers = {},
-    dateType = 'string',
-    unknownType = 'any',
-    emptySchemaType = unknownType,
-    integerType = 'number',
-    typed = false,
-    mapper = {},
-    operations = false,
-    mini = false,
-    version = mini ? '4' : satisfiesDependency('zod', '>=4') ? '4' : '3',
-    guidType = 'uuid',
-    importPath = mini ? 'zod/mini' : version === '4' ? 'zod/v4' : 'zod',
-    coercion = false,
-    inferred = false,
-    generators = [zodGenerator, operations ? operationsGenerator : undefined].filter(Boolean),
-    wrapOutput = undefined,
-    contentType,
-  } = options
-
-  // @deprecated Will be removed in v5 when collisionDetection defaults to true
-  const usedEnumNames = {}
-
-  return {
-    name: pluginZodName,
-    options: {
-      output,
-      transformers,
-      include,
-      exclude,
-      override,
-      typed,
-      dateType,
-      unknownType,
-      emptySchemaType,
-      integerType,
-      mapper,
-      importPath,
-      coercion,
-      operations,
-      inferred,
-      group,
-      wrapOutput,
-      version,
-      guidType,
-      mini,
-      usedEnumNames,
-    },
-    pre: [pluginOasName, typed ? pluginTsName : undefined].filter(Boolean),
-    resolvePath(baseName, pathMode, options) {
-      const root = path.resolve(this.config.root, this.config.output.path)
-      const mode = pathMode ?? getMode(path.resolve(root, output.path))
-
-      if (mode === 'single') {
-        /**
-         * when output is a file then we will always append to the same file(output file), see fileManager.addOrAppend
-         * Other plugins then need to call addOrAppend instead of just add from the fileManager class
-         */
-        return path.resolve(root, output.path)
-      }
-
-      if (group && (options?.group?.path || options?.group?.tag)) {
-        const groupName: Group['name'] = group?.name
-          ? group.name
-          : (ctx) => {
-              if (group?.type === 'path') {
-                return `${ctx.group.split('/')[1]}`
-              }
-              return `${camelCase(ctx.group)}Controller`
-            }
-
-        return path.resolve(
-          root,
-          output.path,
-          groupName({
-            group: group.type === 'path' ? options.group.path! : options.group.tag!,
-          }),
-          baseName,
-        )
-      }
-
-      return path.resolve(root, output.path, baseName)
-    },
-    resolveName(name, type) {
-      let resolvedName = camelCase(name, {
-        suffix: type ? 'schema' : undefined,
-        isFile: type === 'file',
-      })
-
-      if (type === 'type') {
-        resolvedName = pascalCase(resolvedName)
-      }
-
-      if (type) {
-        return transformers?.name?.(resolvedName, type) || resolvedName
-      }
-
-      return resolvedName
-    },
-    async install() {
-      const root = path.resolve(this.config.root, this.config.output.path)
-      const mode = getMode(path.resolve(root, output.path))
-      const oas = await this.getOas()
-
-      if (this.plugin.options.typed && this.plugin.options.version === '3') {
-        // pre add bundled
-        await this.addFile({
-          baseName: 'ToZod.ts',
-          path: path.resolve(root, '.kubb/ToZod.ts'),
-          sources: [
-            {
-              name: 'ToZod',
-              value: toZodSource,
-            },
-          ],
-          imports: [],
-          exports: [],
-        })
-      }
-
-      const schemaGenerator = new SchemaGenerator(this.plugin.options, {
-        fabric: this.fabric,
-        oas,
-        driver: this.driver,
-        events: this.events,
-        plugin: this.plugin,
-        contentType,
-        include: undefined,
-        override,
-        mode,
-        output: output.path,
-      })
-
-      const schemaFiles = await schemaGenerator.build(...generators)
-      await this.upsertFile(...schemaFiles)
-
-      const operationGenerator = new OperationGenerator(this.plugin.options, {
-        fabric: this.fabric,
-        oas,
-        driver: this.driver,
-        events: this.events,
-        plugin: this.plugin,
-        contentType,
-        exclude,
-        include,
-        override,
-        mode,
-      })
-
-      const operationFiles = await operationGenerator.build(...generators)
-      await this.upsertFile(...operationFiles)
-
-      const barrelFiles = await getBarrelFiles(this.fabric.files, {
-        type: output.barrelType ?? 'named',
-        root,
-        output,
-        meta: {
-          pluginName: this.plugin.name,
-        },
-      })
-
-      await this.upsertFile(...barrelFiles)
-    },
-  }
-})

package/src/templates/ToZod.source.ts

@@ -1,4 +0,0 @@
-// @ts-expect-error - import attributes are handled at build time by importAttributeTextPlugin
-import content from '../../templates/ToZod.ts' with { type: 'text' }
-
-export const source = content as string

package/src/types.ts

@@ -1,172 +0,0 @@
-import type { Group, Output, PluginFactoryOptions, ResolveNameParams } from '@kubb/core'
-import type { contentType, Oas, SchemaObject } from '@kubb/oas'
-import type { Exclude, Include, Override, ResolvePathOptions, Schema } from '@kubb/plugin-oas'
-import type { Generator } from '@kubb/plugin-oas/generators'
-
-export type Options = {
-  /**
-   * @default 'zod'
-   */
-  output?: Output<Oas>
-  /**
-   * Define which contentType should be used.
-   * By default, the first JSON valid mediaType is used
-   */
-  contentType?: contentType
-  /**
-   * Group the Zod schemas based on the provided name.
-   */
-  group?: Group
-  /**
-   * Array containing exclude parameters to exclude/skip tags/operations/methods/paths.
-   */
-  exclude?: Array<Exclude>
-  /**
-   * Array containing include parameters to include tags/operations/methods/paths.
-   */
-  include?: Array<Include>
-  /**
-   * Array containing override parameters to override `options` based on tags/operations/methods/paths.
-   */
-  override?: Array<Override<ResolvedOptions>>
-  /**
-   * Path to Zod
-   * It used as `import { z } from '${importPath}'`.
-   * Accepts relative and absolute paths.
-   * Path is used as-is; relative paths are based on the generated file location.
-   * @default 'zod'
-   */
-  importPath?: string
-
-  /**
-   * Choose to use date or datetime as JavaScript Date instead of string.
-   * - false falls back to a simple z.string() format.
-   * - 'string' uses z.string().datetime() for datetime validation.
-   * - 'stringOffset' uses z.string().datetime({ offset: true }) for datetime with timezone offset validation.
-   * - 'stringLocal' uses z.string().datetime({ local: true }) for local datetime validation.
-   * - 'date' uses z.date() for JavaScript Date objects.
-   * @default 'string'
-   * @note 'stringOffset' will become the default in Kubb v3.
-   */
-  dateType?: false | 'string' | 'stringOffset' | 'stringLocal' | 'date'
-  /**
-   * Choose to use `number` or `bigint` for integer fields with `int64` format.
-   * - 'number' uses the JavaScript `number` type (matches JSON.parse() runtime behavior).
-   * - 'bigint' uses the JavaScript `bigint` type (accurate for values exceeding Number.MAX_SAFE_INTEGER).
-   * @note in v5 of Kubb 'bigint' will become the default to better align with OpenAPI's int64 specification.
-   * @default 'number'
-   */
-  integerType?: 'number' | 'bigint'
-  /**
-   * Which type to use when the Swagger/OpenAPI file is not providing more information.
-   * - 'any' allows any value.
-   * - 'unknown' requires type narrowing before use.
-   * - 'void' represents no value.
-   * @default 'any'
-   */
-  unknownType?: 'any' | 'unknown' | 'void'
-  /**
-   * Which type to use for empty schema values.
-   * - 'any' allows any value.
-   * - 'unknown' requires type narrowing before use.
-   * - 'void' represents no value.
-   * @default `unknownType`
-   */
-  emptySchemaType?: 'any' | 'unknown' | 'void'
-  /**
-   * Use TypeScript(`@kubb/plugin-ts`) to add type annotation.
-   */
-  typed?: boolean
-  /**
-   * Return Zod generated schema as type with z.infer<TYPE>
-   */
-  inferred?: boolean
-  /**
-   * Use of z.coerce.string() instead of z.string()
-   * can also be an object to enable coercion for dates, strings, and numbers
-   */
-  coercion?:
-    | boolean
-    | {
-        dates?: boolean
-        strings?: boolean
-        numbers?: boolean
-      }
-  operations?: boolean
-  mapper?: Record<string, string>
-  transformers?: {
-    /**
-     * Customize the names based on the type that is provided by the plugin.
-     */
-    name?: (name: ResolveNameParams['name'], type?: ResolveNameParams['type']) => string
-    /**
-     * Receive schema and baseName(propertyName) and return FakerMeta array
-     * TODO TODO add docs
-     * @beta
-     */
-    schema?: (
-      props: {
-        schema: SchemaObject | null
-        name: string | null
-        parentName: string | null
-      },
-      defaultSchemas: Schema[],
-    ) => Schema[] | undefined
-  }
-  /**
-   * Which version of Zod should be used.
-   * - '3' uses Zod v3.x syntax and features.
-   * - '4' uses Zod v4.x syntax and features.
-   * @default '3'
-   */
-  version?: '3' | '4'
-  /**
-   * Which Zod GUID validator to use for OpenAPI `format: uuid`.
-   * - 'uuid' uses UUID validation.
-   * - 'guid' uses GUID validation (Zod v4 only).
-   * @default 'uuid'
-   */
-  guidType?: 'uuid' | 'guid'
-  /**
-   * Use Zod Mini's functional API for better tree-shaking support.
-   * When enabled, generates functional syntax (e.g., `z.optional(z.string())`) instead of chainable methods (e.g., `z.string().optional()`).
-   * Requires Zod v4 or later. When `mini: true`, `version` is set to '4' and `importPath` will default to 'zod/mini'.
-   * @default false
-   */
-  mini?: boolean
-  /**
-   * Callback function to wrap the output of the generated zod schema
-   *
-   * This is useful for edge case scenarios where you might leverage something like `z.object({ ... }).openapi({ example: { some: "complex-example" }})`
-   * or `extendApi(z.object({ ... }), { example: { some: "complex-example", ...otherOpenApiProperties }})`
-   * while going from openapi -> zod -> openapi
-   */
-  wrapOutput?: (arg: { output: string; schema: SchemaObject }) => string | undefined
-  /**
-   * Define some generators next to the zod generators
-   */
-  generators?: Array<Generator<PluginZod>>
-}
-
-type ResolvedOptions = {
-  output: Output<Oas>
-  group: Options['group']
-  override: NonNullable<Options['override']>
-  transformers: NonNullable<Options['transformers']>
-  dateType: NonNullable<Options['dateType']>
-  integerType: NonNullable<Options['integerType']>
-  unknownType: NonNullable<Options['unknownType']>
-  emptySchemaType: NonNullable<Options['emptySchemaType']>
-  typed: NonNullable<Options['typed']>
-  inferred: NonNullable<Options['inferred']>
-  mapper: NonNullable<Options['mapper']>
-  importPath: NonNullable<Options['importPath']>
-  coercion: NonNullable<Options['coercion']>
-  operations: NonNullable<Options['operations']>
-  wrapOutput: Options['wrapOutput']
-  version: NonNullable<Options['version']>
-  guidType: NonNullable<Options['guidType']>
-  mini: NonNullable<Options['mini']>
-}
-
-export type PluginZod = PluginFactoryOptions<'plugin-zod', Options, ResolvedOptions, never, ResolvePathOptions>

package/templates/ToZod.ts

@@ -1,61 +0,0 @@
-/**
- * See https://github.com/colinhacks/tozod/blob/master/src/index.ts
- * Adapted based on https://github.com/colinhacks/zod/issues/372
- */
-
-import type * as z from 'zod'
-
-type IsAny<T> = [any extends T ? 'true' : 'false'] extends ['true'] ? true : false
-type NonOptional<T> = T extends undefined ? never : T
-type NonNullable<T> = T extends null ? never : T
-type Equals<X, Y> = [X] extends [Y] ? ([Y] extends [X] ? true : false) : false
-
-type ZodKey<T> =
-  IsAny<T> extends true
-    ? 'any'
-    : Equals<T, boolean> extends true //[T] extends [booleanUtil.Type]
-      ? 'boolean'
-      : [undefined] extends [T]
-        ? 'optional'
-        : [null] extends [T]
-          ? 'nullable'
-          : T extends any[]
-            ? 'array'
-            : Equals<T, string> extends true
-              ? 'string'
-              : Equals<T, bigint> extends true //[T] extends [bigintUtil.Type]
-                ? 'bigint'
-                : Equals<T, number> extends true //[T] extends [numberUtil.Type]
-                  ? 'number'
-                  : Equals<T, Date> extends true //[T] extends [dateUtil.Type]
-                    ? 'date'
-                    : T extends { [k: string]: any } //[T] extends [structUtil.Type]
-                      ? 'object'
-                      : 'rest'
-
-export type ToZod<T> = {
-  any: z.ZodAny
-  optional: z.ZodOptional<ToZod<NonOptional<T>>>
-  nullable: z.ZodNullable<ToZod<NonNullable<T>>>
-  array: T extends Array<infer U> ? z.ZodArray<ToZod<U>> : never
-  string: z.ZodString
-  bigint: z.ZodBigInt
-  number: z.ZodNumber
-  boolean: z.ZodBoolean
-  date: z.ZodDate
-  object: z.ZodObject<
-    // @ts-expect-error cannot convert without Extract but Extract removes the type
-    {
-      [K in keyof T]: T[K]
-    },
-    'passthrough',
-    unknown,
-    T
-  >
-  rest: z.ZodType<T>
-}[ZodKey<T>]
-
-export type ZodShape<T> = {
-  // Require all the keys from T
-  [key in keyof T]-?: ToZod<T[key]>
-}