zod 3.14.5 → 3.16.0

package/README.md

@@ -293,6 +293,9 @@ There are a growing number of tools that are built atop or support Zod natively!
 - [`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
 - [`zod-to-openapi`](https://github.com/asteasolutions/zod-to-openapi): Generate full OpenAPI (Swagger) docs from Zod, including schemas, endpoints & parameters
+- [`prisma-zod-generator`](https://github.com/omar-dulaimi/prisma-zod-generator): Emit Zod schemas from your Prisma schema.
+- [`prisma-trpc-generator`](https://github.com/omar-dulaimi/prisma-trpc-generator): Emit fully implemented tRPC routers and their validation schemas using Zod.
+- [`nestjs-graphql-zod`](https://github.com/incetarik/nestjs-graphql-zod): Generates NestJS GraphQL model classes from Zod schemas dynamically and provides GraphQL method decorators working with Zod schemas.
 
 ### Form integrations
 
@@ -1353,7 +1356,7 @@ All Zod schemas contain certain methods.
 
 Given any Zod schema, you can call its `.parse` method to check `data` is valid. If it is, a value is returned with full type information! Otherwise, an error is thrown.
 
-> IMPORTANT: In Zod 2 and Zod 1.11+, the value returned by `.parse` is a _deep clone_ of the variable you passed in. This was also the case in zod@1.4 and earlier.
+> IMPORTANT: The value returned by `.parse` is a _deep clone_ of the variable you passed in.
 
 ```ts
 const stringSchema = z.string();
@@ -1602,7 +1605,28 @@ const stringToNumber = z.string().transform((val) => myString.length);
 stringToNumber.parse("string"); // => 6
 ```
 
-> ⚠️ Transform functions must not throw. Make sure to use refinements before the transform to make sure the input can be parsed by the transform.
+> ⚠️ Transform functions must not throw. Make sure to use refinements before the transform or addIssue within the transform to make sure the input can be parsed by the transform.
+
+#### Validating during transform
+
+Similar to `superRefine`, `transform` can optionally take a `ctx`. This allows you to simultaneously
+validate and transform the value, which can be simpler than chaining `refine` and `validate`. 
+When calling `ctx.addIssue` make sure to still return a value of the correct type otherwise the inferred type will include `undefined`.
+
+```ts
+const Strings = z
+  .string()
+  .transform((val, ctx) => {
+    const parsed = parseInt(val);
+    if (isNaN(parsed)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "Not a number",
+      });
+    }
+    return parsed;
+  });
+```
 
 #### Chaining order
 

package/lib/ZodError.d.ts

@@ -54,6 +54,7 @@ export interface ZodInvalidUnionDiscriminatorIssue extends ZodIssueBase {
     options: Primitive[];
 }
 export interface ZodInvalidEnumValueIssue extends ZodIssueBase {
+    received: string | number;
     code: typeof ZodIssueCode.invalid_enum_value;
     options: (string | number)[];
 }
@@ -110,7 +111,9 @@ export declare type ZodFormattedError<T, U = string> = {
     _errors: U[];
 } & (T extends [any, ...any[]] ? {
     [K in keyof T]?: ZodFormattedError<T[K]>;
-} : T extends any[] ? ZodFormattedError<T[number]>[] : T extends object ? {
+} : T extends any[] ? {
+    [k: number]: ZodFormattedError<T[number]>;
+} : T extends object ? {
     [K in keyof T]?: ZodFormattedError<T[K]>;
 } : unknown);
 export declare type inferFormattedError<T extends ZodType<any, any, any>, U = string> = ZodFormattedError<TypeOf<T>, U>;

package/lib/ZodError.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.setErrorMap = exports.overrideErrorMap = exports.defaultErrorMap = exports.ZodError = exports.quotelessJson = exports.ZodIssueCode = void 0;
+const parseUtil_1 = require("./helpers/parseUtil");
 const util_1 = require("./helpers/util");
 exports.ZodIssueCode = util_1.util.arrayToEnum([
     "invalid_type",
@@ -75,14 +76,14 @@ class ZodError extends Error {
                         const el = issue.path[i];
                         const terminal = i === issue.path.length - 1;
                         if (!terminal) {
-                            if (typeof el === "string") {
-                                curr[el] = curr[el] || { _errors: [] };
-                            }
-                            else if (typeof el === "number") {
-                                const errorArray = [];
-                                errorArray._errors = [];
-                                curr[el] = curr[el] || errorArray;
-                            }
+                            curr[el] = curr[el] || { _errors: [] };
+                            // if (typeof el === "string") {
+                            //   curr[el] = curr[el] || { _errors: [] };
+                            // } else if (typeof el === "number") {
+                            //   const errorArray: any = [];
+                            //   errorArray._errors = [];
+                            //   curr[el] = curr[el] || errorArray;
+                            // }
                         }
                         else {
                             curr[el] = curr[el] || { _errors: [] };
@@ -133,7 +134,7 @@ const defaultErrorMap = (issue, _ctx) => {
     let message;
     switch (issue.code) {
         case exports.ZodIssueCode.invalid_type:
-            if (issue.received === "undefined") {
+            if (issue.received === parseUtil_1.ZodParsedType.undefined) {
                 message = "Required";
             }
             else {
@@ -144,22 +145,16 @@ const defaultErrorMap = (issue, _ctx) => {
             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}'`)
-                .join(", ")}`;
+            message = `Unrecognized key(s) in object: ${util_1.util.joinValues(issue.keys, ", ")}`;
             break;
         case exports.ZodIssueCode.invalid_union:
             message = `Invalid input`;
             break;
         case exports.ZodIssueCode.invalid_union_discriminator:
-            message = `Invalid discriminator value. Expected ${issue.options
-                .map((val) => (typeof val === "string" ? `'${val}'` : val))
-                .join(" | ")}`;
+            message = `Invalid discriminator value. Expected ${util_1.util.joinValues(issue.options)}`;
             break;
         case exports.ZodIssueCode.invalid_enum_value:
-            message = `Invalid enum value. Expected ${issue.options
-                .map((val) => (typeof val === "string" ? `'${val}'` : val))
-                .join(" | ")}`;
+            message = `Invalid enum value. Expected ${util_1.util.joinValues(issue.options)}, received '${issue.received}'`;
             break;
         case exports.ZodIssueCode.invalid_arguments:
             message = `Invalid function arguments`;

package/lib/helpers/util.d.ts

@@ -15,4 +15,5 @@ export declare namespace util {
     }>;
     type noUndefined<T> = T extends undefined ? never : T;
     const isInteger: NumberConstructor["isInteger"];
+    function joinValues<T extends any[]>(array: T, separator?: string): string;
 }

package/lib/helpers/util.js

@@ -48,4 +48,10 @@ var util;
     util.isInteger = typeof Number.isInteger === "function"
         ? (val) => Number.isInteger(val) // eslint-disable-line ban/ban
         : (val) => typeof val === "number" && isFinite(val) && Math.floor(val) === val;
+    function joinValues(array, separator = " | ") {
+        return array
+            .map((val) => (typeof val === "string" ? `'${val}'` : val))
+            .join(separator);
+    }
+    util.joinValues = joinValues;
 })(util = exports.util || (exports.util = {}));

package/lib/index.mjs

@@ -45,6 +45,12 @@ var util;
     util.isInteger = typeof Number.isInteger === "function"
         ? (val) => Number.isInteger(val) // eslint-disable-line ban/ban
         : (val) => typeof val === "number" && isFinite(val) && Math.floor(val) === val;
+    function joinValues(array, separator = " | ") {
+        return array
+            .map((val) => (typeof val === "string" ? `'${val}'` : val))
+            .join(separator);
+    }
+    util.joinValues = joinValues;
 })(util || (util = {}));
 
 const ZodIssueCode = util.arrayToEnum([
@@ -119,14 +125,14 @@ class ZodError extends Error {
                         const el = issue.path[i];
                         const terminal = i === issue.path.length - 1;
                         if (!terminal) {
-                            if (typeof el === "string") {
-                                curr[el] = curr[el] || { _errors: [] };
-                            }
-                            else if (typeof el === "number") {
-                                const errorArray = [];
-                                errorArray._errors = [];
-                                curr[el] = curr[el] || errorArray;
-                            }
+                            curr[el] = curr[el] || { _errors: [] };
+                            // if (typeof el === "string") {
+                            //   curr[el] = curr[el] || { _errors: [] };
+                            // } else if (typeof el === "number") {
+                            //   const errorArray: any = [];
+                            //   errorArray._errors = [];
+                            //   curr[el] = curr[el] || errorArray;
+                            // }
                         }
                         else {
                             curr[el] = curr[el] || { _errors: [] };
@@ -176,7 +182,7 @@ const defaultErrorMap = (issue, _ctx) => {
     let message;
     switch (issue.code) {
         case ZodIssueCode.invalid_type:
-            if (issue.received === "undefined") {
+            if (issue.received === ZodParsedType.undefined) {
                 message = "Required";
             }
             else {
@@ -187,22 +193,16 @@ const defaultErrorMap = (issue, _ctx) => {
             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}'`)
-                .join(", ")}`;
+            message = `Unrecognized key(s) in object: ${util.joinValues(issue.keys, ", ")}`;
             break;
         case ZodIssueCode.invalid_union:
             message = `Invalid input`;
             break;
         case ZodIssueCode.invalid_union_discriminator:
-            message = `Invalid discriminator value. Expected ${issue.options
-                .map((val) => (typeof val === "string" ? `'${val}'` : val))
-                .join(" | ")}`;
+            message = `Invalid discriminator value. Expected ${util.joinValues(issue.options)}`;
             break;
         case ZodIssueCode.invalid_enum_value:
-            message = `Invalid enum value. Expected ${issue.options
-                .map((val) => (typeof val === "string" ? `'${val}'` : val))
-                .join(" | ")}`;
+            message = `Invalid enum value. Expected ${util.joinValues(issue.options)}, received '${issue.received}'`;
             break;
         case ZodIssueCode.invalid_arguments:
             message = `Invalid function arguments`;
@@ -2390,11 +2390,23 @@ function createZodEnum(values) {
 }
 class ZodEnum extends ZodType {
     _parse(input) {
+        if (typeof input.data !== "string") {
+            const ctx = this._getOrReturnCtx(input);
+            const expectedValues = this._def.values;
+            addIssueToContext(ctx, {
+                expected: util.joinValues(expectedValues),
+                received: ctx.parsedType,
+                code: ZodIssueCode.invalid_type,
+            });
+            return INVALID;
+        }
         if (this._def.values.indexOf(input.data) === -1) {
             const ctx = this._getOrReturnCtx(input);
+            const expectedValues = this._def.values;
             addIssueToContext(ctx, {
+                received: ctx.data,
                 code: ZodIssueCode.invalid_enum_value,
-                options: this._def.values,
+                options: expectedValues,
             });
             return INVALID;
         }
@@ -2429,11 +2441,23 @@ ZodEnum.create = createZodEnum;
 class ZodNativeEnum extends ZodType {
     _parse(input) {
         const nativeEnumValues = util.getValidEnumValues(this._def.values);
+        const ctx = this._getOrReturnCtx(input);
+        if (ctx.parsedType !== ZodParsedType.string &&
+            ctx.parsedType !== ZodParsedType.number) {
+            const expectedValues = util.objectValues(nativeEnumValues);
+            addIssueToContext(ctx, {
+                expected: util.joinValues(expectedValues),
+                received: ctx.parsedType,
+                code: ZodIssueCode.invalid_type,
+            });
+            return INVALID;
+        }
         if (nativeEnumValues.indexOf(input.data) === -1) {
-            const ctx = this._getOrReturnCtx(input);
+            const expectedValues = util.objectValues(nativeEnumValues);
             addIssueToContext(ctx, {
+                received: ctx.data,
                 code: ZodIssueCode.invalid_enum_value,
-                options: util.objectValues(nativeEnumValues),
+                options: expectedValues,
             });
             return INVALID;
         }
@@ -2506,22 +2530,22 @@ class ZodEffects extends ZodType {
                 });
             }
         }
+        const checkCtx = {
+            addIssue: (arg) => {
+                addIssueToContext(ctx, arg);
+                if (arg.fatal) {
+                    status.abort();
+                }
+                else {
+                    status.dirty();
+                }
+            },
+            get path() {
+                return ctx.path;
+            },
+        };
+        checkCtx.addIssue = checkCtx.addIssue.bind(checkCtx);
         if (effect.type === "refinement") {
-            const checkCtx = {
-                addIssue: (arg) => {
-                    addIssueToContext(ctx, arg);
-                    if (arg.fatal) {
-                        status.abort();
-                    }
-                    else {
-                        status.dirty();
-                    }
-                },
-                get path() {
-                    return ctx.path;
-                },
-            };
-            checkCtx.addIssue = checkCtx.addIssue.bind(checkCtx);
             const executeRefinement = (acc
             // effect: RefinementEffect<any>
             ) => {
@@ -2575,11 +2599,11 @@ class ZodEffects extends ZodType {
                 // }
                 if (!isValid(base))
                     return base;
-                const result = effect.transform(base.value);
+                const result = effect.transform(base.value, checkCtx);
                 if (result instanceof Promise) {
                     throw new Error(`Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.`);
                 }
-                return OK(result);
+                return { status: status.value, value: result };
             }
             else {
                 return this._def.schema
@@ -2591,7 +2615,7 @@ class ZodEffects extends ZodType {
                     // if (base.status === "dirty") {
                     //   return { status: "dirty", value: base.value };
                     // }
-                    return Promise.resolve(effect.transform(base.value)).then(OK);
+                    return Promise.resolve(effect.transform(base.value, checkCtx)).then((result) => ({ status: status.value, value: result }));
                 });
             }
         }

package/lib/index.umd.js

@@ -51,6 +51,12 @@
         util.isInteger = typeof Number.isInteger === "function"
             ? (val) => Number.isInteger(val) // eslint-disable-line ban/ban
             : (val) => typeof val === "number" && isFinite(val) && Math.floor(val) === val;
+        function joinValues(array, separator = " | ") {
+            return array
+                .map((val) => (typeof val === "string" ? `'${val}'` : val))
+                .join(separator);
+        }
+        util.joinValues = joinValues;
     })(util || (util = {}));
 
     const ZodIssueCode = util.arrayToEnum([
@@ -125,14 +131,14 @@
                             const el = issue.path[i];
                             const terminal = i === issue.path.length - 1;
                             if (!terminal) {
-                                if (typeof el === "string") {
-                                    curr[el] = curr[el] || { _errors: [] };
-                                }
-                                else if (typeof el === "number") {
-                                    const errorArray = [];
-                                    errorArray._errors = [];
-                                    curr[el] = curr[el] || errorArray;
-                                }
+                                curr[el] = curr[el] || { _errors: [] };
+                                // if (typeof el === "string") {
+                                //   curr[el] = curr[el] || { _errors: [] };
+                                // } else if (typeof el === "number") {
+                                //   const errorArray: any = [];
+                                //   errorArray._errors = [];
+                                //   curr[el] = curr[el] || errorArray;
+                                // }
                             }
                             else {
                                 curr[el] = curr[el] || { _errors: [] };
@@ -182,7 +188,7 @@
         let message;
         switch (issue.code) {
             case ZodIssueCode.invalid_type:
-                if (issue.received === "undefined") {
+                if (issue.received === ZodParsedType.undefined) {
                     message = "Required";
                 }
                 else {
@@ -193,22 +199,16 @@
                 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}'`)
-                .join(", ")}`;
+                message = `Unrecognized key(s) in object: ${util.joinValues(issue.keys, ", ")}`;
                 break;
             case ZodIssueCode.invalid_union:
                 message = `Invalid input`;
                 break;
             case ZodIssueCode.invalid_union_discriminator:
-                message = `Invalid discriminator value. Expected ${issue.options
-                .map((val) => (typeof val === "string" ? `'${val}'` : val))
-                .join(" | ")}`;
+                message = `Invalid discriminator value. Expected ${util.joinValues(issue.options)}`;
                 break;
             case ZodIssueCode.invalid_enum_value:
-                message = `Invalid enum value. Expected ${issue.options
-                .map((val) => (typeof val === "string" ? `'${val}'` : val))
-                .join(" | ")}`;
+                message = `Invalid enum value. Expected ${util.joinValues(issue.options)}, received '${issue.received}'`;
                 break;
             case ZodIssueCode.invalid_arguments:
                 message = `Invalid function arguments`;
@@ -2396,11 +2396,23 @@
     }
     class ZodEnum extends ZodType {
         _parse(input) {
+            if (typeof input.data !== "string") {
+                const ctx = this._getOrReturnCtx(input);
+                const expectedValues = this._def.values;
+                addIssueToContext(ctx, {
+                    expected: util.joinValues(expectedValues),
+                    received: ctx.parsedType,
+                    code: ZodIssueCode.invalid_type,
+                });
+                return INVALID;
+            }
             if (this._def.values.indexOf(input.data) === -1) {
                 const ctx = this._getOrReturnCtx(input);
+                const expectedValues = this._def.values;
                 addIssueToContext(ctx, {
+                    received: ctx.data,
                     code: ZodIssueCode.invalid_enum_value,
-                    options: this._def.values,
+                    options: expectedValues,
                 });
                 return INVALID;
             }
@@ -2435,11 +2447,23 @@
     class ZodNativeEnum extends ZodType {
         _parse(input) {
             const nativeEnumValues = util.getValidEnumValues(this._def.values);
+            const ctx = this._getOrReturnCtx(input);
+            if (ctx.parsedType !== ZodParsedType.string &&
+                ctx.parsedType !== ZodParsedType.number) {
+                const expectedValues = util.objectValues(nativeEnumValues);
+                addIssueToContext(ctx, {
+                    expected: util.joinValues(expectedValues),
+                    received: ctx.parsedType,
+                    code: ZodIssueCode.invalid_type,
+                });
+                return INVALID;
+            }
             if (nativeEnumValues.indexOf(input.data) === -1) {
-                const ctx = this._getOrReturnCtx(input);
+                const expectedValues = util.objectValues(nativeEnumValues);
                 addIssueToContext(ctx, {
+                    received: ctx.data,
                     code: ZodIssueCode.invalid_enum_value,
-                    options: util.objectValues(nativeEnumValues),
+                    options: expectedValues,
                 });
                 return INVALID;
             }
@@ -2512,22 +2536,22 @@
                     });
                 }
             }
+            const checkCtx = {
+                addIssue: (arg) => {
+                    addIssueToContext(ctx, arg);
+                    if (arg.fatal) {
+                        status.abort();
+                    }
+                    else {
+                        status.dirty();
+                    }
+                },
+                get path() {
+                    return ctx.path;
+                },
+            };
+            checkCtx.addIssue = checkCtx.addIssue.bind(checkCtx);
             if (effect.type === "refinement") {
-                const checkCtx = {
-                    addIssue: (arg) => {
-                        addIssueToContext(ctx, arg);
-                        if (arg.fatal) {
-                            status.abort();
-                        }
-                        else {
-                            status.dirty();
-                        }
-                    },
-                    get path() {
-                        return ctx.path;
-                    },
-                };
-                checkCtx.addIssue = checkCtx.addIssue.bind(checkCtx);
                 const executeRefinement = (acc
                 // effect: RefinementEffect<any>
                 ) => {
@@ -2581,11 +2605,11 @@
                     // }
                     if (!isValid(base))
                         return base;
-                    const result = effect.transform(base.value);
+                    const result = effect.transform(base.value, checkCtx);
                     if (result instanceof Promise) {
                         throw new Error(`Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.`);
                     }
-                    return OK(result);
+                    return { status: status.value, value: result };
                 }
                 else {
                     return this._def.schema
@@ -2597,7 +2621,7 @@
                         // if (base.status === "dirty") {
                         //   return { status: "dirty", value: base.value };
                         // }
-                        return Promise.resolve(effect.transform(base.value)).then(OK);
+                        return Promise.resolve(effect.transform(base.value, checkCtx)).then((result) => ({ status: status.value, value: result }));
                     });
                 }
             }

package/lib/types.d.ts

@@ -71,7 +71,7 @@ export declare abstract class ZodType<Output = any, Def extends ZodTypeDef = Zod
     promise(): ZodPromise<this>;
     or<T extends ZodTypeAny>(option: T): ZodUnion<[this, T]>;
     and<T extends ZodTypeAny>(incoming: T): ZodIntersection<this, T>;
-    transform<NewOut>(transform: (arg: Output) => NewOut | Promise<NewOut>): ZodEffects<this, NewOut>;
+    transform<NewOut>(transform: (arg: Output, ctx: RefinementCtx) => NewOut | Promise<NewOut>): ZodEffects<this, NewOut>;
     default(def: util.noUndefined<Input>): ZodDefault<this>;
     default(def: () => util.noUndefined<Input>): ZodDefault<this>;
     describe(description: string): this;
@@ -267,28 +267,28 @@ export declare class ZodArray<T extends ZodTypeAny, Cardinality extends ArrayCar
 }
 export declare type ZodNonEmptyArray<T extends ZodTypeAny> = ZodArray<T, "atleastone">;
 export declare namespace objectUtil {
-    type MergeShapes<U extends ZodRawShape, V extends ZodRawShape> = {
+    export type MergeShapes<U extends ZodRawShape, V extends ZodRawShape> = {
         [k in Exclude<keyof U, keyof V>]: U[k];
     } & V;
+    type optionalKeys<T extends object> = {
+        [k in keyof T]: undefined extends T[k] ? k : never;
+    }[keyof T];
     type requiredKeys<T extends object> = {
         [k in keyof T]: undefined extends T[k] ? never : k;
     }[keyof T];
-    type addQuestionMarks<T extends object> = {
-        [k in keyof T]?: T[k];
-    } & {
-        [k in requiredKeys<T>]: T[k];
-    };
-    type identity<T> = T;
-    type flatten<T extends object> = identity<{
+    export type addQuestionMarks<T extends object> = Partial<Pick<T, optionalKeys<T>>> & Pick<T, requiredKeys<T>>;
+    export type identity<T> = T;
+    export type flatten<T extends object> = identity<{
         [k in keyof T]: T[k];
     }>;
-    type noNeverKeys<T extends ZodRawShape> = {
+    export type noNeverKeys<T extends ZodRawShape> = {
         [k in keyof T]: [T[k]] extends [never] ? never : k;
     }[keyof T];
-    type noNever<T extends ZodRawShape> = identity<{
+    export type noNever<T extends ZodRawShape> = identity<{
         [k in noNeverKeys<T>]: k extends keyof T ? T[k] : never;
     }>;
-    const mergeShapes: <U extends ZodRawShape, T extends ZodRawShape>(first: U, second: T) => T & U;
+    export const mergeShapes: <U extends ZodRawShape, T extends ZodRawShape>(first: U, second: T) => T & U;
+    export {};
 }
 export declare type extendShape<A, B> = Omit<A, keyof B> & B;
 declare type UnknownKeysParam = "passthrough" | "strict" | "strip";
@@ -569,7 +569,7 @@ export declare type RefinementEffect<T> = {
 };
 export declare type TransformEffect<T> = {
     type: "transform";
-    transform: (arg: T) => any;
+    transform: (arg: T, ctx: RefinementCtx) => any;
 };
 export declare type PreprocessEffect<T> = {
     type: "preprocess";

package/lib/types.js

@@ -1996,11 +1996,23 @@ function createZodEnum(values) {
 }
 class ZodEnum extends ZodType {
     _parse(input) {
+        if (typeof input.data !== "string") {
+            const ctx = this._getOrReturnCtx(input);
+            const expectedValues = this._def.values;
+            (0, parseUtil_1.addIssueToContext)(ctx, {
+                expected: util_1.util.joinValues(expectedValues),
+                received: ctx.parsedType,
+                code: ZodError_1.ZodIssueCode.invalid_type,
+            });
+            return parseUtil_1.INVALID;
+        }
         if (this._def.values.indexOf(input.data) === -1) {
             const ctx = this._getOrReturnCtx(input);
+            const expectedValues = this._def.values;
             (0, parseUtil_1.addIssueToContext)(ctx, {
+                received: ctx.data,
                 code: ZodError_1.ZodIssueCode.invalid_enum_value,
-                options: this._def.values,
+                options: expectedValues,
             });
             return parseUtil_1.INVALID;
         }
@@ -2036,11 +2048,23 @@ ZodEnum.create = createZodEnum;
 class ZodNativeEnum extends ZodType {
     _parse(input) {
         const nativeEnumValues = util_1.util.getValidEnumValues(this._def.values);
+        const ctx = this._getOrReturnCtx(input);
+        if (ctx.parsedType !== parseUtil_1.ZodParsedType.string &&
+            ctx.parsedType !== parseUtil_1.ZodParsedType.number) {
+            const expectedValues = util_1.util.objectValues(nativeEnumValues);
+            (0, parseUtil_1.addIssueToContext)(ctx, {
+                expected: util_1.util.joinValues(expectedValues),
+                received: ctx.parsedType,
+                code: ZodError_1.ZodIssueCode.invalid_type,
+            });
+            return parseUtil_1.INVALID;
+        }
         if (nativeEnumValues.indexOf(input.data) === -1) {
-            const ctx = this._getOrReturnCtx(input);
+            const expectedValues = util_1.util.objectValues(nativeEnumValues);
             (0, parseUtil_1.addIssueToContext)(ctx, {
+                received: ctx.data,
                 code: ZodError_1.ZodIssueCode.invalid_enum_value,
-                options: util_1.util.objectValues(nativeEnumValues),
+                options: expectedValues,
             });
             return parseUtil_1.INVALID;
         }
@@ -2115,22 +2139,22 @@ class ZodEffects extends ZodType {
                 });
             }
         }
+        const checkCtx = {
+            addIssue: (arg) => {
+                (0, parseUtil_1.addIssueToContext)(ctx, arg);
+                if (arg.fatal) {
+                    status.abort();
+                }
+                else {
+                    status.dirty();
+                }
+            },
+            get path() {
+                return ctx.path;
+            },
+        };
+        checkCtx.addIssue = checkCtx.addIssue.bind(checkCtx);
         if (effect.type === "refinement") {
-            const checkCtx = {
-                addIssue: (arg) => {
-                    (0, parseUtil_1.addIssueToContext)(ctx, arg);
-                    if (arg.fatal) {
-                        status.abort();
-                    }
-                    else {
-                        status.dirty();
-                    }
-                },
-                get path() {
-                    return ctx.path;
-                },
-            };
-            checkCtx.addIssue = checkCtx.addIssue.bind(checkCtx);
             const executeRefinement = (acc
             // effect: RefinementEffect<any>
             ) => {
@@ -2184,11 +2208,11 @@ class ZodEffects extends ZodType {
                 // }
                 if (!(0, parseUtil_1.isValid)(base))
                     return base;
-                const result = effect.transform(base.value);
+                const result = effect.transform(base.value, checkCtx);
                 if (result instanceof Promise) {
                     throw new Error(`Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.`);
                 }
-                return (0, parseUtil_1.OK)(result);
+                return { status: status.value, value: result };
             }
             else {
                 return this._def.schema
@@ -2200,7 +2224,7 @@ class ZodEffects extends ZodType {
                     // if (base.status === "dirty") {
                     //   return { status: "dirty", value: base.value };
                     // }
-                    return Promise.resolve(effect.transform(base.value)).then(parseUtil_1.OK);
+                    return Promise.resolve(effect.transform(base.value, checkCtx)).then((result) => ({ status: status.value, value: result }));
                 });
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod",
-  "version": "3.14.5",
+  "version": "3.16.0",
   "description": "TypeScript-first schema declaration and validation library with static type inference",
   "main": "./lib/index.js",
   "types": "./index.d.ts",