@kubb/plugin-zod 3.0.0-alpha.0

package/dist/index.d.ts

@@ -0,0 +1,156 @@
+import * as _kubb_core from '@kubb/core';
+import { PluginFactoryOptions, ResolveNameParams } from '@kubb/core';
+import * as KubbFile from '@kubb/fs/types';
+import { SchemaObject } from '@kubb/oas';
+import { ResolvePathOptions, Exclude, Include, Override, Schema } from '@kubb/plugin-oas';
+import { O as Operations } from './Operations-BlQtRP31.js';
+import '@kubb/react';
+import 'react';
+
+type Templates = {
+    operations?: typeof Operations.templates | false;
+};
+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']>;
+};
+type PluginZod = PluginFactoryOptions<'plugin-zod', Options, ResolvedOptions, never, ResolvePathOptions>;
+declare module '@kubb/core' {
+    interface _Register {
+        ['@kubb/plugin-zod']: PluginZod;
+    }
+}
+
+declare const pluginZodName = "plugin-zod";
+declare const pluginZod: (options?: Options | undefined) => _kubb_core.UserPluginWithLifeCycle<PluginZod>;
+
+/**
+ * @deprecated Use `import { pluginZod } from '@kubb/plugin-zod'` instead
+ */
+declare const definePluginDefault: (options?: Options | undefined) => _kubb_core.UserPluginWithLifeCycle<PluginZod>;
+/**
+ * @deprecated Use `import { pluginZod } from '@kubb/plugin-zod'` instead
+ */
+declare const definePlugin: (options?: Options | undefined) => _kubb_core.UserPluginWithLifeCycle<PluginZod>;
+
+export { type PluginZod, definePluginDefault as default, definePlugin, pluginZod, pluginZodName };

package/dist/index.js

@@ -0,0 +1,16 @@
+import {
+  pluginZod,
+  pluginZodName
+} from "./chunk-OXCOZC6T.js";
+
+// src/index.ts
+var definePluginDefault = pluginZod;
+var definePlugin = pluginZod;
+var src_default = definePluginDefault;
+export {
+  src_default as default,
+  definePlugin,
+  pluginZod,
+  pluginZodName
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import { pluginZod } from './plugin.ts'\n\nexport { pluginZod, pluginZodName } from './plugin.ts'\nexport type { PluginZod } from './types.ts'\n\n/**\n * @deprecated Use `import { pluginZod } from '@kubb/plugin-zod'` instead\n */\nconst definePluginDefault = pluginZod\n/**\n * @deprecated Use `import { pluginZod } from '@kubb/plugin-zod'` instead\n */\nexport const definePlugin = pluginZod\n\nexport default definePluginDefault\n"],"mappings":";;;;;;AAQA,IAAM,sBAAsB;AAIrB,IAAM,eAAe;AAE5B,IAAO,cAAQ;","names":[]}

package/package.json

@@ -0,0 +1,97 @@
+{
+  "name": "@kubb/plugin-zod",
+  "version": "3.0.0-alpha.0",
+  "description": "Generator plugin-zod",
+  "keywords": [
+    "typescript",
+    "plugins",
+    "kubb",
+    "codegen",
+    "swagger",
+    "openapi"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/kubb-labs/kubb.git",
+    "directory": "packages/plugin-zod"
+  },
+  "license": "MIT",
+  "author": "Stijn Van Hulle <stijn@stijnvanhulle.be",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.cjs"
+    },
+    "./components": {
+      "import": "./dist/components.js",
+      "require": "./dist/components.cjs",
+      "default": "./dist/components.cjs"
+    },
+    "./oas": {
+      "types": "./dist/oas.d.ts"
+    },
+    "./package.json": "./package.json",
+    "./*": "./*"
+  },
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "./dist/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "components": [
+        "./dist/components.d.ts"
+      ],
+      "oas": [
+        "./dist/oas.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "src",
+    "dist",
+    "!/**/**.test.**",
+    "!/**/__tests__/**"
+  ],
+  "dependencies": {
+    "@kubb/core": "3.0.0-alpha.0",
+    "@kubb/oas": "3.0.0-alpha.0",
+    "@kubb/fs": "3.0.0-alpha.0",
+    "@kubb/parser-ts": "3.0.0-alpha.0",
+    "@kubb/plugin-oas": "3.0.0-alpha.0",
+    "@kubb/react": "3.0.0-alpha.0",
+    "@kubb/types": "3.0.0-alpha.0"
+  },
+  "devDependencies": {
+    "@types/react": "^18.3.3",
+    "prettier": "^3.3.3",
+    "react": "^18.3.1",
+    "tsup": "^8.2.4",
+    "@kubb/config-biome": "3.0.0-alpha.0",
+    "@kubb/config-ts": "3.0.0-alpha.0",
+    "@kubb/config-tsup": "3.0.0-alpha.0"
+  },
+  "peerDependencies": {
+    "@kubb/react": "3.0.0-alpha.0"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "build": "tsup",
+    "clean": "npx rimraf ./dist",
+    "lint": "bun biome lint .",
+    "lint:fix": "bun biome lint --apply-unsafe .",
+    "release": "pnpm publish --no-git-check",
+    "release:canary": "bash ../../.github/canary.sh && node ../../scripts/build.js canary && pnpm publish --no-git-check",
+    "start": "tsup --watch",
+    "test": "vitest --passWithNoTests",
+    "typecheck": "tsc -p ./tsconfig.json --noEmit --emitDeclarationOnly false"
+  }
+}

package/src/OperationGenerator.tsx

@@ -0,0 +1,54 @@
+import { OperationGenerator as Generator } from '@kubb/plugin-oas'
+import { Oas } from '@kubb/plugin-oas/components'
+import { App, createRoot } from '@kubb/react'
+
+import { OperationSchema } from './components/OperationSchema.tsx'
+
+import type { Operation } from '@kubb/oas'
+import type { OperationMethodResult, OperationsByMethod } from '@kubb/plugin-oas'
+import { Operations } from './components/Operations.tsx'
+import type { FileMeta, PluginZod } from './types.ts'
+
+export class OperationGenerator extends Generator<PluginZod['resolvedOptions'], PluginZod> {
+  async all(operations: Operation[], _operationsByMethod: OperationsByMethod): OperationMethodResult<FileMeta> {
+    const { pluginManager, oas, plugin, mode } = this.context
+
+    const root = createRoot({
+      logger: pluginManager.logger,
+    })
+
+    const templates = {
+      operations: Operations.templates,
+      ...this.options.templates,
+    }
+
+    root.render(
+      <App pluginManager={pluginManager} plugin={plugin} mode={mode}>
+        <Oas oas={oas} operations={operations} generator={this}>
+          {templates.operations && <Operations.File templates={templates.operations} />}
+        </Oas>
+      </App>,
+    )
+
+    return root.files
+  }
+
+  async operation(operation: Operation, options: PluginZod['resolvedOptions']): OperationMethodResult<FileMeta> {
+    const { oas, pluginManager, plugin, mode } = this.context
+
+    const root = createRoot({
+      logger: pluginManager.logger,
+    })
+    root.render(
+      <App pluginManager={pluginManager} plugin={{ ...plugin, options }} mode={mode}>
+        <Oas oas={oas} operations={[operation]} generator={this}>
+          <Oas.Operation operation={operation}>
+            <OperationSchema.File />
+          </Oas.Operation>
+        </Oas>
+      </App>,
+    )
+
+    return root.files
+  }
+}

package/src/SchemaGenerator.tsx

@@ -0,0 +1,31 @@
+import type { SchemaObject } from '@kubb/oas'
+import { SchemaGenerator as Generator } from '@kubb/plugin-oas'
+import type { SchemaMethodResult } from '@kubb/plugin-oas'
+import { Oas } from '@kubb/plugin-oas/components'
+import { App, createRoot } from '@kubb/react'
+import { Schema } from './components/Schema.tsx'
+import type { FileMeta, PluginZod } from './types.ts'
+
+export class SchemaGenerator extends Generator<PluginZod['resolvedOptions'], PluginZod> {
+  async schema(name: string, schema: SchemaObject, options: PluginZod['resolvedOptions']): SchemaMethodResult<FileMeta> {
+    const { oas, pluginManager, plugin, mode, output } = this.context
+
+    const root = createRoot({
+      logger: pluginManager.logger,
+    })
+
+    const tree = this.parse({ schema, name })
+
+    root.render(
+      <App pluginManager={pluginManager} plugin={{ ...plugin, options }} mode={mode}>
+        <Oas oas={oas}>
+          <Oas.Schema name={name} value={schema} tree={tree}>
+            <Schema.File />
+          </Oas.Schema>
+        </Oas>
+      </App>,
+    )
+
+    return root.files
+  }
+}

package/src/components/OperationSchema.tsx

@@ -0,0 +1,66 @@
+import { schemaKeywords } from '@kubb/plugin-oas'
+import { Oas } from '@kubb/plugin-oas/components'
+import { useOas, useOperation, useOperationManager } from '@kubb/plugin-oas/hooks'
+import { File, Parser, useApp } from '@kubb/react'
+
+import { SchemaGenerator } from '../SchemaGenerator.tsx'
+
+import type { OperationSchema as OperationSchemaType } from '@kubb/plugin-oas'
+import type { ReactNode } from 'react'
+import type { FileMeta, PluginZod } from '../types.ts'
+import { Schema } from './Schema.tsx'
+
+type Props = {
+  description?: string
+  keysToOmit?: string[]
+}
+
+export function OperationSchema({ description, keysToOmit }: Props): ReactNode {
+  return <Schema keysToOmit={keysToOmit} withTypeAnnotation={false} description={description} />
+}
+
+type FileProps = {}
+
+OperationSchema.File = function ({}: FileProps): ReactNode {
+  const { pluginManager, plugin, mode } = useApp<PluginZod>()
+  const { getSchemas, getFile } = useOperationManager()
+  const oas = useOas()
+  const operation = useOperation()
+
+  const file = getFile(operation)
+  const schemas = getSchemas(operation)
+  const generator = new SchemaGenerator(plugin.options, {
+    oas,
+    plugin,
+    pluginManager,
+    mode,
+    override: plugin.options.override,
+  })
+
+  const items = [schemas.pathParams, schemas.queryParams, schemas.headerParams, schemas.statusCodes, schemas.request, schemas.response].flat().filter(Boolean)
+
+  const mapItem = ({ 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 = generator.parse({ schema, name })
+
+    return (
+      <Oas.Schema key={i} name={name} value={schema} tree={[...tree, optional ? { keyword: schemaKeywords.optional } : undefined].filter(Boolean)}>
+        {mode === 'split' && <Oas.Schema.Imports extName={plugin.options.extName} />}
+        <File.Source>
+          <OperationSchema description={description} keysToOmit={keysToOmit} />
+        </File.Source>
+      </Oas.Schema>
+    )
+  }
+
+  return (
+    <Parser language="typescript">
+      <File<FileMeta> baseName={file.baseName} path={file.path} meta={file.meta}>
+        <File.Import name={['z']} path={plugin.options.importPath} />
+        {items.map(mapItem)}
+      </File>
+    </Parser>
+  )
+}

package/src/components/Operations.tsx

@@ -0,0 +1,133 @@
+import { useOperationManager, useOperations } from '@kubb/plugin-oas/hooks'
+import { Const, File, Parser, useApp } from '@kubb/react'
+
+import transformers from '@kubb/core/transformers'
+import type { HttpMethod, Operation } from '@kubb/oas'
+import type { KubbNode } from '@kubb/react'
+import type { ComponentProps, ComponentType } from 'react'
+import type { FileMeta, PluginZod } from '../types.ts'
+
+type TemplateProps = {
+  /**
+   * Name of the function
+   */
+  operationsName: string
+  /**
+   * Name of the function
+   */
+  pathsName: string
+  operations: Operation[]
+}
+
+function Template({ operationsName, pathsName, operations }: TemplateProps): KubbNode {
+  const { groupSchemasByName } = useOperationManager()
+  const transformedOperations = operations.map((operation) => ({ operation, data: groupSchemasByName(operation, { type: 'function' }) }))
+
+  const operationsJSON = transformedOperations.reduce(
+    (prev, acc) => {
+      prev[`"${acc.operation.getOperationId()}"`] = acc.data
+
+      return prev
+    },
+    {} as Record<string, unknown>,
+  )
+
+  const pathsJSON = transformedOperations.reduce(
+    (prev, acc) => {
+      prev[`"${acc.operation.path}"`] = {
+        ...(prev[`"${acc.operation.path}"`] || ({} as Record<HttpMethod, string>)),
+        [acc.operation.method]: `operations["${acc.operation.getOperationId()}"]`,
+      }
+
+      return prev
+    },
+    {} as Record<string, Record<HttpMethod, string>>,
+  )
+
+  return (
+    <>
+      <Const export name={operationsName} asConst>
+        {`{${transformers.stringifyObject(operationsJSON)}}`}
+      </Const>
+      <Const export name={pathsName} asConst>
+        {`{${transformers.stringifyObject(pathsJSON)}}`}
+      </Const>
+    </>
+  )
+}
+
+type RootTemplateProps = {
+  children?: React.ReactNode
+}
+
+function RootTemplate({ children }: RootTemplateProps) {
+  const {
+    mode,
+    pluginManager,
+    plugin: {
+      key: pluginKey,
+      options: { extName },
+    },
+  } = useApp<PluginZod>()
+  const { getFile } = useOperationManager()
+  const operations = useOperations()
+  const { groupSchemasByName } = useOperationManager()
+  const transformedOperations = operations.map((operation) => ({ operation, data: groupSchemasByName(operation, { type: 'function' }) }))
+
+  const file = pluginManager.getFile({ name: 'operations', extName: '.ts', pluginKey })
+  const imports = Object.entries(transformedOperations)
+    .map(([_key, { data, operation }], index) => {
+      const names = [data.request, ...Object.values(data.responses), ...Object.values(data.parameters)].filter(Boolean)
+
+      return <File.Import key={index} extName={extName} name={names} root={file.path} path={getFile(operation).path} />
+    })
+    .filter(Boolean)
+
+  return (
+    <Parser language="typescript">
+      <File<FileMeta> baseName={file.baseName} path={file.path} meta={file.meta} exportable={false}>
+        {mode === 'split' && imports}
+        <File.Source>{children}</File.Source>
+      </File>
+    </Parser>
+  )
+}
+
+const defaultTemplates = { default: Template, root: RootTemplate } as const
+
+type Templates = Partial<typeof defaultTemplates>
+
+type Props = {
+  /**
+   * This will make it possible to override the default behaviour.
+   */
+  Template?: ComponentType<ComponentProps<typeof Template>>
+}
+
+export function Operations({ Template = defaultTemplates.default }: Props): KubbNode {
+  const operations = useOperations()
+
+  return <Template operationsName="operations" pathsName="paths" operations={operations} />
+}
+
+type FileProps = {
+  /**
+   * This will make it possible to override the default behaviour.
+   */
+  templates?: Templates
+}
+
+Operations.File = function (props: FileProps): KubbNode {
+  const templates = { ...defaultTemplates, ...props.templates }
+
+  const Template = templates.default
+  const RootTemplate = templates.root
+
+  return (
+    <RootTemplate>
+      <Operations Template={Template} />
+    </RootTemplate>
+  )
+}
+
+Operations.templates = defaultTemplates