zod 3.14.2 → 3.14.3

package/README.md

@@ -3,7 +3,7 @@
   <h1 align="center">Zod</h1>
 </p>
 <p align="center">
-<a href="https://github.com/edgedb/edgedb-js/actions"><img src="https://github.com/colinhacks/zod/workflows/test.yml/badge.svg?event=push&branch=master" alt="Zod CI status" /></a>
+<a href="https://github.com/edgedb/edgedb-js/actions"><img src="https://github.com/colinhacks/zod/actions/workflows/test.yml/badge.svg?event=push&branch=master" alt="Zod CI status" /></a>
 <a href="https://twitter.com/colinhacks" rel="nofollow"><img src="https://img.shields.io/badge/created%20by-@colinhacks-4BBAAB.svg" alt="Created by Colin McDonnell"></a>
 <a href="https://opensource.org/licenses/MIT" rel="nofollow"><img src="https://img.shields.io/github/license/colinhacks/zod" alt="License"></a>
 <a href="https://www.npmjs.com/package/zod" rel="nofollow"><img src="https://img.shields.io/npm/dw/zod.svg" alt="npm"></a>
@@ -94,8 +94,10 @@ These docs have been translated into [Chinese](./README_ZH.md).
   - [.promise](#promise)
   - [.or](#or)
   - [.and](#and)
-- [Type inference](#type-inference)
-- [Errors](#errors)
+- [Guides and concepts](#guides-and-concepts)
+  - [Type inference](#type-inference)
+  - [Writing generic functions](#writing-generic-functions)
+  - [Error handling](#error-handling)
 - [Comparison](#comparison)
   - [Joi](#joi)
   - [Yup](#yup)
@@ -241,6 +243,8 @@ There are a growing number of tools that are built atop or support Zod natively!
 - [`soly`](https://github.com/mdbetancourt/soly): Create CLI applications with zod.
 - [`graphql-codegen-typescript-validation-schema`](https://github.com/Code-Hex/graphql-codegen-typescript-validation-schema): GraphQL Code Generator plugin to generate form validation schema from your GraphQL schema
 - [`zod-prisma`](https://github.com/CarterGrimmeisen/zod-prisma): Generate Zod schemas from your Prisma schema.
+- [`fastify-type-provider-zod`](https://github.com/turkerdev/fastify-type-provider-zod): Create Fastify type providers from Zod schemas
+- [`Supervillain`](https://github.com/Southclaws/supervillain): Generate Zod schemas from your Go structs
 
 ### Form integrations
 
@@ -1687,7 +1691,9 @@ z.object({ name: z.string() }).and(z.object({ age: z.number() })); // { name: st
 z.intersection(z.object({ name: z.string() }), z.object({ age: z.number() }));
 ```
 
-# Type inference
+# Guides and concepts
+
+## Type inference
 
 You can extract the TypeScript type of any schema with `z.infer<typeof mySchema>` .
 
@@ -1716,16 +1722,72 @@ type output = z.output<typeof stringToNumber>; // number
 type inferred = z.infer<typeof stringToNumber>; // number
 ```
 
-# Errors
+## Writing generic functions
+
+When attempting to write a functions that accepts a Zod schemas as an input, it's common to try something like this:
+
+```ts
+function makeSchemaOptional<T>(schema: z.ZodType<T>) {
+  return schema.optional();
+}
+```
+
+This approach has some issues. The `schema` variable in this function is typed as an instance of `ZodType`, which is an abstract class that all Zod schemas inherit from. This approach loses type information, namely _which subclass_ the input actually is.
+
+```ts
+const arg = makeSchemaOptional(z.string());
+arg.unwrap();
+```
+
+A better approach is for the generate parameter to refer to _the schema as a whole_.
+
+```ts
+function makeSchemaOptional<T extends z.ZodTypeAny>(schema: T) {
+  return schema.optional();
+}
+```
+
+> `ZodTypeAny` is just a shorthand for `ZodType<any, any, any>`, a type that is broad enough to match any Zod schema.
+
+As you can see, `schema` is now fully and properly typed.
+
+```ts
+const arg = makeSchemaOptional(z.string());
+arg.unwrap(); // ZodString
+```
+
+### Restricting valid schemas
+
+The `ZodType` class has three generic parameters.
+
+```ts
+class ZodType<
+  Output,
+  Def extends ZodTypeDef = ZodTypeDef,
+  Input = Output
+> { ... }
+```
+
+By contraining these in your generic input, you can limit what schemas are allowable as inputs to your function:
+
+```ts
+function makeSchemaOptional<T extends z.ZodType<string>>(schema: T) {
+  return schema.optional();
+}
+
+makeSchemaOptional(z.string());
+// works fine
+
+makeSchemaOptional(z.number());
+// Error: 'ZodNumber' is not assignable to parameter of type 'ZodType<string, ZodTypeDef, string>'
+```
+
+## Error handling
 
 Zod provides a subclass of Error called `ZodError`. ZodErrors contain an `issues` array containing detailed information about the validation problems.
 
 ```ts
-const data = z
-  .object({
-    name: z.string(),
-  })
-  .safeParse({ name: 12 });
+const data = z.object({ name: z.string() }).safeParse({ name: 12 });
 
 if (!data.success) {
   data.error.issues;

package/lib/index.mjs

@@ -419,6 +419,17 @@ var errorUtil;
     errorUtil.toString = (message) => typeof message === "string" ? message : message === null || message === void 0 ? void 0 : message.message;
 })(errorUtil || (errorUtil = {}));
 
+class ParseInputLazyPath {
+    constructor(parent, value, path, key) {
+        this.parent = parent;
+        this.data = value;
+        this._path = path;
+        this._key = key;
+    }
+    get path() {
+        return this._path.concat(this._key);
+    }
+}
 const handleResult = (ctx, result) => {
     if (isValid(result)) {
         return { success: true, data: result.value };
@@ -475,8 +486,8 @@ class ZodType {
         this.transform = this.transform.bind(this);
         this.default = this.default.bind(this);
         this.describe = this.describe.bind(this);
-        this.isOptional = this.isOptional.bind(this);
         this.isNullable = this.isNullable.bind(this);
+        this.isOptional = this.isOptional.bind(this);
     }
     get description() {
         return this._def.description;
@@ -1308,21 +1319,13 @@ class ZodArray extends ZodType {
         }
         if (ctx.common.async) {
             return Promise.all(ctx.data.map((item, i) => {
-                return def.type._parseAsync({
-                    parent: ctx,
-                    path: [...ctx.path, i],
-                    data: item,
-                });
+                return def.type._parseAsync(new ParseInputLazyPath(ctx, item, ctx.path, i));
             })).then((result) => {
                 return ParseStatus.mergeArray(status, result);
             });
         }
         const result = ctx.data.map((item, i) => {
-            return def.type._parseSync({
-                parent: ctx,
-                path: [...ctx.path, i],
-                data: item,
-            });
+            return def.type._parseSync(new ParseInputLazyPath(ctx, item, ctx.path, i));
         });
         return ParseStatus.mergeArray(status, result);
     }
@@ -1450,11 +1453,7 @@ class ZodObject extends ZodType {
             const value = ctx.data[key];
             pairs.push({
                 key: { status: "valid", value: key },
-                value: keyValidator._parse({
-                    parent: ctx,
-                    data: value,
-                    path: [...ctx.path, key],
-                }),
+                value: keyValidator._parse(new ParseInputLazyPath(ctx, value, ctx.path, key)),
                 alwaysSet: key in ctx.data,
             });
         }
@@ -1489,7 +1488,7 @@ class ZodObject extends ZodType {
                 const value = ctx.data[key];
                 pairs.push({
                     key: { status: "valid", value: key },
-                    value: catchall._parse({ parent: ctx, path: [...ctx.path, key], data: value } //, ctx.child(key), value, getParsedType(value)
+                    value: catchall._parse(new ParseInputLazyPath(ctx, value, ctx.path, key) //, ctx.child(key), value, getParsedType(value)
                     ),
                     alwaysSet: key in ctx.data,
                 });
@@ -1985,11 +1984,7 @@ class ZodTuple extends ZodType {
             const schema = this._def.items[itemIndex] || this._def.rest;
             if (!schema)
                 return null;
-            return schema._parse({
-                data: item,
-                path: [...ctx.path, itemIndex],
-                parent: ctx,
-            });
+            return schema._parse(new ParseInputLazyPath(ctx, item, ctx.path, itemIndex));
         })
             .filter((x) => !!x); // filter nulls
         if (ctx.common.async) {
@@ -2041,16 +2036,8 @@ class ZodRecord extends ZodType {
         const valueType = this._def.valueType;
         for (const key in ctx.data) {
             pairs.push({
-                key: keyType._parse({
-                    data: key,
-                    path: [...ctx.path, key],
-                    parent: ctx,
-                }),
-                value: valueType._parse({
-                    data: ctx.data[key],
-                    path: [...ctx.path, key],
-                    parent: ctx,
-                }),
+                key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, key)),
+                value: valueType._parse(new ParseInputLazyPath(ctx, ctx.data[key], ctx.path, key)),
             });
         }
         if (ctx.common.async) {
@@ -2095,16 +2082,8 @@ class ZodMap extends ZodType {
         const valueType = this._def.valueType;
         const pairs = [...ctx.data.entries()].map(([key, value], index) => {
             return {
-                key: keyType._parse({
-                    data: key,
-                    path: [...ctx.path, index, "key"],
-                    parent: ctx,
-                }),
-                value: valueType._parse({
-                    data: value,
-                    path: [...ctx.path, index, "value"],
-                    parent: ctx,
-                }),
+                key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, [index, "key"])),
+                value: valueType._parse(new ParseInputLazyPath(ctx, value, ctx.path, [index, "value"])),
             };
         });
         if (ctx.common.async) {
@@ -2197,7 +2176,7 @@ class ZodSet extends ZodType {
             }
             return { status: status.value, value: parsedSet };
         }
-        const elements = [...ctx.data.values()].map((item, i) => valueType._parse({ data: item, path: [...ctx.path, i], parent: ctx }));
+        const elements = [...ctx.data.values()].map((item, i) => valueType._parse(new ParseInputLazyPath(ctx, item, ctx.path, i)));
         if (ctx.common.async) {
             return Promise.all(elements).then((elements) => finalizeSet(elements));
         }

package/lib/types.d.ts

@@ -44,7 +44,7 @@ export declare type SafeParseError<Input> = {
     error: ZodError<Input>;
 };
 export declare type SafeParseReturnType<Input, Output> = SafeParseSuccess<Output> | SafeParseError<Input>;
-export declare abstract class ZodType<Output, Def extends ZodTypeDef = ZodTypeDef, Input = Output> {
+export declare abstract class ZodType<Output = any, Def extends ZodTypeDef = ZodTypeDef, Input = Output> {
     readonly _type: Output;
     readonly _output: Output;
     readonly _input: Input;
@@ -65,10 +65,6 @@ export declare abstract class ZodType<Output, Def extends ZodTypeDef = ZodTypeDe
     safeParseAsync(data: unknown, params?: Partial<ParseParams>): Promise<SafeParseReturnType<Input, Output>>;
     /** Alias of safeParseAsync */
     spa: (data: unknown, params?: Partial<ParseParams> | undefined) => Promise<SafeParseReturnType<Input, Output>>;
-    /** The .is method has been removed in Zod 3. For details see https://github.com/colinhacks/zod/tree/v3. */
-    is: never;
-    /** The .check method has been removed in Zod 3. For details see https://github.com/colinhacks/zod/tree/v3. */
-    check: never;
     refine<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, RefinedOutput, RefinedOutput>;
     refine(check: (arg: Output) => unknown | Promise<unknown>, message?: string | CustomErrorParams | ((arg: Output) => CustomErrorParams)): ZodEffects<this, Output, Input>;
     refinement<RefinedOutput extends Output>(check: (arg: Output) => arg is RefinedOutput, refinementData: IssueData | ((arg: Output, ctx: RefinementCtx) => IssueData)): ZodEffects<this, RefinedOutput, RefinedOutput>;

package/lib/types.js

@@ -6,6 +6,17 @@ const errorUtil_1 = require("./helpers/errorUtil");
 const parseUtil_1 = require("./helpers/parseUtil");
 const util_1 = require("./helpers/util");
 const ZodError_1 = require("./ZodError");
+class ParseInputLazyPath {
+    constructor(parent, value, path, key) {
+        this.parent = parent;
+        this.data = value;
+        this._path = path;
+        this._key = key;
+    }
+    get path() {
+        return this._path.concat(this._key);
+    }
+}
 const handleResult = (ctx, result) => {
     if ((0, parseUtil_1.isValid)(result)) {
         return { success: true, data: result.value };
@@ -62,8 +73,8 @@ class ZodType {
         this.transform = this.transform.bind(this);
         this.default = this.default.bind(this);
         this.describe = this.describe.bind(this);
-        this.isOptional = this.isOptional.bind(this);
         this.isNullable = this.isNullable.bind(this);
+        this.isOptional = this.isOptional.bind(this);
     }
     get description() {
         return this._def.description;
@@ -214,6 +225,8 @@ class ZodType {
         });
     }
     optional() {
+        ("");
+        ("asdf");
         return ZodOptional.create(this);
     }
     nullable() {
@@ -909,21 +922,13 @@ class ZodArray extends ZodType {
         }
         if (ctx.common.async) {
             return Promise.all(ctx.data.map((item, i) => {
-                return def.type._parseAsync({
-                    parent: ctx,
-                    path: [...ctx.path, i],
-                    data: item,
-                });
+                return def.type._parseAsync(new ParseInputLazyPath(ctx, item, ctx.path, i));
             })).then((result) => {
                 return parseUtil_1.ParseStatus.mergeArray(status, result);
             });
         }
         const result = ctx.data.map((item, i) => {
-            return def.type._parseSync({
-                parent: ctx,
-                path: [...ctx.path, i],
-                data: item,
-            });
+            return def.type._parseSync(new ParseInputLazyPath(ctx, item, ctx.path, i));
         });
         return parseUtil_1.ParseStatus.mergeArray(status, result);
     }
@@ -1052,11 +1057,7 @@ class ZodObject extends ZodType {
             const value = ctx.data[key];
             pairs.push({
                 key: { status: "valid", value: key },
-                value: keyValidator._parse({
-                    parent: ctx,
-                    data: value,
-                    path: [...ctx.path, key],
-                }),
+                value: keyValidator._parse(new ParseInputLazyPath(ctx, value, ctx.path, key)),
                 alwaysSet: key in ctx.data,
             });
         }
@@ -1092,7 +1093,7 @@ class ZodObject extends ZodType {
                 const value = ctx.data[key];
                 pairs.push({
                     key: { status: "valid", value: key },
-                    value: catchall._parse({ parent: ctx, path: [...ctx.path, key], data: value } //, ctx.child(key), value, getParsedType(value)
+                    value: catchall._parse(new ParseInputLazyPath(ctx, value, ctx.path, key) //, ctx.child(key), value, getParsedType(value)
                     ),
                     alwaysSet: key in ctx.data,
                 });
@@ -1592,11 +1593,7 @@ class ZodTuple extends ZodType {
             const schema = this._def.items[itemIndex] || this._def.rest;
             if (!schema)
                 return null;
-            return schema._parse({
-                data: item,
-                path: [...ctx.path, itemIndex],
-                parent: ctx,
-            });
+            return schema._parse(new ParseInputLazyPath(ctx, item, ctx.path, itemIndex));
         })
             .filter((x) => !!x); // filter nulls
         if (ctx.common.async) {
@@ -1649,16 +1646,8 @@ class ZodRecord extends ZodType {
         const valueType = this._def.valueType;
         for (const key in ctx.data) {
             pairs.push({
-                key: keyType._parse({
-                    data: key,
-                    path: [...ctx.path, key],
-                    parent: ctx,
-                }),
-                value: valueType._parse({
-                    data: ctx.data[key],
-                    path: [...ctx.path, key],
-                    parent: ctx,
-                }),
+                key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, key)),
+                value: valueType._parse(new ParseInputLazyPath(ctx, ctx.data[key], ctx.path, key)),
             });
         }
         if (ctx.common.async) {
@@ -1704,16 +1693,8 @@ class ZodMap extends ZodType {
         const valueType = this._def.valueType;
         const pairs = [...ctx.data.entries()].map(([key, value], index) => {
             return {
-                key: keyType._parse({
-                    data: key,
-                    path: [...ctx.path, index, "key"],
-                    parent: ctx,
-                }),
-                value: valueType._parse({
-                    data: value,
-                    path: [...ctx.path, index, "value"],
-                    parent: ctx,
-                }),
+                key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, [index, "key"])),
+                value: valueType._parse(new ParseInputLazyPath(ctx, value, ctx.path, [index, "value"])),
             };
         });
         if (ctx.common.async) {
@@ -1807,7 +1788,7 @@ class ZodSet extends ZodType {
             }
             return { status: status.value, value: parsedSet };
         }
-        const elements = [...ctx.data.values()].map((item, i) => valueType._parse({ data: item, path: [...ctx.path, i], parent: ctx }));
+        const elements = [...ctx.data.values()].map((item, i) => valueType._parse(new ParseInputLazyPath(ctx, item, ctx.path, i)));
         if (ctx.common.async) {
             return Promise.all(elements).then((elements) => finalizeSet(elements));
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod",
-  "version": "3.14.2",
+  "version": "3.14.3",
   "description": "TypeScript-first schema declaration and validation library with static type inference",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
@@ -43,7 +43,7 @@
   ],
   "scripts": {
     "prettier:check": "prettier --check src/**/*.ts deno/lib/**/*.ts --no-error-on-unmatched-pattern",
-    "prettier:fix": "prettier --write src/**/*.ts deno/lib/**/*.ts --no-error-on-unmatched-pattern",
+    "prettier:fix": "prettier --write src/**/*.ts deno/lib/**/*.ts --ignore-unknown --no-error-on-unmatched-pattern",
     "lint:check": "eslint --ext .ts ./src",
     "lint:fix": "eslint --fix --ext .ts ./src",
     "check": "yarn lint:check && yarn prettier:check",
@@ -57,51 +57,43 @@
     "rollup": "rollup --config rollup.config.js",
     "test": "jest --coverage",
     "test:deno": "cd deno && deno test",
-    "badge": "make-coverage-badge --output-path ./coverage.svg",
     "prepublishOnly": "npm run test && npm run build && npm run build:deno",
     "play": "nodemon -e ts -w . -x ts-node src/playground.ts --project tsconfig.json --trace-warnings",
     "depcruise": "depcruise -c .dependency-cruiser.js src",
-    "benchmark": "ts-node src/benchmarks/index.ts"
+    "benchmark": "ts-node src/benchmarks/index.ts",
+    "prepare": "husky install"
   },
   "devDependencies": {
     "@rollup/plugin-typescript": "^8.2.0",
     "@types/benchmark": "^2.1.0",
     "@types/jest": "^26.0.17",
-    "@types/node": "^14.14.10",
+    "@types/node": "14",
     "@typescript-eslint/eslint-plugin": "^5.15.0",
     "@typescript-eslint/parser": "^5.15.0",
     "benchmark": "^2.1.4",
     "dependency-cruiser": "^9.19.0",
-    "eslint": "^7.15.0",
-    "eslint-config-prettier": "^7.1.0",
-    "eslint-plugin-ban": "^1.5.2",
-    "eslint-plugin-import": "^2.22.1",
+    "eslint": "^8.11.0",
+    "eslint-config-prettier": "^8.5.0",
+    "eslint-plugin-ban": "^1.6.0",
+    "eslint-plugin-import": "^2.25.4",
     "eslint-plugin-simple-import-sort": "^7.0.0",
-    "eslint-plugin-unused-imports": "^1.1.0",
-    "husky": "^4.3.4",
-    "jest": "^26.6.3",
-    "lint-staged": "^10.5.3",
-    "make-coverage-badge": "^1.2.0",
-    "nodemon": "^2.0.2",
-    "prettier": "^2.2.1",
-    "rollup": "^2.42.1",
-    "rollup-plugin-uglify": "^6.0.4",
-    "table": "^6.8.0",
-    "ts-jest": "^26.4.4",
-    "ts-node": "^9.1.0",
+    "eslint-plugin-unused-imports": "^2.0.0",
+    "husky": "^7.0.4",
+    "jest": "^27.5.1",
+    "lint-staged": "^12.3.7",
+    "nodemon": "^2.0.15",
+    "prettier": "^2.6.0",
+    "pretty-quick": "^3.1.3",
+    "rollup": "^2.70.1",
+    "ts-jest": "^27.1.3",
+    "ts-node": "^10.7.0",
     "tslib": "^2.3.1",
     "typescript": "^4.6.2"
   },
-  "husky": {
-    "hooks": {
-      "pre-commit": "lint-staged",
-      "pre-push": "lint-staged"
-    }
-  },
   "lint-staged": {
-    "*.ts": [
-      "yarn lint:fix",
-      "yarn prettier:fix"
+    "src/*.ts": [
+      "eslint --cache --fix",
+      "prettier --ignore-unknown --write"
     ]
   }
 }