@kubb/plugin-zod 3.0.0-alpha.9 → 3.0.0-beta.10

package/src/generators/zodGenerator.tsx

@@ -0,0 +1,121 @@
+import { type OperationSchema as OperationSchemaType, SchemaGenerator, createReactGenerator, schemaKeywords } from '@kubb/plugin-oas'
+import { Oas } from '@kubb/plugin-oas/components'
+import { useOas, useOperationManager, useSchemaManager } from '@kubb/plugin-oas/hooks'
+import { pluginTsName } from '@kubb/plugin-ts'
+import { File, useApp } from '@kubb/react'
+import { Zod } from '../components'
+import type { PluginZod } from '../types'
+
+export const zodGenerator = createReactGenerator<PluginZod>({
+  name: 'zod',
+  Operation({ operation, options }) {
+    const { coercion, inferred, typed, mapper } = options
+
+    const { plugin, pluginManager, mode } = useApp<PluginZod>()
+    const oas = useOas()
+    const { getSchemas, getFile } = useOperationManager()
+    const schemaManager = useSchemaManager()
+
+    const file = getFile(operation)
+    const schemas = getSchemas(operation)
+    const schemaGenerator = new SchemaGenerator(options, {
+      oas,
+      plugin,
+      pluginManager,
+      mode,
+      override: options.override,
+    })
+
+    const operationSchemas = [schemas.pathParams, schemas.queryParams, schemas.headerParams, schemas.statusCodes, schemas.request, schemas.response]
+      .flat()
+      .filter(Boolean)
+
+    const mapOperationSchema = ({ name, schema, description, keysToOmit, ...options }: OperationSchemaType, i: number) => {
+      // hack so Params can be optional when needed
+      const required = Array.isArray(schema?.required) ? !!schema.required.length : !!schema?.required
+      const optional = !required && !!name.includes('Params')
+      const tree = [...schemaGenerator.parse({ schema, name }), optional ? { keyword: schemaKeywords.optional } : undefined].filter(Boolean)
+      const imports = schemaManager.getImports(tree)
+
+      const zod = {
+        name: schemaManager.getName(name, { type: 'function' }),
+        inferTypeName: schemaManager.getName(name, { type: 'type' }),
+        file: schemaManager.getFile(name),
+      }
+
+      const type = {
+        name: schemaManager.getName(name, { type: 'type', pluginKey: [pluginTsName] }),
+        file: schemaManager.getFile(options.operationName || name, { pluginKey: [pluginTsName], tag: options.operation?.getTags()[0]?.name }),
+      }
+
+      return (
+        <Oas.Schema key={i} name={name} value={schema} tree={tree}>
+          {typed && <File.Import isTypeOnly root={file.path} path={type.file.path} name={[type.name]} />}
+          {imports.map((imp, index) => (
+            <File.Import key={index} root={file.path} path={imp.path} name={imp.name} />
+          ))}
+          <Zod
+            name={zod.name}
+            typeName={typed ? type.name : undefined}
+            inferTypeName={inferred ? zod.inferTypeName : undefined}
+            description={description}
+            tree={tree}
+            mapper={mapper}
+            coercion={coercion}
+            keysToOmit={keysToOmit}
+          />
+        </Oas.Schema>
+      )
+    }
+
+    return (
+      <File baseName={file.baseName} path={file.path} meta={file.meta} banner={plugin.options.output?.banner} footer={plugin.options.output?.footer}>
+        <File.Import name={['z']} path={plugin.options.importPath} />
+        {operationSchemas.map(mapOperationSchema)}
+      </File>
+    )
+  },
+  Schema({ schema, options }) {
+    const { coercion, inferred, typed, mapper, importPath } = options
+
+    const { getName, getFile, getImports } = useSchemaManager()
+    const {
+      plugin: {
+        options: { output },
+      },
+    } = useApp<PluginZod>()
+
+    const imports = getImports(schema.tree)
+
+    const zod = {
+      name: getName(schema.name, { type: 'function' }),
+      inferTypeName: getName(schema.name, { type: 'type' }),
+      file: getFile(schema.name),
+    }
+
+    const type = {
+      name: getName(schema.name, { type: 'type', pluginKey: [pluginTsName] }),
+      file: getFile(schema.name, { pluginKey: [pluginTsName] }),
+    }
+
+    return (
+      <File baseName={zod.file.baseName} path={zod.file.path} meta={zod.file.meta} banner={output?.banner} footer={output?.footer}>
+        <File.Import name={['z']} path={importPath} />
+        {typed && <File.Import isTypeOnly root={zod.file.path} path={type.file.path} name={[type.name]} />}
+        {imports.map((imp, index) => (
+          <File.Import key={index} root={zod.file.path} path={imp.path} name={imp.name} />
+        ))}
+
+        <Zod
+          name={zod.name}
+          typeName={typed ? type.name : undefined}
+          inferTypeName={inferred ? zod.inferTypeName : undefined}
+          description={schema.value.description}
+          tree={schema.tree}
+          mapper={mapper}
+          coercion={coercion}
+        />
+      </File>
+    )
+  },
+})

package/src/parser/index.ts

@@ -1,9 +1,9 @@
 import transformers, { createJSDocBlockText } from '@kubb/core/transformers'
-import { type SchemaKeywordMapper, isKeyword, schemaKeywords } from '@kubb/plugin-oas'
+import { type SchemaKeywordMapper, type SchemaTree, isKeyword, schemaKeywords } from '@kubb/plugin-oas'
 
 import type { Schema, SchemaKeywordBase, SchemaMapper } from '@kubb/plugin-oas'
 
-export const zodKeywordMapper = {
+const zodKeywordMapper = {
   any: () => 'z.any()',
   unknown: () => 'z.unknown()',
   number: (coercion?: boolean, min?: number, max?: number) => {
@@ -39,7 +39,7 @@ export const zodKeywordMapper = {
   tuple: (items: string[] = []) => `z.tuple([${items?.join(', ')}])`,
   enum: (items: string[] = []) => `z.enum([${items?.join(', ')}])`,
   union: (items: string[] = []) => `z.union([${items?.join(', ')}])`,
-  const: (value?: string | number) => `z.literal(${value ?? ''})`,
+  const: (value?: string | number | boolean) => `z.literal(${value ?? ''})`,
   /**
    * ISO 8601
    */
@@ -102,6 +102,7 @@ export const zodKeywordMapper = {
   password: undefined,
   phone: undefined,
   readOnly: undefined,
+  writeOnly: undefined,
   ref: (value?: string) => (value ? `z.lazy(() => ${value})` : undefined),
   blob: () => 'z.string()',
   deprecated: undefined,
@@ -149,17 +150,27 @@ export function sort(items?: Schema[]): Schema[] {
   return transformers.orderBy(items, [(v) => order.indexOf(v.keyword)], ['asc'])
 }
 
+const shouldCoerce = (coercion: ParserOptions['coercion'] | undefined, type: 'dates' | 'strings' | 'numbers'): boolean => {
+  if (coercion === undefined) {
+    return false
+  }
+  if (typeof coercion === 'boolean') {
+    return coercion
+  }
+
+  return !!coercion[type]
+}
+
 type ParserOptions = {
   name: string
   typeName?: string
   description?: string
-
   keysToOmit?: string[]
   mapper?: Record<string, string>
-  coercion?: boolean
+  coercion?: boolean | { dates?: boolean; strings?: boolean; numbers?: boolean }
 }
 
-export function parse(parent: Schema | undefined, current: Schema, options: ParserOptions): string | undefined {
+export function parse({ parent, current, siblings }: SchemaTree, options: ParserOptions): string | undefined {
   const value = zodKeywordMapper[current.keyword as keyof typeof zodKeywordMapper]
 
   if (!value) {
@@ -169,7 +180,7 @@ export function parse(parent: Schema | undefined, current: Schema, options: Pars
   if (isKeyword(current, schemaKeywords.union)) {
     // zod union type needs at least 2 items
     if (Array.isArray(current.args) && current.args.length === 1) {
-      return parse(parent, current.args[0] as Schema, options)
+      return parse({ parent, current: current.args[0] as Schema, siblings }, options)
     }
     if (Array.isArray(current.args) && !current.args.length) {
       return ''
@@ -177,7 +188,7 @@ export function parse(parent: Schema | undefined, current: Schema, options: Pars
 
     return zodKeywordMapper.union(
       sort(current.args)
-        .map((schema) => parse(current, schema, options))
+        .map((schema, _index, siblings) => parse({ parent: current, current: schema, siblings }, options))
         .filter(Boolean),
     )
   }
@@ -187,7 +198,7 @@ export function parse(parent: Schema | undefined, current: Schema, options: Pars
       .filter((schema: Schema) => {
         return ![schemaKeywords.optional, schemaKeywords.describe].includes(schema.keyword as typeof schemaKeywords.describe)
       })
-      .map((schema: Schema) => parse(current, schema, options))
+      .map((schema: Schema, _index, siblings) => parse({ parent: current, current: schema, siblings }, options))
       .filter(Boolean)
 
     return `${items.slice(0, 1)}${zodKeywordMapper.and(items.slice(1))}`
@@ -196,7 +207,7 @@ export function parse(parent: Schema | undefined, current: Schema, options: Pars
   if (isKeyword(current, schemaKeywords.array)) {
     return zodKeywordMapper.array(
       sort(current.args.items)
-        .map((schemas) => parse(current, schemas, options))
+        .map((schemas, _index, siblings) => parse({ parent: current, current: schemas, siblings }, options))
         .filter(Boolean),
       current.args.min,
       current.args.max,
@@ -205,17 +216,22 @@ export function parse(parent: Schema | undefined, current: Schema, options: Pars
 
   if (isKeyword(current, schemaKeywords.enum)) {
     if (current.args.asConst) {
+      if (current.args.items.length === 1) {
+        const child = {
+          keyword: schemaKeywords.const,
+          args: current.args.items[0],
+        }
+        return parse({ parent: current, current: child, siblings: [child] }, options)
+      }
+
       return zodKeywordMapper.union(
         current.args.items
-          .map((schema) => {
-            return parse(
-              current,
-              {
-                keyword: schemaKeywords.const,
-                args: schema,
-              },
-              options,
-            )
+          .map((schema) => ({
+            keyword: schemaKeywords.const,
+            args: schema,
+          }))
+          .map((schema, _index, siblings) => {
+            return parse({ parent: current, current: schema, siblings }, options)
           })
           .filter(Boolean),
       )
@@ -223,6 +239,10 @@ export function parse(parent: Schema | undefined, current: Schema, options: Pars
 
     return zodKeywordMapper.enum(
       current.args.items.map((schema) => {
+        if (schema.format === 'boolean') {
+          return transformers.stringify(schema.value)
+        }
+
         if (schema.format === 'number') {
           return transformers.stringify(schema.value)
         }
@@ -251,8 +271,8 @@ export function parse(parent: Schema | undefined, current: Schema, options: Pars
         }
 
         return `"${name}": ${sort(schemas)
-          .map((schema, array) => {
-            return parse(current, schema, options)
+          .map((schema, array, siblings) => {
+            return parse({ parent: current, current: schema, siblings }, options)
           })
           .filter(Boolean)
           .join('')}`
@@ -261,9 +281,9 @@ export function parse(parent: Schema | undefined, current: Schema, options: Pars
 
     const additionalProperties = current.args?.additionalProperties?.length
       ? current.args.additionalProperties
-          .map((schema) => parse(current, schema, options))
+          .map((schema, _index, siblings) => parse({ parent: current, current: schema, siblings }, options))
           .filter(Boolean)
-          .at(0)
+          .join('')
       : undefined
 
     const text = [
@@ -277,9 +297,7 @@ export function parse(parent: Schema | undefined, current: Schema, options: Pars
 
   if (isKeyword(current, schemaKeywords.tuple)) {
     return zodKeywordMapper.tuple(
-      sort(current.args.items)
-        .map((schema) => parse(current, schema, options))
-        .filter(Boolean),
+      current.args.items.map((schema, _index, siblings) => parse({ parent: current, current: schema, siblings }, options)).filter(Boolean),
     )
   }
 
@@ -287,6 +305,10 @@ export function parse(parent: Schema | undefined, current: Schema, options: Pars
     if (current.args.format === 'number' && current.args.value !== undefined) {
       return zodKeywordMapper.const(Number.parseInt(current.args.value?.toString()))
     }
+
+    if (current.args.format === 'boolean' && current.args.value !== undefined) {
+      return zodKeywordMapper.const(current.args.value)
+    }
     return zodKeywordMapper.const(transformers.stringify(current.args.value))
   }
 
@@ -309,15 +331,15 @@ export function parse(parent: Schema | undefined, current: Schema, options: Pars
   }
 
   if (isKeyword(current, schemaKeywords.string)) {
-    return zodKeywordMapper.string(options.coercion)
+    return zodKeywordMapper.string(shouldCoerce(options.coercion, 'strings'))
   }
 
   if (isKeyword(current, schemaKeywords.number)) {
-    return zodKeywordMapper.number(options.coercion)
+    return zodKeywordMapper.number(shouldCoerce(options.coercion, 'numbers'))
   }
 
   if (isKeyword(current, schemaKeywords.integer)) {
-    return zodKeywordMapper.integer(options.coercion)
+    return zodKeywordMapper.integer(shouldCoerce(options.coercion, 'numbers'))
   }
 
   if (isKeyword(current, schemaKeywords.min)) {
@@ -332,11 +354,11 @@ export function parse(parent: Schema | undefined, current: Schema, options: Pars
   }
 
   if (isKeyword(current, schemaKeywords.date)) {
-    return zodKeywordMapper.date(current.args.type, options.coercion)
+    return zodKeywordMapper.date(current.args.type, shouldCoerce(options.coercion, 'dates'))
   }
 
   if (isKeyword(current, schemaKeywords.time)) {
-    return zodKeywordMapper.time(current.args.type, options.coercion)
+    return zodKeywordMapper.time(current.args.type, shouldCoerce(options.coercion, 'dates'))
   }
 
   if (current.keyword in zodKeywordMapper && 'args' in current) {
@@ -345,6 +367,12 @@ export function parse(parent: Schema | undefined, current: Schema, options: Pars
     return value((current as SchemaKeywordBase<unknown>).args as any)
   }
 
+  if (isKeyword(current, schemaKeywords.optional)) {
+    if (siblings.some((schema) => isKeyword(schema, schemaKeywords.default))) return ''
+
+    return value()
+  }
+
   if (current.keyword in zodKeywordMapper) {
     return value()
   }

package/src/plugin.ts

@@ -1,23 +1,22 @@
 import path from 'node:path'
 
-import { FileManager, PluginManager, createPlugin } from '@kubb/core'
+import { FileManager, type Group, PluginManager, createPlugin } from '@kubb/core'
 import { camelCase, pascalCase } from '@kubb/core/transformers'
-import { renderTemplate } from '@kubb/core/utils'
 import { OperationGenerator, SchemaGenerator, pluginOasName } from '@kubb/plugin-oas'
 
 import { pluginTsName } from '@kubb/plugin-ts'
 
 import type { Plugin } from '@kubb/core'
 import type { PluginOas as SwaggerPluginOptions } from '@kubb/plugin-oas'
-import { zodParser } from './SchemaGenerator.tsx'
-import { Operations } from './components/Operations.tsx'
+import { operationsGenerator } from './generators'
+import { zodGenerator } from './generators/zodGenerator.tsx'
 import type { PluginZod } from './types.ts'
 
 export const pluginZodName = 'plugin-zod' satisfies PluginZod['name']
 
 export const pluginZod = createPlugin<PluginZod>((options) => {
   const {
-    output = { path: 'zod' },
+    output = { path: 'zod', barrelType: 'named' },
     group,
     exclude = [],
     include,
@@ -26,43 +25,42 @@ export const pluginZod = createPlugin<PluginZod>((options) => {
     dateType = 'string',
     unknownType = 'any',
     typed = false,
-    typedSchema = false,
     mapper = {},
-    templates,
+    operations = false,
     importPath = 'zod',
     coercion = false,
+    inferred = false,
+    generators = [zodGenerator, operations ? operationsGenerator : undefined].filter(Boolean),
   } = options
-  const template = group?.output ? group.output : `${output.path}/{{tag}}Controller`
 
   return {
     name: pluginZodName,
-    output: {
-      exportType: 'barrelNamed',
-      ...output,
-    },
     options: {
-      extName: output.extName,
+      output,
       transformers,
       include,
       exclude,
       override,
       typed,
-      typedSchema,
       dateType,
       unknownType,
       mapper,
       importPath,
       coercion,
-      templates: {
-        operations: Operations.templates,
-        ...templates,
-      },
+      operations,
+      inferred,
     },
     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 ?? FileManager.getMode(path.resolve(root, output.path))
 
+      if (options?.tag && group?.type === 'tag') {
+        const groupName: Group['name'] = group?.name ? group.name : (ctx) => `${ctx.group}Controller`
+
+        return path.resolve(root, output.path, groupName({ group: camelCase(options.tag) }), baseName)
+      }
+
       if (mode === 'single') {
         /**
          * when output is a file then we will always append to the same file(output file), see fileManager.addOrAppend
@@ -71,12 +69,6 @@ export const pluginZod = createPlugin<PluginZod>((options) => {
         return path.resolve(root, output.path)
       }
 
-      if (options?.tag && group?.type === 'tag') {
-        const tag = camelCase(options.tag)
-
-        return path.resolve(root, renderTemplate(template, { tag }), baseName)
-      }
-
       return path.resolve(root, output.path, baseName)
     },
     resolveName(name, type) {
@@ -113,7 +105,7 @@ export const pluginZod = createPlugin<PluginZod>((options) => {
         output: output.path,
       })
 
-      const schemaFiles = await schemaGenerator.build(zodParser)
+      const schemaFiles = await schemaGenerator.build(...generators)
       await this.addFile(...schemaFiles)
 
       const operationGenerator = new OperationGenerator(this.plugin.options, {
@@ -127,22 +119,21 @@ export const pluginZod = createPlugin<PluginZod>((options) => {
         mode,
       })
 
-      const operationFiles = await operationGenerator.build(zodParser)
+      const operationFiles = await operationGenerator.build(...generators)
       await this.addFile(...operationFiles)
 
-      if (this.config.output.exportType) {
-        const barrelFiles = await this.fileManager.getBarrelFiles({
-          root,
-          output,
-          files: this.fileManager.files,
-          meta: {
-            pluginKey: this.plugin.key,
-          },
-          logger: this.logger,
-        })
-
-        await this.addFile(...barrelFiles)
-      }
+      const barrelFiles = await this.fileManager.getBarrelFiles({
+        type: output.barrelType ?? 'named',
+        root,
+        output,
+        files: this.fileManager.files,
+        meta: {
+          pluginKey: this.plugin.key,
+        },
+        logger: this.logger,
+      })
+
+      await this.addFile(...barrelFiles)
     },
   }
 })

package/src/types.ts

@@ -1,57 +1,16 @@
-import type { Plugin, PluginFactoryOptions, ResolveNameParams } from '@kubb/core'
-import type * as KubbFile from '@kubb/fs/types'
+import type { Group, Output, PluginFactoryOptions, ResolveNameParams } from '@kubb/core'
 import type { SchemaObject } from '@kubb/oas'
-import type { Exclude, Include, Override, ResolvePathOptions, Schema } from '@kubb/plugin-oas'
-import type { Operations } from './components/Operations'
-
-type Templates = {
-  operations?: typeof Operations.templates | false
-}
+import type { Exclude, Generator, Include, Override, ResolvePathOptions, Schema } from '@kubb/plugin-oas'
 
 export type Options = {
-  output?: {
-    /**
-     * Relative path to save the Zod schemas.
-     * When output is a file it will save all models inside that file else it will create a file per schema item.
-     * @default 'zod'
-     */
-    path: string
-    /**
-     * Name to be used for the `export * as {{exportAs}} from './'`
-     */
-    exportAs?: string
-    /**
-     * Add an extension to the generated imports and exports, default it will not use an extension
-     */
-    extName?: KubbFile.Extname
-    /**
-     * Define what needs to exported, here you can also disable the export of barrel files
-     * @default `'barrel'`
-     */
-    exportType?: 'barrel' | 'barrelNamed' | false
-  }
+  /**
+   * @default 'zod'
+   */
+  output?: Output
   /**
    * Group the Zod schemas based on the provided name.
    */
-  group?: {
-    /**
-     * Tag will group based on the operation tag inside the Swagger file
-     */
-    type: 'tag'
-    /**
-     * Relative path to save the grouped Zod schemas.
-     *
-     * `{{tag}}` will be replaced by the current tagName.
-     * @example `${output}/{{tag}}Controller` => `zod/PetController`
-     * @default `${output}/{{tag}}Controller`
-     */
-    output?: string
-    /**
-     * Name to be used for the `export * as {{exportAs}} from './`
-     * @default `"{{tag}}Schemas"`
-     */
-    exportAs?: string
-  }
+  group?: Group
   /**
    * Array containing exclude parameters to exclude/skip tags/operations/methods/paths.
    */
@@ -64,30 +23,15 @@ export type Options = {
    * Array containing override parameters to override `options` based on tags/operations/methods/paths.
    */
   override?: Array<Override<ResolvedOptions>>
-  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(propertName) and return FakerMeta array
-     * TODO TODO add docs
-     * @beta
-     */
-    schema?: (
-      props: {
-        schema?: SchemaObject
-        name?: string
-        parentName?: string
-      },
-      defaultSchemas: Schema[],
-    ) => Schema[] | undefined
-  }
-  mapper?: Record<string, string>
   /**
-   * Make it possible to override one of the templates
+   * Path to Zod
+   * It will be used as `import { z } from '${importPath}'`.
+   * It allows both relative and absolute path.
+   * the path will be applied as is, so relative path should be based on the file being generated.
+   * @default 'zod'
    */
-  templates?: Partial<Templates>
+  importPath?: string
+
   /**
    * Choose to use `date` or `datetime` as JavaScript `Date` instead of `string`.
    * False will fallback on a simple z.string() format
@@ -106,40 +50,57 @@ export type Options = {
   /**
    * Return Zod generated schema as type with z.infer<TYPE>
    */
-  typedSchema?: boolean
+  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
+  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(propertName) and return FakerMeta array
+     * TODO TODO add docs
+     * @beta
+     */
+    schema?: (
+      props: {
+        schema?: SchemaObject
+        name?: string
+        parentName?: string
+      },
+      defaultSchemas: Schema[],
+    ) => Schema[] | undefined
+  }
   /**
-   * Path to Zod
-   * It will be used as `import { z } from '${importPath}'`.
-   * It allows both relative and absolute path.
-   * the path will be applied as is, so relative path should be based on the file being generated.
-   * @default 'zod'
+   * Define some generators next to the zod generators
    */
-  importPath?: string
+  generators?: Array<Generator<PluginZod>>
 }
 
 type ResolvedOptions = {
-  extName: KubbFile.Extname | undefined
+  output: Output
+  override: NonNullable<Options['override']>
   transformers: NonNullable<Options['transformers']>
-  exclude: Options['exclude']
-  include: Options['include']
-  override: Options['override']
   dateType: NonNullable<Options['dateType']>
   unknownType: NonNullable<Options['unknownType']>
   typed: NonNullable<Options['typed']>
-  typedSchema: NonNullable<Options['typedSchema']>
-  templates: NonNullable<Templates>
+  inferred: NonNullable<Options['inferred']>
   mapper: NonNullable<Options['mapper']>
   importPath: NonNullable<Options['importPath']>
   coercion: NonNullable<Options['coercion']>
-}
-
-export type FileMeta = {
-  pluginKey?: Plugin['key']
-  tag?: string
+  operations: NonNullable<Options['operations']>
 }
 
 export type PluginZod = PluginFactoryOptions<'plugin-zod', Options, ResolvedOptions, never, ResolvePathOptions>