@kubb/plugin-zod 3.0.0-alpha.9 → 3.0.0-beta.1

package/src/components/Operations.tsx

@@ -1,29 +1,17 @@
-import { useOperationManager, useOperations } from '@kubb/plugin-oas/hooks'
-import { Const, File, useApp } from '@kubb/react'
+import type { SchemaNames } from '@kubb/plugin-oas/hooks'
+import { Const, File } from '@kubb/react'
 
 import transformers from '@kubb/core/transformers'
 import type { HttpMethod, Operation } from '@kubb/oas'
 import type { KubbNode } from '@kubb/react/types'
-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[]
+type Props = {
+  name: string
+  operations: Array<{ operation: Operation; data: SchemaNames }>
 }
 
-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(
+export function Operations({ name, operations }: Props): KubbNode {
+  const operationsJSON = operations.reduce(
     (prev, acc) => {
       prev[`"${acc.operation.getOperationId()}"`] = acc.data
 
@@ -32,7 +20,7 @@ function Template({ operationsName, pathsName, operations }: TemplateProps): Kub
     {} as Record<string, unknown>,
   )
 
-  const pathsJSON = transformedOperations.reduce(
+  const pathsJSON = operations.reduce(
     (prev, acc) => {
       prev[`"${acc.operation.path}"`] = {
         ...(prev[`"${acc.operation.path}"`] || ({} as Record<HttpMethod, string>)),
@@ -46,90 +34,16 @@ function Template({ operationsName, pathsName, operations }: TemplateProps): Kub
 
   return (
     <>
-      <File.Source name={operationsName} isExportable isIndexable>
-        <Const export name={operationsName} asConst>
+      <File.Source name={name} isExportable isIndexable>
+        <Const export name={name} asConst>
           {`{${transformers.stringifyObject(operationsJSON)}}`}
         </Const>
       </File.Source>
-      <File.Source name={pathsName} isExportable isIndexable>
-        <Const export name={pathsName} asConst>
+      <File.Source name={'paths'} isExportable isIndexable>
+        <Const export name={'paths'} asConst>
           {`{${transformers.stringifyObject(pathsJSON)}}`}
         </Const>
       </File.Source>
     </>
   )
 }
-
-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 }]) => {
-      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<FileMeta> baseName={file.baseName} path={file.path} meta={file.meta}>
-      {mode === 'split' && imports}
-      {children}
-    </File>
-  )
-}
-
-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

package/src/components/Zod.tsx

@@ -0,0 +1,66 @@
+import transformers from '@kubb/core/transformers'
+import { type Schema, schemaKeywords } from '@kubb/plugin-oas'
+import { isKeyword } from '@kubb/plugin-oas'
+import { Const, File, Type } from '@kubb/react'
+import type { KubbNode } from '@kubb/react/types'
+import * as parserZod from '../parser/index.ts'
+import type { PluginZod } from '../types.ts'
+
+type Props = {
+  name: string
+  typeName?: string
+  inferTypeName?: string
+  tree: Array<Schema>
+  description?: string
+  coercion: PluginZod['resolvedOptions']['coercion']
+  mapper: PluginZod['resolvedOptions']['mapper']
+  keysToOmit?: string[]
+}
+
+export function Zod({ name, typeName, tree, inferTypeName, mapper, coercion, keysToOmit, description }: Props): KubbNode {
+  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, keysToOmit, typeName: typeName, description, mapper, coercion }))
+    .filter(Boolean)
+    .join('')
+
+  const suffix = output.endsWith('.nullable()') ? '.unwrap().and' : '.and'
+
+  return (
+    <>
+      <File.Source name={name} isExportable isIndexable>
+        <Const
+          export
+          name={name}
+          JSDoc={{
+            comments: [description ? `@description ${transformers.jsStringEscape(description)}` : undefined].filter(Boolean),
+          }}
+        >
+          {[
+            output,
+            keysToOmit?.length ? `${suffix}(z.object({ ${keysToOmit.map((key) => `${key}: z.never()`).join(',')} }))` : undefined,
+            typeName ? ` as z.ZodType<${typeName}>` : '',
+          ]
+            .filter(Boolean)
+            .join('') || ''}
+        </Const>
+      </File.Source>
+      {inferTypeName && (
+        <File.Source name={inferTypeName} isExportable isIndexable isTypeOnly>
+          <Type export name={inferTypeName}>
+            {`z.infer<typeof ${name}>`}
+          </Type>
+        </File.Source>
+      )}
+    </>
+  )
+}

package/src/components/index.ts

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

package/src/generators/__snapshots__/anyof.ts

@@ -0,0 +1,3 @@
+import { z } from "zod";
+
+ export const test = z.union([z.object({ "propertyA": z.string() }).strict(), z.object({ "propertyA": z.string(), "propertyB": z.string() }).strict()]);

package/src/generators/__snapshots__/createPet.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+
+ /**
+ * @description Null response
+ */
+export const createPets201 = z.any();
+
+ /**
+ * @description unexpected error
+ */
+export const createPetsError = z.lazy(() => error);
+
+ export const createPetsMutationRequest = z.object({ "name": z.string(), "tag": z.string() });
+
+ export const createPetsMutationResponse = z.any();

package/src/generators/__snapshots__/createPetWithUnknownTypeAny.ts

@@ -0,0 +1,13 @@
+/**
+ * @description Null response
+ */
+export const createPetWithUnknownTypeAny = z.any()
+
+/**
+ * @description unexpected error
+ */
+export const createPetWithUnknownTypeAny = z.lazy(() => createPetWithUnknownTypeAny)
+
+export const createPetWithUnknownTypeAny = z.object({ name: z.string(), tag: z.string() })
+
+export const createPetWithUnknownTypeAny = z.any()

package/src/generators/__snapshots__/createPetWithUnknownTypeUnknown.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+
+ /**
+ * @description Null response
+ */
+export const createPets201 = z.unknown();
+
+ /**
+ * @description unexpected error
+ */
+export const createPetsError = z.lazy(() => error);
+
+ export const createPetsMutationRequest = z.object({ "name": z.string(), "tag": z.string() });
+
+ export const createPetsMutationResponse = z.unknown();

package/src/generators/__snapshots__/deletePet.ts

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

package/src/generators/__snapshots__/discriminator.ts

@@ -0,0 +1,3 @@
+import { z } from "zod";
+
+ export const advanced = z.union([z.lazy(() => enumerationValueSpecificationDto).and(z.object({ "type": z.enum(["enum", "range", "regex", "slider"]) })), z.lazy(() => rangeValueSpecificationDto).and(z.object({ "type": z.enum(["enum", "range", "regex", "slider"]) })), z.lazy(() => regexValueSpecificationDto).and(z.object({ "type": z.enum(["enum", "range", "regex", "slider"]) })), z.lazy(() => sliderValueSpecificationDto).and(z.object({ "type": z.enum(["enum", "range", "regex", "slider"]) }))]);

package/src/generators/__snapshots__/enumBooleanLiteral.ts

@@ -0,0 +1,3 @@
+import { z } from "zod";
+
+ export const enumBooleanLiteral = z.union([z.literal(true), z.literal(false)]);

package/src/generators/__snapshots__/enumNamesType.ts

@@ -0,0 +1,3 @@
+import { z } from "zod";
+
+ export const enumNamesType = z.enum(["0", "1"]);

package/src/generators/__snapshots__/enumNullable.ts

@@ -0,0 +1,3 @@
+import { z } from "zod";
+
+ export const enumNullable = z.enum(["Pending", "Received"]).nullable();

package/src/generators/__snapshots__/enumSingleLiteral.ts

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

package/src/generators/__snapshots__/enumVarNamesType.ts

@@ -0,0 +1,3 @@
+import { z } from "zod";
+
+ export const enumVarNamesType = z.union([z.literal(0), z.literal(1)]);

package/src/generators/__snapshots__/example.ts

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

package/src/generators/__snapshots__/getPets.ts

@@ -0,0 +1,18 @@
+import { z } from "zod";
+
+ export const listPetsQueryParams = z.object({ "limit": z.string().describe("How many items to return at one time (max 100)").optional() }).optional();
+
+ /**
+ * @description A paged array of pets
+ */
+export const listPets200 = z.lazy(() => pets);
+
+ /**
+ * @description unexpected error
+ */
+export const listPetsError = z.lazy(() => error);
+
+ /**
+ * @description A paged array of pets
+ */
+export const listPetsQueryResponse = z.lazy(() => pets);

package/src/generators/__snapshots__/mixedValueTypeConst.ts

@@ -0,0 +1,6 @@
+import { z } from "zod";
+
+ /**
+ * @description This probably should fail miserably
+ */
+export const mixedValueTypeConst = z.object({ "foobar": z.literal("foobar") }).describe("This probably should fail miserably");

package/src/generators/__snapshots__/nullableString.ts

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

package/src/generators/__snapshots__/nullableStringUuid.ts

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

package/src/generators/__snapshots__/nullableStringWithAnyOf.ts

@@ -0,0 +1,3 @@
+import { z } from "zod";
+
+ export const nullableStringWithAnyOf = z.union([z.string(), z.null()]);

package/src/generators/__snapshots__/numberValueConst.ts

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

package/src/generators/__snapshots__/oneof.ts

@@ -0,0 +1,3 @@
+import { z } from "zod";
+
+ export const test = z.union([z.object({ "propertyA": z.string().optional() }), z.object({ "propertyA": z.string().optional() })]);

package/src/generators/__snapshots__/operations.ts

@@ -0,0 +1,46 @@
+import { listPetsQueryResponse, listPetsQueryParams, createPetsMutationRequest, createPetsMutationResponse, showPetByIdQueryResponse, showPetByIdPathParams } from "./showPetById";
+
+ export const operations = { "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: {}
+    }, "showPetById": {
+        request: undefined,
+        parameters: {
+            path: showPetByIdPathParams,
+            query: undefined,
+            header: undefined
+        },
+        responses: {
+            200: showPetByIdQueryResponse,
+            default: showPetByIdQueryResponse
+        },
+        errors: {}
+    } } as const;
+
+ export const paths = { "/pets": {
+        get: operations["listPets"],
+        post: operations["createPets"]
+    }, "/pets/{petId}": {
+        get: operations["showPetById"]
+    } } as const;

package/src/generators/__snapshots__/optionalPetInfer.ts

@@ -0,0 +1,5 @@
+import { z } from "zod";
+
+ export const optionalPet = z.object({ "id": z.number().int().optional(), "name": z.string().optional(), "tag": z.string().optional() });
+
+ export type OptionalPet = z.infer<typeof optionalPet>;

package/src/generators/__snapshots__/optionalPetTyped.ts

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

package/src/generators/__snapshots__/order.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.date().optional(), "status": z.enum(["placed", "approved", "delivered"]).describe("Order Status").optional(), "complete": z.boolean().optional() });

package/src/generators/__snapshots__/orderDateTyeString.ts

@@ -0,0 +1,10 @@
+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__/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,18 @@
+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);
+
+ /**
+ * @description Expected response to a valid request
+ */
+export const showPetByIdQueryResponse = z.lazy(() => pet);

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>
+    )
+  },
+})