zod 3.14.1 → 3.14.4

package/README.md

@@ -3,11 +3,11 @@
   <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/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>
 <a href="https://www.npmjs.com/package/zod" rel="nofollow"><img src="https://img.shields.io/github/stars/colinhacks/zod" alt="stars"></a>
-<a href="./src/__tests__" rel="nofollow"><img src="./coverage.svg" alt="coverage"></a>
 <a href="https://discord.gg/KaSRdyX2vc" rel="nofollow"><img src="https://img.shields.io/discord/893487829802418277?label=Discord&logo=discord&logoColor=white" alt="discord server"></a>
 </p>
 
@@ -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/ZodError.d.ts

@@ -3,6 +3,7 @@ import { Primitive } from "./helpers/typeAliases";
 import { util } from "./helpers/util";
 export declare const ZodIssueCode: {
     invalid_type: "invalid_type";
+    invalid_literal: "invalid_literal";
     custom: "custom";
     invalid_union: "invalid_union";
     invalid_union_discriminator: "invalid_union_discriminator";
@@ -27,6 +28,10 @@ export interface ZodInvalidTypeIssue extends ZodIssueBase {
     expected: ZodParsedType;
     received: ZodParsedType;
 }
+export interface ZodInvalidLiteralIssue extends ZodIssueBase {
+    code: typeof ZodIssueCode.invalid_literal;
+    expected: unknown;
+}
 export interface ZodUnrecognizedKeysIssue extends ZodIssueBase {
     code: typeof ZodIssueCode.unrecognized_keys;
     keys: string[];
@@ -87,7 +92,7 @@ export interface ZodCustomIssue extends ZodIssueBase {
 export declare type DenormalizedError = {
     [k: string]: DenormalizedError | string[];
 };
-export declare type ZodIssueOptionalMessage = ZodInvalidTypeIssue | ZodUnrecognizedKeysIssue | ZodInvalidUnionIssue | ZodInvalidUnionDiscriminatorIssue | ZodInvalidEnumValueIssue | ZodInvalidArgumentsIssue | ZodInvalidReturnTypeIssue | ZodInvalidDateIssue | ZodInvalidStringIssue | ZodTooSmallIssue | ZodTooBigIssue | ZodInvalidIntersectionTypesIssue | ZodNotMultipleOfIssue | ZodCustomIssue;
+export declare type ZodIssueOptionalMessage = ZodInvalidTypeIssue | ZodInvalidLiteralIssue | ZodUnrecognizedKeysIssue | ZodInvalidUnionIssue | ZodInvalidUnionDiscriminatorIssue | ZodInvalidEnumValueIssue | ZodInvalidArgumentsIssue | ZodInvalidReturnTypeIssue | ZodInvalidDateIssue | ZodInvalidStringIssue | ZodTooSmallIssue | ZodTooBigIssue | ZodInvalidIntersectionTypesIssue | ZodNotMultipleOfIssue | ZodCustomIssue;
 export declare type ZodIssue = ZodIssueOptionalMessage & {
     message: string;
 };

package/lib/ZodError.js

@@ -4,6 +4,7 @@ exports.setErrorMap = exports.overrideErrorMap = exports.defaultErrorMap = expor
 const util_1 = require("./helpers/util");
 exports.ZodIssueCode = util_1.util.arrayToEnum([
     "invalid_type",
+    "invalid_literal",
     "custom",
     "invalid_union",
     "invalid_union_discriminator",
@@ -135,6 +136,9 @@ const defaultErrorMap = (issue, _ctx) => {
                 message = `Expected ${issue.expected}, received ${issue.received}`;
             }
             break;
+        case exports.ZodIssueCode.invalid_literal:
+            message = `Invalid literal value, expected ${JSON.stringify(issue.expected)}`;
+            break;
         case exports.ZodIssueCode.unrecognized_keys:
             message = `Unrecognized key(s) in object: ${issue.keys
                 .map((k) => `'${k}'`)

package/lib/benchmarks/string.js

@@ -17,6 +17,8 @@ const manual = (str) => {
     return str;
 };
 const stringSchema = index_1.z.string();
+const optionalStringSchema = index_1.z.string().optional();
+const optionalNullableStringSchema = index_1.z.string().optional().nullable();
 suite
     .add("empty string", () => {
     stringSchema.parse(empty);
@@ -26,6 +28,15 @@ suite
 })
     .add("long string", () => {
     stringSchema.parse(long);
+})
+    .add("optional string", () => {
+    optionalStringSchema.parse(long);
+})
+    .add("nullable string", () => {
+    optionalNullableStringSchema.parse(long);
+})
+    .add("nullable (null) string", () => {
+    optionalNullableStringSchema.parse(null);
 })
     .add("invalid: null", () => {
     try {

package/lib/helpers/parseUtil.d.ts

@@ -42,7 +42,6 @@ export interface ParseContext {
         readonly issues: ZodIssue[];
         readonly contextualErrorMap?: ZodErrorMap;
         readonly async: boolean;
-        readonly typeCache: Map<any, ZodParsedType> | undefined;
     };
     readonly path: ParsePath;
     readonly schemaErrorMap?: ZodErrorMap;

package/lib/index.mjs

@@ -49,6 +49,7 @@ var util;
 
 const ZodIssueCode = util.arrayToEnum([
     "invalid_type",
+    "invalid_literal",
     "custom",
     "invalid_union",
     "invalid_union_discriminator",
@@ -178,6 +179,9 @@ const defaultErrorMap = (issue, _ctx) => {
                 message = `Expected ${issue.expected}, received ${issue.received}`;
             }
             break;
+        case ZodIssueCode.invalid_literal:
+            message = `Invalid literal value, expected ${JSON.stringify(issue.expected)}`;
+            break;
         case ZodIssueCode.unrecognized_keys:
             message = `Unrecognized key(s) in object: ${issue.keys
                 .map((k) => `'${k}'`)
@@ -419,6 +423,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 +490,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;
@@ -530,7 +545,6 @@ class ZodType {
             common: {
                 issues: [],
                 async: (_a = params === null || params === void 0 ? void 0 : params.async) !== null && _a !== void 0 ? _a : false,
-                typeCache: typeof Map !== "undefined" ? new Map() : undefined,
                 contextualErrorMap: params === null || params === void 0 ? void 0 : params.errorMap,
             },
             path: (params === null || params === void 0 ? void 0 : params.path) || [],
@@ -554,7 +568,6 @@ class ZodType {
                 issues: [],
                 contextualErrorMap: params === null || params === void 0 ? void 0 : params.errorMap,
                 async: true,
-                typeCache: typeof Map !== "undefined" ? new Map() : undefined,
             },
             path: (params === null || params === void 0 ? void 0 : params.path) || [],
             schemaErrorMap: this._def.errorMap,
@@ -1308,21 +1321,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);
     }
@@ -1442,19 +1447,19 @@ class ZodObject extends ZodType {
         }
         const { status, ctx } = this._processInputParams(input);
         const { shape, keys: shapeKeys } = this._getCached();
-        const dataKeys = util.objectKeys(ctx.data);
-        const extraKeys = dataKeys.filter((k) => !shapeKeys.includes(k));
+        const extraKeys = [];
+        for (const key in ctx.data) {
+            if (!shapeKeys.includes(key)) {
+                extraKeys.push(key);
+            }
+        }
         const pairs = [];
         for (const key of shapeKeys) {
             const keyValidator = shape[key];
             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 +1494,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 +1990,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 +2042,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 +2088,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 +2182,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));
         }
@@ -2375,9 +2360,8 @@ class ZodLiteral extends ZodType {
         if (input.data !== this._def.value) {
             const ctx = this._getOrReturnCtx(input);
             addIssueToContext(ctx, {
-                code: ZodIssueCode.invalid_type,
-                expected: getParsedType(this._def.value),
-                received: ctx.parsedType,
+                code: ZodIssueCode.invalid_literal,
+                expected: this._def.value,
             });
             return INVALID;
         }
@@ -2632,12 +2616,7 @@ class ZodOptional extends ZodType {
         if (parsedType === ZodParsedType.undefined) {
             return OK(undefined);
         }
-        const { ctx } = this._processInputParams(input);
-        return this._def.innerType._parse({
-            data: ctx.data,
-            path: ctx.path,
-            parent: ctx,
-        });
+        return this._def.innerType._parse(input);
     }
     unwrap() {
         return this._def.innerType;
@@ -2656,12 +2635,7 @@ class ZodNullable extends ZodType {
         if (parsedType === ZodParsedType.null) {
             return OK(null);
         }
-        const { ctx } = this._processInputParams(input);
-        return this._def.innerType._parse({
-            data: ctx.data,
-            path: ctx.path,
-            parent: ctx,
-        });
+        return this._def.innerType._parse(input);
     }
     unwrap() {
         return this._def.innerType;

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>;
@@ -441,7 +437,7 @@ export declare class ZodIntersection<T extends ZodTypeAny, U extends ZodTypeAny>
     static create: <T_1 extends ZodTypeAny, U_1 extends ZodTypeAny>(left: T_1, right: U_1, params?: RawCreateParams) => ZodIntersection<T_1, U_1>;
 }
 export declare type ZodTupleItems = [ZodTypeAny, ...ZodTypeAny[]];
-export declare type AssertArray<T extends any> = T extends any[] ? T : never;
+export declare type AssertArray<T> = T extends any[] ? T : never;
 export declare type OutputTypeOfTuple<T extends ZodTupleItems | []> = AssertArray<{
     [k in keyof T]: T[k] extends ZodType<any, any> ? T[k]["_output"] : never;
 }>;
@@ -532,11 +528,11 @@ export declare class ZodLazy<T extends ZodTypeAny> extends ZodType<output<T>, Zo
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     static create: <T_1 extends ZodTypeAny>(getter: () => T_1, params?: RawCreateParams) => ZodLazy<T_1>;
 }
-export interface ZodLiteralDef<T extends any = any> extends ZodTypeDef {
+export interface ZodLiteralDef<T = any> extends ZodTypeDef {
     value: T;
     typeName: ZodFirstPartyTypeKind.ZodLiteral;
 }
-export declare class ZodLiteral<T extends any> extends ZodType<T, ZodLiteralDef<T>> {
+export declare class ZodLiteral<T> extends ZodType<T, ZodLiteralDef<T>> {
     _parse(input: ParseInput): ParseReturnType<this["_output"]>;
     get value(): T;
     static create: <T_1 extends Primitive>(value: T_1, params?: RawCreateParams) => ZodLiteral<T_1>;

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;
@@ -117,7 +128,6 @@ class ZodType {
             common: {
                 issues: [],
                 async: (_a = params === null || params === void 0 ? void 0 : params.async) !== null && _a !== void 0 ? _a : false,
-                typeCache: typeof Map !== "undefined" ? new Map() : undefined,
                 contextualErrorMap: params === null || params === void 0 ? void 0 : params.errorMap,
             },
             path: (params === null || params === void 0 ? void 0 : params.path) || [],
@@ -141,7 +151,6 @@ class ZodType {
                 issues: [],
                 contextualErrorMap: params === null || params === void 0 ? void 0 : params.errorMap,
                 async: true,
-                typeCache: typeof Map !== "undefined" ? new Map() : undefined,
             },
             path: (params === null || params === void 0 ? void 0 : params.path) || [],
             schemaErrorMap: this._def.errorMap,
@@ -214,6 +223,8 @@ class ZodType {
         });
     }
     optional() {
+        ("");
+        ("asdf");
         return ZodOptional.create(this);
     }
     nullable() {
@@ -909,21 +920,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);
     }
@@ -1044,19 +1047,19 @@ class ZodObject extends ZodType {
         }
         const { status, ctx } = this._processInputParams(input);
         const { shape, keys: shapeKeys } = this._getCached();
-        const dataKeys = util_1.util.objectKeys(ctx.data);
-        const extraKeys = dataKeys.filter((k) => !shapeKeys.includes(k));
+        const extraKeys = [];
+        for (const key in ctx.data) {
+            if (!shapeKeys.includes(key)) {
+                extraKeys.push(key);
+            }
+        }
         const pairs = [];
         for (const key of shapeKeys) {
             const keyValidator = shape[key];
             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 +1095,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 +1595,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 +1648,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 +1695,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 +1790,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));
         }
@@ -1988,9 +1971,8 @@ class ZodLiteral extends ZodType {
         if (input.data !== this._def.value) {
             const ctx = this._getOrReturnCtx(input);
             (0, parseUtil_1.addIssueToContext)(ctx, {
-                code: ZodError_1.ZodIssueCode.invalid_type,
-                expected: (0, parseUtil_1.getParsedType)(this._def.value),
-                received: ctx.parsedType,
+                code: ZodError_1.ZodIssueCode.invalid_literal,
+                expected: this._def.value,
             });
             return parseUtil_1.INVALID;
         }
@@ -2251,12 +2233,7 @@ class ZodOptional extends ZodType {
         if (parsedType === parseUtil_1.ZodParsedType.undefined) {
             return (0, parseUtil_1.OK)(undefined);
         }
-        const { ctx } = this._processInputParams(input);
-        return this._def.innerType._parse({
-            data: ctx.data,
-            path: ctx.path,
-            parent: ctx,
-        });
+        return this._def.innerType._parse(input);
     }
     unwrap() {
         return this._def.innerType;
@@ -2276,12 +2253,7 @@ class ZodNullable extends ZodType {
         if (parsedType === parseUtil_1.ZodParsedType.null) {
             return (0, parseUtil_1.OK)(null);
         }
-        const { ctx } = this._processInputParams(input);
-        return this._def.innerType._parse({
-            data: ctx.data,
-            path: ctx.path,
-            parent: ctx,
-        });
+        return this._def.innerType._parse(input);
     }
     unwrap() {
         return this._def.innerType;

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "zod",
-  "version": "3.14.1",
+  "version": "3.14.4",
   "description": "TypeScript-first schema declaration and validation library with static type inference",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
   "module": "./lib/index.mjs",
+  "dependencies": {},
   "exports": {
     ".": {
       "require": "./lib/index.js",
@@ -41,12 +42,12 @@
     "inference"
   ],
   "scripts": {
-    "check:format": "prettier --check \"src/**/*.ts\" \"deno/lib/**/*.ts\"",
-    "fix:format": "prettier --write \"src/**/*.ts\" \"deno/lib/**/*.ts\"",
-    "check:lint": "eslint --ext .ts ./src",
-    "fix:lint": "eslint --fix --ext .ts ./src",
-    "check": "yarn check:lint && yarn check:format",
-    "fix": "yarn fix:lint && yarn fix:format",
+    "prettier:check": "prettier --check 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",
+    "fix": "yarn lint:fix && yarn prettier:fix",
     "clean": "rm -rf lib/* deno/lib/*",
     "build": "yarn run clean && npm run build:cjs && npm run build:esm && npm run build:deno",
     "build:deno": "node ./deno/build.mjs",
@@ -56,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",
-    "@typescript-eslint/eslint-plugin": "^4.11.1",
-    "@typescript-eslint/parser": "^4.11.1",
+    "@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.5.2"
-  },
-  "husky": {
-    "hooks": {
-      "pre-commit": "lint-staged && yarn build:deno && git add .",
-      "pre-push": "lint-staged && yarn build && yarn test && yarn badge"
-    }
+    "typescript": "^4.6.2"
   },
   "lint-staged": {
-    "*.ts": [
-      "yarn fix:lint",
-      "yarn fix:format"
+    "src/*.ts": [
+      "eslint --cache --fix",
+      "prettier --ignore-unknown --write"
     ]
   }
 }