@kubb/plugin-zod 0.0.0-canary-20241104172400

package/dist/types-L1fXCZAs.d.cts

@@ -0,0 +1,100 @@
+import { PluginFactoryOptions, Output, Group, ResolveNameParams } from '@kubb/core';
+import { SchemaObject } from '@kubb/oas';
+import { ResolvePathOptions, Exclude, Include, Override, Schema, Generator } from '@kubb/plugin-oas';
+
+type Options = {
+    /**
+     * @default 'zod'
+     */
+    output?: Output;
+    /**
+     * Group the Zod schemas based on the provided name.
+     */
+    group?: Group;
+    /**
+     * 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>>;
+    /**
+     * 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;
+    /**
+     * 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>
+     */
+    inferred?: boolean;
+    /**
+     * Use of z.coerce.string() instead of z.string()
+     * can also be an object to enable coercion for dates, strings, and numbers
+     */
+    coercion?: boolean | {
+        dates?: boolean;
+        strings?: boolean;
+        numbers?: boolean;
+    };
+    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;
+    };
+    /**
+     * Define some generators next to the zod generators
+     */
+    generators?: Array<Generator<PluginZod>>;
+};
+type ResolvedOptions = {
+    output: Output;
+    override: NonNullable<Options['override']>;
+    transformers: NonNullable<Options['transformers']>;
+    dateType: NonNullable<Options['dateType']>;
+    unknownType: NonNullable<Options['unknownType']>;
+    typed: NonNullable<Options['typed']>;
+    inferred: NonNullable<Options['inferred']>;
+    mapper: NonNullable<Options['mapper']>;
+    importPath: NonNullable<Options['importPath']>;
+    coercion: NonNullable<Options['coercion']>;
+    operations: NonNullable<Options['operations']>;
+};
+type PluginZod = PluginFactoryOptions<'plugin-zod', Options, ResolvedOptions, never, ResolvePathOptions>;
+
+export type { Options as O, PluginZod as P };

package/dist/types-L1fXCZAs.d.ts

@@ -0,0 +1,100 @@
+import { PluginFactoryOptions, Output, Group, ResolveNameParams } from '@kubb/core';
+import { SchemaObject } from '@kubb/oas';
+import { ResolvePathOptions, Exclude, Include, Override, Schema, Generator } from '@kubb/plugin-oas';
+
+type Options = {
+    /**
+     * @default 'zod'
+     */
+    output?: Output;
+    /**
+     * Group the Zod schemas based on the provided name.
+     */
+    group?: Group;
+    /**
+     * 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>>;
+    /**
+     * 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;
+    /**
+     * 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>
+     */
+    inferred?: boolean;
+    /**
+     * Use of z.coerce.string() instead of z.string()
+     * can also be an object to enable coercion for dates, strings, and numbers
+     */
+    coercion?: boolean | {
+        dates?: boolean;
+        strings?: boolean;
+        numbers?: boolean;
+    };
+    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;
+    };
+    /**
+     * Define some generators next to the zod generators
+     */
+    generators?: Array<Generator<PluginZod>>;
+};
+type ResolvedOptions = {
+    output: Output;
+    override: NonNullable<Options['override']>;
+    transformers: NonNullable<Options['transformers']>;
+    dateType: NonNullable<Options['dateType']>;
+    unknownType: NonNullable<Options['unknownType']>;
+    typed: NonNullable<Options['typed']>;
+    inferred: NonNullable<Options['inferred']>;
+    mapper: NonNullable<Options['mapper']>;
+    importPath: NonNullable<Options['importPath']>;
+    coercion: NonNullable<Options['coercion']>;
+    operations: NonNullable<Options['operations']>;
+};
+type PluginZod = PluginFactoryOptions<'plugin-zod', Options, ResolvedOptions, never, ResolvePathOptions>;
+
+export type { Options as O, PluginZod as P };

package/package.json

@@ -0,0 +1,95 @@
+{
+  "name": "@kubb/plugin-zod",
+  "version": "0.0.0-canary-20241104172400",
+  "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"
+    },
+    "./generators": {
+      "import": "./dist/generators.js",
+      "require": "./dist/generators.cjs",
+      "default": "./dist/generators.cjs"
+    },
+    "./components": {
+      "import": "./dist/components.js",
+      "require": "./dist/components.cjs",
+      "default": "./dist/components.cjs"
+    },
+    "./package.json": "./package.json",
+    "./*": "./*"
+  },
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "./dist/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "components": [
+        "./dist/components.d.ts"
+      ],
+      "generators": [
+        "./dist/generators.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "src",
+    "dist",
+    "!/**/**.test.**",
+    "!/**/__tests__/**"
+  ],
+  "dependencies": {
+    "@kubb/core": "0.0.0-canary-20241104172400",
+    "@kubb/fs": "0.0.0-canary-20241104172400",
+    "@kubb/oas": "0.0.0-canary-20241104172400",
+    "@kubb/parser-ts": "0.0.0-canary-20241104172400",
+    "@kubb/plugin-oas": "0.0.0-canary-20241104172400",
+    "@kubb/plugin-ts": "0.0.0-canary-20241104172400",
+    "@kubb/react": "0.0.0-canary-20241104172400"
+  },
+  "devDependencies": {
+    "tsup": "^8.3.5",
+    "@kubb/config-ts": "0.0.0-canary-20241104172400",
+    "@kubb/config-tsup": "0.0.0-canary-20241104172400"
+  },
+  "peerDependencies": {
+    "@kubb/react": "0.0.0-canary-20241104172400"
+  },
+  "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/components/Operations.tsx

@@ -0,0 +1,49 @@
+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'
+
+type Props = {
+  name: string
+  operations: Array<{ operation: Operation; data: SchemaNames }>
+}
+
+export function Operations({ name, operations }: Props): KubbNode {
+  const operationsJSON = operations.reduce(
+    (prev, acc) => {
+      prev[`"${acc.operation.getOperationId()}"`] = acc.data
+
+      return prev
+    },
+    {} as Record<string, unknown>,
+  )
+
+  const pathsJSON = operations.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 (
+    <>
+      <File.Source name={name} isExportable isIndexable>
+        <Const export name={name} asConst>
+          {`{${transformers.stringifyObject(operationsJSON)}}`}
+        </Const>
+      </File.Source>
+      <File.Source name={'paths'} isExportable isIndexable>
+        <Const export name={'paths'} asConst>
+          {`{${transformers.stringifyObject(pathsJSON)}}`}
+        </Const>
+      </File.Source>
+    </>
+  )
+}

package/src/components/Zod.tsx

@@ -0,0 +1,68 @@
+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((schema, _index, siblings) =>
+      parserZod.parse({ parent: undefined, current: schema, siblings }, { 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('') || 'z.undefined()'}
+        </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

@@ -0,0 +1,2 @@
+export { Operations } from './Operations.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__/coercion.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__/coercionDates.ts

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

package/src/generators/__snapshots__/coercionNumbers.ts

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

package/src/generators/__snapshots__/coercionStrings.ts

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

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.lazy(() => createPets201);

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.lazy(() => createPets201);

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,15 @@
+import { z } from "zod";
+
+ export const listPetsQueryParams = z.object({ "limit": z.string().describe("How many items to return at one time (max 100)").optional(), "offset": z.number().int().default(0) }).optional();
+
+ /**
+ * @description A paged array of pets
+ */
+export const listPets200 = z.lazy(() => pets);
+
+ /**
+ * @description unexpected error
+ */
+export const listPetsError = z.lazy(() => error);
+
+ export const listPetsQueryResponse = z.lazy(() => listPets200);

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,43 @@
+import { listPetsQueryResponse, listPetsQueryParams, createPetsMutationRequest, createPetsMutationResponse, showPetByIdQueryResponse, showPetByIdPathParams } from "./showPetById";
+
+ export const operations = { "listPets": {
+        request: undefined,
+        parameters: {
+            path: undefined,
+            query: listPetsQueryParams,
+            header: undefined
+        },
+        responses: {
+            default: listPetsQueryResponse
+        },
+        errors: {}
+    }, "createPets": {
+        request: createPetsMutationRequest,
+        parameters: {
+            path: undefined,
+            query: undefined,
+            header: undefined
+        },
+        responses: {
+            default: createPetsMutationResponse
+        },
+        errors: {}
+    }, "showPetById": {
+        request: undefined,
+        parameters: {
+            path: showPetByIdPathParams,
+            query: undefined,
+            header: undefined
+        },
+        responses: {
+            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(),
+})