@kubb/plugin-zod 3.0.0-alpha.0

package/src/components/Schema.tsx

@@ -0,0 +1,171 @@
+import { Oas } from '@kubb/plugin-oas/components'
+import { Const, File, Type, useApp, useFile } from '@kubb/react'
+import { pluginTsName } from '@kubb/plugin-ts'
+
+import transformers from '@kubb/core/transformers'
+import { isKeyword, schemaKeywords } from '@kubb/plugin-oas'
+import { useSchema } from '@kubb/plugin-oas/hooks'
+import type { ReactNode } from 'react'
+import * as parserZod from '../parser/index.ts'
+import { pluginZodName } from '../plugin.ts'
+import type { PluginZod } from '../types.ts'
+
+type Props = {
+  description?: string
+  withTypeAnnotation?: boolean
+  keysToOmit?: string[]
+}
+
+export function Schema(props: Props): ReactNode {
+  const { keysToOmit, withTypeAnnotation, description } = props
+  const { tree, name } = useSchema()
+  const {
+    pluginManager,
+    plugin: {
+      options: { mapper, typedSchema, coercion },
+    },
+  } = useApp<PluginZod>()
+
+  // all checks are also inside this.schema(React)
+  const resolvedName = pluginManager.resolveName({
+    name,
+    pluginKey: [pluginZodName],
+    type: 'function',
+  })
+  const resolvedTypeName = pluginManager.resolveName({
+    name,
+    pluginKey: [pluginZodName],
+    type: 'type',
+  })
+
+  const typeName = pluginManager.resolveName({
+    name,
+    pluginKey: [pluginTsName],
+    type: 'type',
+  })
+
+  if (!tree.length) {
+    return (
+      <Const
+        name={resolvedName}
+        export
+        JSDoc={{
+          comments: [description ? `@description ${transformers.jsStringEscape(description)}` : undefined].filter(Boolean),
+        }}
+      >
+        undefined
+      </Const>
+    )
+  }
+
+  const hasTuple = tree.some((item) => isKeyword(item, schemaKeywords.tuple))
+
+  const output = parserZod
+    .sort(tree)
+    .filter((item) => {
+      if (hasTuple && (isKeyword(item, schemaKeywords.min) || isKeyword(item, schemaKeywords.max))) {
+        return false
+      }
+
+      return true
+    })
+    .map((item) => parserZod.parse(undefined, item, { name, typeName, description, mapper, coercion, keysToOmit }))
+    .filter(Boolean)
+    .join('')
+
+  const suffix = output.endsWith('.nullable()') ? '.unwrap().and' : '.and'
+
+  return (
+    <>
+      <Const
+        export
+        name={resolvedName}
+        JSDoc={{
+          comments: [description ? `@description ${transformers.jsStringEscape(description)}` : undefined].filter(Boolean),
+        }}
+      >
+        {[
+          output,
+          keysToOmit?.length ? `${suffix}(z.object({ ${keysToOmit.map((key) => `${key}: z.never()`).join(',')} }))` : undefined,
+          withTypeAnnotation && typeName ? ` as z.ZodType<${typeName}>` : '',
+        ]
+          .filter(Boolean)
+          .join('') || ''}
+      </Const>
+      {typedSchema && (
+        <Type export name={resolvedTypeName}>
+          {`z.infer<typeof ${resolvedName}>`}
+        </Type>
+      )}
+    </>
+  )
+}
+
+type FileProps = {}
+
+Schema.File = function ({}: FileProps): ReactNode {
+  const {
+    pluginManager,
+    plugin: {
+      options: { typed },
+    },
+  } = useApp<PluginZod>()
+  const { tree, schema } = useSchema()
+
+  const withData = tree.some(
+    (schema) =>
+      schema.keyword === schemaKeywords.array ||
+      schema.keyword === schemaKeywords.and ||
+      schema.keyword === schemaKeywords.object ||
+      schema.keyword === schemaKeywords.union ||
+      schema.keyword === schemaKeywords.tuple,
+  )
+
+  const withTypeAnnotation = !!typed
+
+  return (
+    <Oas.Schema.File output={pluginManager.config.output.path}>
+      <Schema.Imports />
+      <File.Source>
+        <Schema withTypeAnnotation={withTypeAnnotation} description={schema?.description} />
+      </File.Source>
+    </Oas.Schema.File>
+  )
+}
+Schema.Imports = (): ReactNode => {
+  const {
+    pluginManager,
+    plugin: {
+      options: { typed, importPath },
+    },
+  } = useApp<PluginZod>()
+  const { path: root } = useFile()
+  const { name, tree, schema } = useSchema()
+
+  // used for this.options.typed
+  const typeName = pluginManager.resolveName({
+    name,
+    pluginKey: [pluginTsName],
+    type: 'type',
+  })
+
+  const typeFileName = pluginManager.resolveName({
+    name: name,
+    pluginKey: [pluginTsName],
+    type: 'file',
+  })
+
+  const typePath = pluginManager.resolvePath({
+    baseName: typeFileName,
+    pluginKey: [pluginTsName],
+  })
+
+  const withTypeAnnotation = !!typed
+
+  return (
+    <>
+      <File.Import name={['z']} path={importPath} />
+      {withTypeAnnotation && typeName && typePath && <File.Import isTypeOnly root={root} path={typePath} name={[typeName]} />}
+    </>
+  )
+}

package/src/components/__snapshots__/operations.ts

@@ -0,0 +1,50 @@
+export const operations = {
+  'get_pets-pet-id': {
+    request: undefined,
+    parameters: {
+      path: undefined,
+      query: undefined,
+      header: undefined,
+    },
+    responses: {
+      200: GetPetsPetIdQueryResponse,
+      default: GetPetsPetIdQueryResponse,
+    },
+    errors: {},
+  },
+  listPets: {
+    request: undefined,
+    parameters: {
+      path: undefined,
+      query: ListPetsQueryParams,
+      header: undefined,
+    },
+    responses: {
+      200: ListPetsQueryResponse,
+      default: ListPetsQueryResponse,
+    },
+    errors: {},
+  },
+  createPets: {
+    request: CreatePetsMutationRequest,
+    parameters: {
+      path: undefined,
+      query: undefined,
+      header: undefined,
+    },
+    responses: {
+      201: CreatePetsMutationResponse,
+      default: CreatePetsMutationResponse,
+    },
+    errors: {},
+  },
+} as const
+export const paths = {
+  '/pets/{pet_id}': {
+    get: operations['get_pets-pet-id'],
+  },
+  '/pets': {
+    get: operations['listPets'],
+    post: operations['createPets'],
+  },
+} as const

package/src/components/index.ts

@@ -0,0 +1,3 @@
+export { OperationSchema } from './OperationSchema.tsx'
+export { Operations } from './Operations.tsx'
+export { Schema } from './Schema.tsx'

package/src/index.ts

@@ -0,0 +1,15 @@
+import { pluginZod } from './plugin.ts'
+
+export { pluginZod, pluginZodName } from './plugin.ts'
+export type { PluginZod } from './types.ts'
+
+/**
+ * @deprecated Use `import { pluginZod } from '@kubb/plugin-zod'` instead
+ */
+const definePluginDefault = pluginZod
+/**
+ * @deprecated Use `import { pluginZod } from '@kubb/plugin-zod'` instead
+ */
+export const definePlugin = pluginZod
+
+export default definePluginDefault

package/src/parser/index.ts

@@ -0,0 +1,345 @@
+import transformers, { createJSDocBlockText } from '@kubb/core/transformers'
+import { type SchemaKeywordMapper, isKeyword, schemaKeywords } from '@kubb/plugin-oas'
+
+import type { Schema, SchemaKeywordBase, SchemaMapper } from '@kubb/plugin-oas'
+
+export const zodKeywordMapper = {
+  any: () => 'z.any()',
+  unknown: () => 'z.unknown()',
+  number: (coercion?: boolean, min?: number, max?: number) => {
+    return [coercion ? 'z.coerce.number()' : 'z.number()', min !== undefined ? `.min(${min})` : undefined, max !== undefined ? `.max(${max})` : undefined]
+      .filter(Boolean)
+      .join('')
+  },
+  integer: (coercion?: boolean, min?: number, max?: number) => {
+    return [coercion ? 'z.coerce.number()' : 'z.number()', min !== undefined ? `.min(${min})` : undefined, max !== undefined ? `.max(${max})` : undefined]
+      .filter(Boolean)
+      .join('')
+  },
+  object: (value?: string) => `z.object({${value}})`,
+  string: (coercion?: boolean, min?: number, max?: number) => {
+    return [coercion ? 'z.coerce.string()' : 'z.string()', min !== undefined ? `.min(${min})` : undefined, max !== undefined ? `.max(${max})` : undefined]
+      .filter(Boolean)
+      .join('')
+  },
+  boolean: () => 'z.boolean()',
+  undefined: () => 'z.undefined()',
+  nullable: () => '.nullable()',
+  null: () => 'z.null()',
+  nullish: () => '.nullish()',
+  array: (items: string[] = [], min?: number, max?: number) => {
+    return [`z.array(${items?.join('')})`, min !== undefined ? `.min(${min})` : undefined, max !== undefined ? `.max(${max})` : undefined]
+      .filter(Boolean)
+      .join('')
+  },
+  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 ?? ''})`,
+  /**
+   * ISO 8601
+   */
+  datetime: (offset = false, local = false) => {
+    if (offset) {
+      return `z.string().datetime({ offset: ${offset} })`
+    }
+
+    if (local) {
+      return `z.string().datetime({ local: ${local} })`
+    }
+
+    return 'z.string().datetime()'
+  },
+  /**
+   * Type `'date'` Date
+   * Type `'string'` ISO date format (YYYY-MM-DD)
+   * @default ISO date format (YYYY-MM-DD)
+   */
+  date: (type: 'date' | 'string' = 'string', coercion?: boolean) => {
+    if (type === 'string') {
+      return 'z.string().date()'
+    }
+
+    if (coercion) {
+      return 'z.coerce.date()'
+    }
+
+    return 'z.date()'
+  },
+  /**
+   * Type `'date'` Date
+   * Type `'string'` ISO time format (HH:mm:ss[.SSSSSS])
+   * @default ISO time format (HH:mm:ss[.SSSSSS])
+   */
+  time: (type: 'date' | 'string' = 'string', coercion?: boolean) => {
+    if (type === 'string') {
+      return 'z.string().time()'
+    }
+
+    if (coercion) {
+      return 'z.coerce.date()'
+    }
+
+    return 'z.date()'
+  },
+  uuid: () => '.uuid()',
+  url: () => '.url()',
+  strict: () => '.strict()',
+  default: (value?: string | number | true) => `.default(${value ?? ''})`,
+  and: (items: string[] = []) => items?.map((item) => `.and(${item})`).join(''),
+  describe: (value = '') => `.describe(${value})`,
+  min: (value?: number) => `.min(${value ?? ''})`,
+  max: (value?: number) => `.max(${value ?? ''})`,
+  optional: () => '.optional()',
+  matches: (value = '') => `.regex(${value})`,
+  email: () => '.email()',
+  firstName: undefined,
+  lastName: undefined,
+  password: undefined,
+  phone: undefined,
+  readOnly: undefined,
+  ref: (value?: string) => (value ? `z.lazy(() => ${value})` : undefined),
+  blob: () => 'z.string()',
+  deprecated: undefined,
+  example: undefined,
+  schema: undefined,
+  catchall: (value?: string) => (value ? `.catchall(${value})` : undefined),
+  name: undefined,
+} satisfies SchemaMapper<string | null | undefined>
+
+/**
+ * @link based on https://github.com/cellular/oazapfts/blob/7ba226ebb15374e8483cc53e7532f1663179a22c/src/codegen/generate.ts#L398
+ */
+
+export function sort(items?: Schema[]): Schema[] {
+  const order: string[] = [
+    schemaKeywords.string,
+    schemaKeywords.datetime,
+    schemaKeywords.date,
+    schemaKeywords.time,
+    schemaKeywords.tuple,
+    schemaKeywords.number,
+    schemaKeywords.object,
+    schemaKeywords.enum,
+    schemaKeywords.url,
+    schemaKeywords.email,
+    schemaKeywords.firstName,
+    schemaKeywords.lastName,
+    schemaKeywords.password,
+    schemaKeywords.matches,
+    schemaKeywords.uuid,
+    schemaKeywords.min,
+    schemaKeywords.max,
+    schemaKeywords.default,
+    schemaKeywords.describe,
+    schemaKeywords.optional,
+    schemaKeywords.nullable,
+    schemaKeywords.nullish,
+    schemaKeywords.null,
+  ]
+
+  if (!items) {
+    return []
+  }
+
+  return transformers.orderBy(items, [(v) => order.indexOf(v.keyword)], ['asc'])
+}
+
+type ParserOptions = {
+  name: string
+  typeName?: string
+  description?: string
+
+  keysToOmit?: string[]
+  mapper?: Record<string, string>
+  coercion?: boolean
+}
+
+export function parse(parent: Schema | undefined, current: Schema, options: ParserOptions): string | undefined {
+  const value = zodKeywordMapper[current.keyword as keyof typeof zodKeywordMapper]
+
+  if (!value) {
+    return undefined
+  }
+
+  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)
+    }
+    if (Array.isArray(current.args) && !current.args.length) {
+      return ''
+    }
+
+    return zodKeywordMapper.union(
+      sort(current.args)
+        .map((schema) => parse(current, schema, options))
+        .filter(Boolean),
+    )
+  }
+
+  if (isKeyword(current, schemaKeywords.and)) {
+    const items = sort(current.args)
+      .filter((schema: Schema) => {
+        return ![schemaKeywords.optional, schemaKeywords.describe].includes(schema.keyword as typeof schemaKeywords.describe)
+      })
+      .map((schema: Schema) => parse(current, schema, options))
+      .filter(Boolean)
+
+    return `${items.slice(0, 1)}${zodKeywordMapper.and(items.slice(1))}`
+  }
+
+  if (isKeyword(current, schemaKeywords.array)) {
+    return zodKeywordMapper.array(
+      sort(current.args.items)
+        .map((schemas) => parse(current, schemas, options))
+        .filter(Boolean),
+      current.args.min,
+      current.args.max,
+    )
+  }
+
+  if (isKeyword(current, schemaKeywords.enum)) {
+    if (current.args.asConst) {
+      return zodKeywordMapper.union(
+        current.args.items
+          .map((schema) => {
+            return parse(
+              current,
+              {
+                keyword: schemaKeywords.const,
+                args: schema,
+              },
+              options,
+            )
+          })
+          .filter(Boolean),
+      )
+    }
+
+    return zodKeywordMapper.enum(
+      current.args.items.map((schema) => {
+        if (schema.format === 'number') {
+          return transformers.stringify(schema.value)
+        }
+        return transformers.stringify(schema.value)
+      }),
+    )
+  }
+
+  if (isKeyword(current, schemaKeywords.ref)) {
+    return zodKeywordMapper.ref(current.args?.name)
+  }
+
+  if (isKeyword(current, schemaKeywords.object)) {
+    const properties = Object.entries(current.args?.properties || {})
+      .filter((item) => {
+        const schema = item[1]
+        return schema && typeof schema.map === 'function'
+      })
+      .map(([name, schemas]) => {
+        const nameSchema = schemas.find((schema) => schema.keyword === schemaKeywords.name) as SchemaKeywordMapper['name']
+        const mappedName = nameSchema?.args || name
+
+        // custom mapper(pluginOptions)
+        if (options.mapper?.[mappedName]) {
+          return `"${name}": ${options.mapper?.[mappedName]}`
+        }
+
+        return `"${name}": ${sort(schemas)
+          .map((schema, array) => {
+            return parse(current, schema, options)
+          })
+          .filter(Boolean)
+          .join('')}`
+      })
+      .join(',')
+
+    const additionalProperties = current.args?.additionalProperties?.length
+      ? current.args.additionalProperties
+          .map((schema) => parse(current, schema, options))
+          .filter(Boolean)
+          .at(0)
+      : undefined
+
+    const text = [
+      zodKeywordMapper.object(properties),
+      current.args?.strict ? zodKeywordMapper.strict() : undefined,
+      additionalProperties ? zodKeywordMapper.catchall(additionalProperties) : undefined,
+    ].filter(Boolean)
+
+    return text.join('')
+  }
+
+  if (isKeyword(current, schemaKeywords.tuple)) {
+    return zodKeywordMapper.tuple(
+      sort(current.args.items)
+        .map((schema) => parse(current, schema, options))
+        .filter(Boolean),
+    )
+  }
+
+  if (isKeyword(current, schemaKeywords.const)) {
+    if (current.args.format === 'number' && current.args.value !== undefined) {
+      return zodKeywordMapper.const(Number.parseInt(current.args.value?.toString()))
+    }
+    return zodKeywordMapper.const(transformers.stringify(current.args.value))
+  }
+
+  if (isKeyword(current, schemaKeywords.matches)) {
+    if (current.args) {
+      return zodKeywordMapper.matches(transformers.toRegExpString(current.args))
+    }
+  }
+
+  if (isKeyword(current, schemaKeywords.default)) {
+    if (current.args) {
+      return zodKeywordMapper.default(current.args)
+    }
+  }
+
+  if (isKeyword(current, schemaKeywords.describe)) {
+    if (current.args) {
+      return zodKeywordMapper.describe(transformers.stringify(current.args.toString()))
+    }
+  }
+
+  if (isKeyword(current, schemaKeywords.string)) {
+    return zodKeywordMapper.string(options.coercion)
+  }
+
+  if (isKeyword(current, schemaKeywords.number) || isKeyword(current, schemaKeywords.integer)) {
+    return zodKeywordMapper.number(options.coercion)
+  }
+
+  if (isKeyword(current, schemaKeywords.min)) {
+    return zodKeywordMapper.min(current.args)
+  }
+  if (isKeyword(current, schemaKeywords.max)) {
+    return zodKeywordMapper.max(current.args)
+  }
+
+  if (isKeyword(current, schemaKeywords.datetime)) {
+    return zodKeywordMapper.datetime(current.args.offset, current.args.local)
+  }
+
+  if (isKeyword(current, schemaKeywords.date)) {
+    return zodKeywordMapper.date(current.args.type, options.coercion)
+  }
+
+  if (isKeyword(current, schemaKeywords.time)) {
+    return zodKeywordMapper.time(current.args.type, options.coercion)
+  }
+
+  if (current.keyword in zodKeywordMapper && 'args' in current) {
+    const value = zodKeywordMapper[current.keyword as keyof typeof zodKeywordMapper] as (typeof zodKeywordMapper)['const']
+
+    return value((current as SchemaKeywordBase<unknown>).args as any)
+  }
+
+  if (current.keyword in zodKeywordMapper) {
+    return value()
+  }
+
+  return undefined
+}