@kubb/plugin-zod 3.0.0-alpha.0

package/src/plugin.ts

@@ -0,0 +1,167 @@
+import path from 'node:path'
+
+import { FileManager, PluginManager, createPlugin } from '@kubb/core'
+import { camelCase, pascalCase } from '@kubb/core/transformers'
+import { renderTemplate } from '@kubb/core/utils'
+import { pluginOasName } from '@kubb/plugin-oas'
+import { getGroupedByTagFiles } from '@kubb/plugin-oas/utils'
+import { pluginTsName } from '@kubb/plugin-ts'
+
+import { OperationGenerator } from './OperationGenerator.tsx'
+import { SchemaGenerator } from './SchemaGenerator.tsx'
+
+import type { Plugin } from '@kubb/core'
+import type { PluginOas as SwaggerPluginOptions } from '@kubb/plugin-oas'
+import { Operations } from './components/Operations.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' },
+    group,
+    exclude = [],
+    include,
+    override = [],
+    transformers = {},
+    dateType = 'string',
+    unknownType = 'any',
+    typed = false,
+    typedSchema = false,
+    mapper = {},
+    templates,
+    importPath = 'zod',
+    coercion = false,
+  } = options
+  const template = group?.output ? group.output : `${output.path}/{{tag}}Controller`
+
+  return {
+    name: pluginZodName,
+    options: {
+      extName: output.extName,
+      transformers,
+      include,
+      exclude,
+      override,
+      typed,
+      typedSchema,
+      dateType,
+      unknownType,
+      mapper,
+      importPath,
+      coercion,
+      templates: {
+        operations: Operations.templates,
+        ...templates,
+      },
+    },
+    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 (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 (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) {
+      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 writeFile(path, source) {
+      if (!path.endsWith('.ts') || !source) {
+        return
+      }
+
+      return this.fileManager.write(path, source, { sanity: false })
+    },
+    async buildStart() {
+      const [swaggerPlugin]: [Plugin<SwaggerPluginOptions>] = PluginManager.getDependedPlugins<SwaggerPluginOptions>(this.plugins, [pluginOasName])
+
+      const oas = await swaggerPlugin.api.getOas()
+      const root = path.resolve(this.config.root, this.config.output.path)
+      const mode = FileManager.getMode(path.resolve(root, output.path))
+
+      const schemaGenerator = new SchemaGenerator(this.plugin.options, {
+        oas,
+        pluginManager: this.pluginManager,
+        plugin: this.plugin,
+        contentType: swaggerPlugin.api.contentType,
+        include: undefined,
+        override,
+        mode,
+        output: output.path,
+      })
+
+      const schemaFiles = await schemaGenerator.build()
+      await this.addFile(...schemaFiles)
+
+      const operationGenerator = new OperationGenerator(this.plugin.options, {
+        oas,
+        pluginManager: this.pluginManager,
+        plugin: this.plugin,
+        contentType: swaggerPlugin.api.contentType,
+        exclude,
+        include,
+        override,
+        mode,
+      })
+
+      const operationFiles = await operationGenerator.build()
+      await this.addFile(...operationFiles)
+    },
+    async buildEnd() {
+      if (this.config.output.write === false) {
+        return
+      }
+
+      const root = path.resolve(this.config.root, this.config.output.path)
+
+      if (group?.type === 'tag') {
+        const rootFiles = await getGroupedByTagFiles({
+          logger: this.logger,
+          files: this.fileManager.files,
+          plugin: this.plugin,
+          template,
+          exportAs: group.exportAs || '{{tag}}Schemas',
+          root,
+          output,
+        })
+
+        await this.addFile(...rootFiles)
+      }
+
+      await this.fileManager.addIndexes({
+        root,
+        output,
+        meta: { pluginKey: this.plugin.key },
+        logger: this.logger,
+      })
+    },
+  }
+})

package/src/types.ts

@@ -0,0 +1,151 @@
+import type { Plugin, PluginFactoryOptions, ResolveNameParams } from '@kubb/core'
+import type * as KubbFile from '@kubb/fs/types'
+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
+}
+
+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
+  }
+  /**
+   * 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
+  }
+  /**
+   * 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>>
+  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
+   */
+  templates?: Partial<Templates>
+  /**
+   * Choose to use `date` or `datetime` as JavaScript `Date` instead of `string`.
+   * False will fallback on a simple z.string() format
+   * @default 'string' 'stringOffset' will become the default in Kubb v3
+   */
+  dateType?: false | 'string' | 'stringOffset' | 'stringLocal' | 'date'
+  /**
+   * Which type to use when the Swagger/OpenAPI file is not providing more information
+   * @default 'any'
+   */
+  unknownType?: 'any' | 'unknown'
+  /**
+   * Use TypeScript(`@kubb/plugin-ts`) to add type annotation.
+   */
+  typed?: boolean
+  /**
+   * Return Zod generated schema as type with z.infer<TYPE>
+   */
+  typedSchema?: boolean
+  /**
+   * Use of z.coerce.string() instead of z.string()
+   */
+  coercion?: boolean
+  /**
+   * 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'
+   */
+  importPath?: string
+}
+
+type ResolvedOptions = {
+  extName: KubbFile.Extname | undefined
+  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>
+  mapper: NonNullable<Options['mapper']>
+  importPath: NonNullable<Options['importPath']>
+  coercion: NonNullable<Options['coercion']>
+}
+
+export type FileMeta = {
+  pluginKey?: Plugin['key']
+  tag?: string
+}
+
+export type PluginZod = PluginFactoryOptions<'plugin-zod', Options, ResolvedOptions, never, ResolvePathOptions>
+
+declare module '@kubb/core' {
+  export interface _Register {
+    ['@kubb/plugin-zod']: PluginZod
+  }
+}