zod 3.25.4 → 3.25.5

package/src/v4/classic/tests/string.test.ts

@@ -393,18 +393,16 @@ test("nanoid", () => {
 
   expect(result.error!.issues[0].message).toEqual("custom error");
   expect(result.error).toMatchInlineSnapshot(`
-    ZodError {
-      "issues": [
-        {
-          "code": "invalid_format",
-          "format": "nanoid",
-          "message": "custom error",
-          "origin": "string",
-          "path": [],
-          "pattern": "/^[a-zA-Z0-9_-]{21}$/",
-        },
-      ],
-    }
+    [ZodError: [
+      {
+        "origin": "string",
+        "code": "invalid_format",
+        "format": "nanoid",
+        "pattern": "/^[a-zA-Z0-9_-]{21}$/",
+        "path": [],
+        "message": "custom error"
+      }
+    ]]
   `);
 });
 
@@ -416,18 +414,16 @@ test("bad nanoid", () => {
 
   expect(result.error!.issues[0].message).toEqual("custom error");
   expect(result.error).toMatchInlineSnapshot(`
-    ZodError {
-      "issues": [
-        {
-          "code": "invalid_format",
-          "format": "nanoid",
-          "message": "custom error",
-          "origin": "string",
-          "path": [],
-          "pattern": "/^[a-zA-Z0-9_-]{21}$/",
-        },
-      ],
-    }
+    [ZodError: [
+      {
+        "origin": "string",
+        "code": "invalid_format",
+        "format": "nanoid",
+        "pattern": "/^[a-zA-Z0-9_-]{21}$/",
+        "path": [],
+        "message": "custom error"
+      }
+    ]]
   `);
 });
 
@@ -501,18 +497,16 @@ test("cuid", () => {
 
   expect(result.error!.issues[0].message).toEqual("Invalid cuid");
   expect(result.error).toMatchInlineSnapshot(`
-    ZodError {
-      "issues": [
-        {
-          "code": "invalid_format",
-          "format": "cuid",
-          "message": "Invalid cuid",
-          "origin": "string",
-          "path": [],
-          "pattern": "/^[cC][^\\s-]{8,}$/",
-        },
-      ],
-    }
+    [ZodError: [
+      {
+        "origin": "string",
+        "code": "invalid_format",
+        "format": "cuid",
+        "pattern": "/^[cC][^\\\\s-]{8,}$/",
+        "path": [],
+        "message": "Invalid cuid"
+      }
+    ]]
   `);
 });
 
@@ -552,18 +546,16 @@ test("ulid", () => {
 
   expect(result.error!.issues[0].message).toEqual("Invalid ULID");
   expect(result.error).toMatchInlineSnapshot(`
-    ZodError {
-      "issues": [
-        {
-          "code": "invalid_format",
-          "format": "ulid",
-          "message": "Invalid ULID",
-          "origin": "string",
-          "path": [],
-          "pattern": "/^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/",
-        },
-      ],
-    }
+    [ZodError: [
+      {
+        "origin": "string",
+        "code": "invalid_format",
+        "format": "ulid",
+        "pattern": "/^[0-9A-HJKMNP-TV-Za-hjkmnp-tv-z]{26}$/",
+        "path": [],
+        "message": "Invalid ULID"
+      }
+    ]]
   `);
 });
 
@@ -575,18 +567,16 @@ test("xid", () => {
 
   expect(result.error!.issues[0].message).toEqual("Invalid XID");
   expect(result.error).toMatchInlineSnapshot(`
-    ZodError {
-      "issues": [
-        {
-          "code": "invalid_format",
-          "format": "xid",
-          "message": "Invalid XID",
-          "origin": "string",
-          "path": [],
-          "pattern": "/^[0-9a-vA-V]{20}$/",
-        },
-      ],
-    }
+    [ZodError: [
+      {
+        "origin": "string",
+        "code": "invalid_format",
+        "format": "xid",
+        "pattern": "/^[0-9a-vA-V]{20}$/",
+        "path": [],
+        "message": "Invalid XID"
+      }
+    ]]
   `);
 });
 

package/src/v4/classic/tests/template-literal.test.ts

@@ -686,82 +686,72 @@ test("template literal parsing - failure - complex cases", () => {
 test("template literal parsing - failure - issue format", () => {
   expect(anotherNull.safeParse("1null")).toMatchInlineSnapshot(`
     {
-      "error": ZodError {
-        "issues": [
-          {
-            "code": "invalid_format",
-            "format": "template_literal",
-            "message": "Invalid input",
-            "path": [],
-            "pattern": "^null$",
-          },
-        ],
-      },
+      "error": [ZodError: [
+      {
+        "code": "invalid_format",
+        "format": "template_literal",
+        "pattern": "^null$",
+        "path": [],
+        "message": "Invalid input"
+      }
+    ]],
       "success": false,
     }
   `);
   expect(cuidZZZ.safeParse("1cjld2cyuq0000t3rmniod1foyZZZ")).toMatchInlineSnapshot(`
     {
-      "error": ZodError {
-        "issues": [
-          {
-            "code": "invalid_format",
-            "format": "template_literal",
-            "message": "Invalid input",
-            "path": [],
-            "pattern": "^[cC][^\\s-]{8,}ZZZ$",
-          },
-        ],
-      },
+      "error": [ZodError: [
+      {
+        "code": "invalid_format",
+        "format": "template_literal",
+        "pattern": "^[cC][^\\\\s-]{8,}ZZZ$",
+        "path": [],
+        "message": "Invalid input"
+      }
+    ]],
       "success": false,
     }
   `);
   expect(stringMin5Max10.safeParse("1234")).toMatchInlineSnapshot(`
     {
-      "error": ZodError {
-        "issues": [
-          {
-            "code": "invalid_format",
-            "format": "template_literal",
-            "message": "Invalid input",
-            "path": [],
-            "pattern": "^[\\s\\S]{5,10}$",
-          },
-        ],
-      },
+      "error": [ZodError: [
+      {
+        "code": "invalid_format",
+        "format": "template_literal",
+        "pattern": "^[\\\\s\\\\S]{5,10}$",
+        "path": [],
+        "message": "Invalid input"
+      }
+    ]],
       "success": false,
     }
   `);
   expect(connectionString.safeParse("mongodb://host:1234/defaultauthdb?authSourceadmin")).toMatchInlineSnapshot(`
     {
-      "error": ZodError {
-        "issues": [
-          {
-            "code": "invalid_format",
-            "format": "template_literal",
-            "message": "Invalid input",
-            "path": [],
-            "pattern": "^mongodb:\\/\\/(\\w+:\\w+@)?\\w+:\\d+(\\/(\\w+)?(\\?(\\w+=\\w+(&\\w+=\\w+)*)?)?)?$",
-          },
-        ],
-      },
+      "error": [ZodError: [
+      {
+        "code": "invalid_format",
+        "format": "template_literal",
+        "pattern": "^mongodb:\\\\/\\\\/(\\\\w+:\\\\w+@)?\\\\w+:\\\\d+(\\\\/(\\\\w+)?(\\\\?(\\\\w+=\\\\w+(&\\\\w+=\\\\w+)*)?)?)?$",
+        "path": [],
+        "message": "Invalid input"
+      }
+    ]],
       "success": false,
     }
   `);
 
   expect(stringStartsWithMax5.safeParse("1hell")).toMatchInlineSnapshot(`
     {
-      "error": ZodError {
-        "issues": [
-          {
-            "code": "invalid_format",
-            "format": "template_literal",
-            "message": "Invalid input",
-            "path": [],
-            "pattern": "^hello.*$",
-          },
-        ],
-      },
+      "error": [ZodError: [
+      {
+        "code": "invalid_format",
+        "format": "template_literal",
+        "pattern": "^hello.*$",
+        "path": [],
+        "message": "Invalid input"
+      }
+    ]],
       "success": false,
     }
   `);

package/src/v4/classic/tests/transform.test.ts

@@ -17,15 +17,13 @@ test("transform ctx.addIssue with parse", () => {
   const result = schema.safeParse("asdf");
   expect(result.success).toEqual(false);
   expect(result.error!).toMatchInlineSnapshot(`
-    ZodError {
-      "issues": [
-        {
-          "code": "custom",
-          "message": "asdf is not one of our allowed strings",
-          "path": [],
-        },
-      ],
-    }
+    [ZodError: [
+      {
+        "code": "custom",
+        "message": "asdf is not one of our allowed strings",
+        "path": []
+      }
+    ]]
   `);
 });
 
@@ -49,15 +47,13 @@ test("transform ctx.addIssue with parseAsync", async () => {
 
   expect(result).toMatchInlineSnapshot(`
     {
-      "error": ZodError {
-        "issues": [
-          {
-            "code": "custom",
-            "message": "asdf is not one of our allowed strings",
-            "path": [],
-          },
-        ],
-      },
+      "error": [ZodError: [
+      {
+        "code": "custom",
+        "message": "asdf is not one of our allowed strings",
+        "path": []
+      }
+    ]],
       "success": false,
     }
   `);
@@ -204,15 +200,13 @@ test("short circuit on dirty", () => {
   expect(result.success).toEqual(false);
 
   expect(result.error).toMatchInlineSnapshot(`
-    ZodError {
-      "issues": [
-        {
-          "code": "custom",
-          "message": "Invalid input",
-          "path": [],
-        },
-      ],
-    }
+    [ZodError: [
+      {
+        "code": "custom",
+        "path": [],
+        "message": "Invalid input"
+      }
+    ]]
   `);
 
   const result2 = schema.safeParse(1234);
@@ -231,30 +225,26 @@ test("async short circuit on dirty", async () => {
   expect(result.success).toEqual(false);
 
   expect(result.error).toMatchInlineSnapshot(`
-    ZodError {
-      "issues": [
-        {
-          "code": "custom",
-          "message": "Invalid input",
-          "path": [],
-        },
-      ],
-    }
+    [ZodError: [
+      {
+        "code": "custom",
+        "path": [],
+        "message": "Invalid input"
+      }
+    ]]
   `);
 
   const result2 = await schema.spa(1234);
   expect(result2.success).toEqual(false);
 
   expect(result2.error).toMatchInlineSnapshot(`
-    ZodError {
-      "issues": [
-        {
-          "code": "invalid_type",
-          "expected": "string",
-          "message": "Invalid input: expected string, received number",
-          "path": [],
-        },
-      ],
-    }
+    [ZodError: [
+      {
+        "expected": "string",
+        "code": "invalid_type",
+        "path": [],
+        "message": "Invalid input: expected string, received number"
+      }
+    ]]
   `);
 });

package/src/v4/classic/tests/tuple.test.ts

@@ -11,49 +11,43 @@ test("successful validation", () => {
   const r1 = testTuple.safeParse(["asdf", "asdf"]);
   expect(r1.success).toEqual(false);
   expect(r1.error!).toMatchInlineSnapshot(`
-    ZodError {
-      "issues": [
-        {
-          "code": "invalid_type",
-          "expected": "number",
-          "message": "Invalid input: expected number, received string",
-          "path": [
-            1,
-          ],
-        },
-      ],
-    }
+    [ZodError: [
+      {
+        "expected": "number",
+        "code": "invalid_type",
+        "path": [
+          1
+        ],
+        "message": "Invalid input: expected number, received string"
+      }
+    ]]
   `);
 
   const r2 = testTuple.safeParse(["asdf", 1234, true]);
   expect(r2.success).toEqual(false);
   expect(r2.error!).toMatchInlineSnapshot(`
-    ZodError {
-      "issues": [
-        {
-          "code": "too_big",
-          "maximum": 2,
-          "message": "Too big: expected array to have <2 items",
-          "origin": "array",
-          "path": [],
-        },
-      ],
-    }
+    [ZodError: [
+      {
+        "origin": "array",
+        "code": "too_big",
+        "maximum": 2,
+        "path": [],
+        "message": "Too big: expected array to have <2 items"
+      }
+    ]]
   `);
 
   const r3 = testTuple.safeParse({});
   expect(r3.success).toEqual(false);
   expect(r3.error!).toMatchInlineSnapshot(`
-    ZodError {
-      "issues": [
-        {
-          "code": "invalid_type",
-          "expected": "tuple",
-          "message": "Invalid input: expected tuple, received object",
-          "path": [],
-        },
-      ],
-    }
+    [ZodError: [
+      {
+        "expected": "tuple",
+        "code": "invalid_type",
+        "path": [],
+        "message": "Invalid input: expected tuple, received object"
+      }
+    ]]
   `);
 });
 
@@ -69,49 +63,43 @@ test("async validation", async () => {
   const r1 = await testTuple.safeParseAsync(["asdf", "asdf"]);
   expect(r1.success).toEqual(false);
   expect(r1.error!).toMatchInlineSnapshot(`
-    ZodError {
-      "issues": [
-        {
-          "code": "invalid_type",
-          "expected": "number",
-          "message": "Invalid input: expected number, received string",
-          "path": [
-            1,
-          ],
-        },
-      ],
-    }
+    [ZodError: [
+      {
+        "expected": "number",
+        "code": "invalid_type",
+        "path": [
+          1
+        ],
+        "message": "Invalid input: expected number, received string"
+      }
+    ]]
   `);
 
   const r2 = await testTuple.safeParseAsync(["asdf", 1234, true]);
   expect(r2.success).toEqual(false);
   expect(r2.error!).toMatchInlineSnapshot(`
-    ZodError {
-      "issues": [
-        {
-          "code": "too_big",
-          "maximum": 2,
-          "message": "Too big: expected array to have <2 items",
-          "origin": "array",
-          "path": [],
-        },
-      ],
-    }
+    [ZodError: [
+      {
+        "origin": "array",
+        "code": "too_big",
+        "maximum": 2,
+        "path": [],
+        "message": "Too big: expected array to have <2 items"
+      }
+    ]]
   `);
 
   const r3 = await testTuple.safeParseAsync({});
   expect(r3.success).toEqual(false);
   expect(r3.error!).toMatchInlineSnapshot(`
-    ZodError {
-      "issues": [
-        {
-          "code": "invalid_type",
-          "expected": "tuple",
-          "message": "Invalid input: expected tuple, received object",
-          "path": [],
-        },
-      ],
-    }
+    [ZodError: [
+      {
+        "expected": "tuple",
+        "code": "invalid_type",
+        "path": [],
+        "message": "Invalid input: expected tuple, received object"
+      }
+    ]]
   `);
 });
 

package/src/v4/core/errors.ts

@@ -1,7 +1,7 @@
 import type { $ZodCheck, $ZodStringFormats } from "./checks.js";
 import { $constructor } from "./core.js";
 import type { $ZodType } from "./schemas.js";
-import type * as util from "./util.js";
+import * as util from "./util.js";
 
 ///////////////////////////
 ////     base type     ////
@@ -181,14 +181,25 @@ export interface $ZodError<T = unknown> extends Error {
 }
 
 const initializer = (inst: $ZodError, def: $ZodIssue[]): void => {
+  inst.name = "$ZodError";
   Object.defineProperty(inst, "_zod", {
     value: inst._zod,
     enumerable: false,
   });
   Object.defineProperty(inst, "issues", {
     value: def,
+    enumerable: false,
+  });
+  // inst.message = JSON.stringify(def, util.jsonStringifyReplacer, 2);
+  Object.defineProperty(inst, "message", {
+    get() {
+      return JSON.stringify(def, util.jsonStringifyReplacer, 2);
+    },
     enumerable: true,
+    // configurable: false,
   });
+  // inst.toString = () => inst.message;
+
   // inst.message = `Invalid input`;
   // Object.defineProperty(inst, "message", {
   //   get() {

package/src/v4/core/parse.ts

@@ -70,7 +70,7 @@ export const _safeParse: (_Err: $ZodErrorClass) => $SafeParse = (_Err) => (schem
       }
     : { success: true, data: result.value };
 };
-export const safeParse: $SafeParse = /* @__PURE__*/ _safeParse(errors.$ZodError);
+export const safeParse: $SafeParse = /* @__PURE__*/ _safeParse(errors.$ZodRealError);
 
 export type $SafeParseAsync = <T extends schemas.$ZodType>(
   schema: T,
@@ -91,4 +91,4 @@ export const _safeParseAsync: (_Err: $ZodErrorClass) => $SafeParseAsync = (_Err)
     : { success: true, data: result.value };
 };
 
-export const safeParseAsync: $SafeParseAsync = /* @__PURE__*/ _safeParseAsync(errors.$ZodError);
+export const safeParseAsync: $SafeParseAsync = /* @__PURE__*/ _safeParseAsync(errors.$ZodRealError);

package/src/v4/core/tests/index.test.ts

@@ -1,5 +1,46 @@
-import { expect, test } from "vitest";
+import { expect, expectTypeOf, test } from "vitest";
+import * as z from "zod/v3";
 
 test("test", () => {
   expect(true).toBe(true);
 });
+
+test("test2", () => {
+  expect(() => z.string().parse(234)).toThrowErrorMatchingInlineSnapshot(`
+    [ZodError: [
+      {
+        "code": "invalid_type",
+        "expected": "string",
+        "received": "number",
+        "path": [],
+        "message": "Expected string, received number"
+      }
+    ]]
+  `);
+});
+
+test("async validation", async () => {
+  const testTuple = z
+    .tuple([z.string().refine(async () => true), z.number().refine(async () => true)])
+    .refine(async () => true);
+  expectTypeOf<typeof testTuple._output>().toEqualTypeOf<[string, number]>();
+
+  const val = await testTuple.parseAsync(["asdf", 1234]);
+  expect(val).toEqual(val);
+
+  const r1 = await testTuple.safeParseAsync(["asdf", "asdf"]);
+  expect(r1.success).toEqual(false);
+  expect(r1.error!).toMatchInlineSnapshot(`
+    [ZodError: [
+      {
+        "code": "invalid_type",
+        "expected": "number",
+        "received": "string",
+        "path": [
+          1
+        ],
+        "message": "Expected number, received string"
+      }
+    ]]
+  `);
+});

package/src/v4/mini/tests/error.test.ts

@@ -11,7 +11,7 @@ test("no locale by default", () => {
 test("error inheritance", () => {
   const e1 = z.string().safeParse(123).error!;
   expect(e1).toBeInstanceOf(z.core.$ZodError);
-  expect(e1).not.toBeInstanceOf(Error);
+  // expect(e1).not.toBeInstanceOf(Error);
 
   try {
     z.string().parse(123);