@kubb/plugin-zod 0.0.0-canary-20241104172400

package/src/generators/__snapshots__/orderDateTypeFalse.ts

@@ -0,0 +1,3 @@
+import { z } from "zod";
+
+ export const order = z.object({ "id": z.number().int().optional(), "petId": z.number().int().optional(), "quantity": z.number().int().optional(), "shipDate": z.string().optional(), "status": z.enum(["placed", "approved", "delivered"]).describe("Order Status").optional(), "complete": z.boolean().optional() });

package/src/generators/__snapshots__/orderDateTypeString.ts

@@ -0,0 +1,3 @@
+import { z } from "zod";
+
+ export const order = z.object({ "id": z.number().int().optional(), "petId": z.number().int().optional(), "quantity": z.number().int().optional(), "shipDate": z.string().datetime().optional(), "status": z.enum(["placed", "approved", "delivered"]).describe("Order Status").optional(), "complete": z.boolean().optional() });

package/src/generators/__snapshots__/pet.ts

@@ -0,0 +1,3 @@
+import { z } from "zod";
+
+ export const pet = z.object({ "id": z.number().int(), "name": z.string(), "date": z.date().optional(), "tag": z.string().min(5).max(100).optional() });

package/src/generators/__snapshots__/petArray.ts

@@ -0,0 +1,6 @@
+import { z } from "zod";
+
+ /**
+ * @description List of Pet object
+ */
+export const petArray = z.array(z.lazy(() => pet)).min(1).max(3).describe("List of Pet object");

package/src/generators/__snapshots__/petCoercion.ts

@@ -0,0 +1,3 @@
+import { z } from "zod";
+
+ export const pet = z.object({ "id": z.coerce.number().int(), "name": z.coerce.string(), "date": z.coerce.date().optional(), "tag": z.coerce.string().min(5).max(100).optional() });

package/src/generators/__snapshots__/petTupleObject.ts

@@ -0,0 +1,6 @@
+import { z } from "zod";
+
+ /**
+ * @description Tuple of exact length 2 nested in an object
+ */
+export const petTupleObject = z.object({ "tupleProperty": z.tuple([z.string(), z.string()]).optional() }).describe("Tuple of exact length 2 nested in an object");

package/src/generators/__snapshots__/petWithMapper.ts

@@ -0,0 +1,3 @@
+import { z } from "zod";
+
+ export const pet = z.object({ "id": z.number().int(), "name": z.string().email(), "date": z.date().optional(), "tag": z.string().min(5).max(100).optional() });

package/src/generators/__snapshots__/pets.ts

@@ -0,0 +1,3 @@
+import { z } from "zod";
+
+ export const pets = z.array(z.object({ "id": z.number().int(), "name": z.string(), "tag": z.string().optional() })) as z.ZodType<Pets>;

package/src/generators/__snapshots__/recursive.ts

@@ -0,0 +1,3 @@
+import { z } from "zod";
+
+ export const example = z.object({ "name": z.string(), "children": z.array(z.lazy(() => example)) });

package/src/generators/__snapshots__/showPetById.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+
+ export const showPetByIdPathParams = z.object({ "petId": z.string().describe("The id of the pet to retrieve"), "testId": z.string().describe("The id of the pet to retrieve") });
+
+ /**
+ * @description Expected response to a valid request
+ */
+export const showPetById200 = z.lazy(() => pet);
+
+ /**
+ * @description unexpected error
+ */
+export const showPetByIdError = z.lazy(() => error);
+
+ export const showPetByIdQueryResponse = z.lazy(() => showPetById200);

package/src/generators/__snapshots__/stringValueConst.ts

@@ -0,0 +1,6 @@
+import { z } from "zod";
+
+ /**
+ * @description its value is equal to the value of the keyword
+ */
+export const stringValueConst = z.object({ "foobar": z.literal("foobar") }).describe("its value is equal to the value of the keyword");

package/src/generators/__snapshots__/uuidSchema.ts

@@ -0,0 +1,3 @@
+import { z } from "zod";
+
+ export const uuidSchema = z.string().uuid();

package/src/generators/index.ts

@@ -0,0 +1,2 @@
+export { zodGenerator } from './zodGenerator.tsx'
+export { operationsGenerator } from './operationsGenerator.tsx'

package/src/generators/operationsGenerator.tsx

@@ -0,0 +1,39 @@
+import { createReactGenerator } from '@kubb/plugin-oas'
+import { useOperationManager } from '@kubb/plugin-oas/hooks'
+import { File, useApp } from '@kubb/react'
+import { Operations } from '../components/Operations'
+import { pluginZodName } from '../plugin.ts'
+import type { PluginZod } from '../types'
+
+export const operationsGenerator = createReactGenerator<PluginZod>({
+  name: 'operations',
+  Operations({ operations }) {
+    const {
+      pluginManager,
+      plugin: {
+        options: { output },
+      },
+    } = useApp<PluginZod>()
+    const { getFile, groupSchemasByName } = useOperationManager()
+
+    const name = 'operations'
+    const file = pluginManager.getFile({ name, extname: '.ts', pluginKey: [pluginZodName] })
+
+    const transformedOperations = operations.map((operation) => ({ operation, data: groupSchemasByName(operation, { type: 'function' }) }))
+
+    const imports = Object.entries(transformedOperations)
+      .map(([key, { data, operation }]) => {
+        const names = [data.request, ...Object.values(data.responses), ...Object.values(data.parameters)].filter(Boolean)
+
+        return <File.Import key={key} name={names} root={file.path} path={getFile(operation).path} />
+      })
+      .filter(Boolean)
+
+    return (
+      <File baseName={file.baseName} path={file.path} meta={file.meta} banner={output?.banner} footer={output?.footer}>
+        {imports}
+        <Operations name={name} operations={transformedOperations} />
+      </File>
+    )
+  },
+})

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/index.ts

@@ -0,0 +1,2 @@
+export { pluginZod, pluginZodName } from './plugin.ts'
+export type { PluginZod } from './types.ts'

package/src/parser/index.ts

@@ -0,0 +1,381 @@
+import transformers, { createJSDocBlockText } from '@kubb/core/transformers'
+import { type SchemaKeywordMapper, type SchemaTree, isKeyword, schemaKeywords } from '@kubb/plugin-oas'
+
+import type { Schema, SchemaKeywordBase, SchemaMapper } from '@kubb/plugin-oas'
+
+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().int()' : 'z.number().int()',
+      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 | boolean) => `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,
+  writeOnly: 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'])
+}
+
+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 | { dates?: boolean; strings?: boolean; numbers?: boolean }
+}
+
+export function parse({ parent, current, siblings }: SchemaTree, 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: current.args[0] as Schema, siblings }, options)
+    }
+    if (Array.isArray(current.args) && !current.args.length) {
+      return ''
+    }
+
+    return zodKeywordMapper.union(
+      sort(current.args)
+        .map((schema, _index, siblings) => parse({ parent: current, current: schema, siblings }, 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, _index, siblings) => parse({ parent: current, current: schema, siblings }, 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, _index, siblings) => parse({ parent: current, current: schemas, siblings }, options))
+        .filter(Boolean),
+      current.args.min,
+      current.args.max,
+    )
+  }
+
+  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) => ({
+            keyword: schemaKeywords.const,
+            args: schema,
+          }))
+          .map((schema, _index, siblings) => {
+            return parse({ parent: current, current: schema, siblings }, options)
+          })
+          .filter(Boolean),
+      )
+    }
+
+    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)
+        }
+        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, siblings) => {
+            return parse({ parent: current, current: schema, siblings }, options)
+          })
+          .filter(Boolean)
+          .join('')}`
+      })
+      .join(',')
+
+    const additionalProperties = current.args?.additionalProperties?.length
+      ? current.args.additionalProperties
+          .map((schema, _index, siblings) => parse({ parent: current, current: schema, siblings }, options))
+          .filter(Boolean)
+          .join('')
+      : 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(
+      current.args.items.map((schema, _index, siblings) => parse({ parent: current, current: schema, siblings }, 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()))
+    }
+
+    if (current.args.format === 'boolean' && current.args.value !== undefined) {
+      return zodKeywordMapper.const(current.args.value)
+    }
+    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(shouldCoerce(options.coercion, 'strings'))
+  }
+
+  if (isKeyword(current, schemaKeywords.number)) {
+    return zodKeywordMapper.number(shouldCoerce(options.coercion, 'numbers'))
+  }
+
+  if (isKeyword(current, schemaKeywords.integer)) {
+    return zodKeywordMapper.integer(shouldCoerce(options.coercion, 'numbers'))
+  }
+
+  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, shouldCoerce(options.coercion, 'dates'))
+  }
+
+  if (isKeyword(current, schemaKeywords.time)) {
+    return zodKeywordMapper.time(current.args.type, shouldCoerce(options.coercion, 'dates'))
+  }
+
+  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 (isKeyword(current, schemaKeywords.optional)) {
+    if (siblings.some((schema) => isKeyword(schema, schemaKeywords.default))) return ''
+
+    return value()
+  }
+
+  if (current.keyword in zodKeywordMapper) {
+    return value()
+  }
+
+  return undefined
+}