@kubb/plugin-zod 3.0.0-alpha.14 → 3.0.0-alpha.16

package/src/generators/zodGenerator.tsx

@@ -0,0 +1,114 @@
+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}>
+        <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 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}>
+        <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/plugin.ts

@@ -9,8 +9,8 @@ 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']
@@ -26,11 +26,11 @@ export const pluginZod = createPlugin<PluginZod>((options) => {
     dateType = 'string',
     unknownType = 'any',
     typed = false,
-    typedSchema = false,
     mapper = {},
-    templates,
+    operations = false,
     importPath = 'zod',
     coercion = false,
+    inferred = false,
   } = options
   const template = group?.output ? group.output : `${output.path}/{{tag}}Controller`
 
@@ -47,16 +47,13 @@ export const pluginZod = createPlugin<PluginZod>((options) => {
       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) {
@@ -113,7 +110,7 @@ export const pluginZod = createPlugin<PluginZod>((options) => {
         output: output.path,
       })
 
-      const schemaFiles = await schemaGenerator.build(zodParser)
+      const schemaFiles = await schemaGenerator.build(...[zodGenerator, operations ? operationsGenerator : undefined].filter(Boolean))
       await this.addFile(...schemaFiles)
 
       const operationGenerator = new OperationGenerator(this.plugin.options, {
@@ -127,7 +124,7 @@ export const pluginZod = createPlugin<PluginZod>((options) => {
         mode,
       })
 
-      const operationFiles = await operationGenerator.build(zodParser)
+      const operationFiles = await operationGenerator.build(...[zodGenerator, operations ? operationsGenerator : undefined].filter(Boolean))
       await this.addFile(...operationFiles)
 
       if (this.config.output.exportType) {

package/src/types.ts

@@ -2,11 +2,6 @@ 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?: {
@@ -64,30 +59,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,35 +86,46 @@ 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()
    */
   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
+  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
+  }
 }
 
 type ResolvedOptions = {
-  extName: KubbFile.Extname | undefined
+  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']>
+  operations: NonNullable<Options['coercion']>
 }
 
 export type FileMeta = {

package/dist/Operations-BG26e_MW.d.cts

@@ -1,47 +0,0 @@
-import { Operation } from '@kubb/oas';
-import { KubbNode } from '@kubb/react/types';
-import { ComponentType, ComponentProps } from 'react';
-
-type TemplateProps = {
-    /**
-     * Name of the function
-     */
-    operationsName: string;
-    /**
-     * Name of the function
-     */
-    pathsName: string;
-    operations: Operation[];
-};
-declare function Template({ operationsName, pathsName, operations }: TemplateProps): KubbNode;
-type RootTemplateProps = {
-    children?: React.ReactNode;
-};
-declare function RootTemplate({ children }: RootTemplateProps): JSX.Element;
-declare const defaultTemplates: {
-    readonly default: typeof Template;
-    readonly root: typeof RootTemplate;
-};
-type Templates = Partial<typeof defaultTemplates>;
-type Props = {
-    /**
-     * This will make it possible to override the default behaviour.
-     */
-    Template?: ComponentType<ComponentProps<typeof Template>>;
-};
-declare function Operations({ Template }: Props): KubbNode;
-declare namespace Operations {
-    var File: (props: FileProps) => KubbNode;
-    var templates: {
-        readonly default: typeof Template;
-        readonly root: typeof RootTemplate;
-    };
-}
-type FileProps = {
-    /**
-     * This will make it possible to override the default behaviour.
-     */
-    templates?: Templates;
-};
-
-export { Operations as O };

package/dist/Operations-BG26e_MW.d.ts

@@ -1,47 +0,0 @@
-import { Operation } from '@kubb/oas';
-import { KubbNode } from '@kubb/react/types';
-import { ComponentType, ComponentProps } from 'react';
-
-type TemplateProps = {
-    /**
-     * Name of the function
-     */
-    operationsName: string;
-    /**
-     * Name of the function
-     */
-    pathsName: string;
-    operations: Operation[];
-};
-declare function Template({ operationsName, pathsName, operations }: TemplateProps): KubbNode;
-type RootTemplateProps = {
-    children?: React.ReactNode;
-};
-declare function RootTemplate({ children }: RootTemplateProps): JSX.Element;
-declare const defaultTemplates: {
-    readonly default: typeof Template;
-    readonly root: typeof RootTemplate;
-};
-type Templates = Partial<typeof defaultTemplates>;
-type Props = {
-    /**
-     * This will make it possible to override the default behaviour.
-     */
-    Template?: ComponentType<ComponentProps<typeof Template>>;
-};
-declare function Operations({ Template }: Props): KubbNode;
-declare namespace Operations {
-    var File: (props: FileProps) => KubbNode;
-    var templates: {
-        readonly default: typeof Template;
-        readonly root: typeof RootTemplate;
-    };
-}
-type FileProps = {
-    /**
-     * This will make it possible to override the default behaviour.
-     */
-    templates?: Templates;
-};
-
-export { Operations as O };