zod 3.25.4 → 3.25.6

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

@@ -47,16 +47,14 @@ test("type error with custom error map", () => {
   const result = z.string().safeParse(234, { error: errorMap });
   expect(result.success).toBe(false);
   expect(result.error).toMatchInlineSnapshot(`
-    ZodError {
-      "issues": [
-        {
-          "code": "invalid_type",
-          "expected": "string",
-          "message": "bad type!",
-          "path": [],
-        },
-      ],
-    }
+    [ZodError: [
+      {
+        "expected": "string",
+        "code": "invalid_type",
+        "path": [],
+        "message": "bad type!"
+      }
+    ]]
   `);
 });
 
@@ -69,18 +67,16 @@ test("refinement fail with params", () => {
     .safeParse(2, { error: errorMap });
   expect(result.success).toBe(false);
   expect(result.error).toMatchInlineSnapshot(`
-    ZodError {
-      "issues": [
-        {
-          "code": "custom",
-          "message": "less-than-3",
-          "params": {
-            "minimum": 3,
-          },
-          "path": [],
+    [ZodError: [
+      {
+        "code": "custom",
+        "path": [],
+        "params": {
+          "minimum": 3
         },
-      ],
-    }
+        "message": "less-than-3"
+      }
+    ]]
   `);
 });
 
@@ -95,18 +91,16 @@ test("hard coded error  with custom errormap", () => {
 
   expect(result.success).toBe(false);
   expect(result.error).toMatchInlineSnapshot(`
-    ZodError {
-      "issues": [
-        {
-          "code": "custom",
-          "message": "override",
-          "params": {
-            "minimum": 13,
-          },
-          "path": [],
+    [ZodError: [
+      {
+        "code": "custom",
+        "path": [],
+        "params": {
+          "minimum": 13
         },
-      ],
-    }
+        "message": "override"
+      }
+    ]]
   `);
 });
 
@@ -118,15 +112,13 @@ test("default error message", () => {
 
   expect(result.success).toBe(false);
   expect(result.error).toMatchInlineSnapshot(`
-    ZodError {
-      "issues": [
-        {
-          "code": "custom",
-          "message": "Invalid input",
-          "path": [],
-        },
-      ],
-    }
+    [ZodError: [
+      {
+        "code": "custom",
+        "path": [],
+        "message": "Invalid input"
+      }
+    ]]
   `);
 });
 
@@ -138,15 +130,13 @@ test("override error in refine", () => {
   expect(result.success).toBe(false);
   expect(result.error!.issues.length).toEqual(1);
   expect(result.error).toMatchInlineSnapshot(`
-    ZodError {
-      "issues": [
-        {
-          "code": "custom",
-          "message": "override",
-          "path": [],
-        },
-      ],
-    }
+    [ZodError: [
+      {
+        "code": "custom",
+        "path": [],
+        "message": "override"
+      }
+    ]]
   `);
 });
 
@@ -160,15 +150,13 @@ test("override error in refinement", () => {
   expect(result.success).toBe(false);
   expect(result.error!.issues.length).toEqual(1);
   expect(result.error).toMatchInlineSnapshot(`
-    ZodError {
-      "issues": [
-        {
-          "code": "custom",
-          "message": "override",
-          "path": [],
-        },
-      ],
-    }
+    [ZodError: [
+      {
+        "code": "custom",
+        "path": [],
+        "message": "override"
+      }
+    ]]
   `);
 });
 
@@ -182,17 +170,15 @@ test("array minimum", () => {
   expect(result.success).toBe(false);
   expect(result.error!.issues[0].code).toEqual("too_small");
   expect(result.error).toMatchInlineSnapshot(`
-    ZodError {
-      "issues": [
-        {
-          "code": "too_small",
-          "message": "Too small: expected array to have >3 items",
-          "minimum": 3,
-          "origin": "array",
-          "path": [],
-        },
-      ],
-    }
+    [ZodError: [
+      {
+        "origin": "array",
+        "code": "too_small",
+        "minimum": 3,
+        "path": [],
+        "message": "Too small: expected array to have >3 items"
+      }
+    ]]
   `);
 });
 
@@ -201,18 +187,16 @@ test("literal bigint default error message", () => {
   expect(result.success).toBe(false);
   expect(result.error!.issues.length).toEqual(1);
   expect(result.error).toMatchInlineSnapshot(`
-    ZodError {
-      "issues": [
-        {
-          "code": "invalid_value",
-          "message": "Invalid input: expected 12n",
-          "path": [],
-          "values": [
-            12n,
-          ],
-        },
-      ],
-    }
+    [ZodError: [
+      {
+        "code": "invalid_value",
+        "values": [
+          "12"
+        ],
+        "path": [],
+        "message": "Invalid input: expected 12n"
+      }
+    ]]
   `);
 });
 
@@ -230,18 +214,16 @@ test("custom path in custom error map", () => {
   const result = schema.safeParse({ items: ["first"] }, { error: errorMap });
   expect(result.success).toBe(false);
   expect(result.error).toMatchInlineSnapshot(`
-    ZodError {
-      "issues": [
-        {
-          "code": "custom",
-          "message": "doesnt matter",
-          "path": [
-            "items",
-            "items-too-few",
-          ],
-        },
-      ],
-    }
+    [ZodError: [
+      {
+        "code": "custom",
+        "path": [
+          "items",
+          "items-too-few"
+        ],
+        "message": "doesnt matter"
+      }
+    ]]
   `);
 });
 
@@ -542,17 +524,15 @@ test("z.config customError ", () => {
   const result = stringWithCustomError.min(10).safeParse("tooshort");
   expect(result.success).toBe(false);
   expect(result.error).toMatchInlineSnapshot(`
-    ZodError {
-      "issues": [
-        {
-          "code": "too_small",
-          "message": "override",
-          "minimum": 10,
-          "origin": "string",
-          "path": [],
-        },
-      ],
-    }
+    [ZodError: [
+      {
+        "origin": "string",
+        "code": "too_small",
+        "minimum": 10,
+        "path": [],
+        "message": "override"
+      }
+    ]]
   `);
   expect(result.error!.issues[0].message).toEqual("override");
   z.config({ customError: undefined });
@@ -628,26 +608,24 @@ test("dont short circuit on continuable errors", () => {
   const result = user.safeParse({ password: "asdf", confirm: "qwer" });
   expect(result.success).toBe(false);
   expect(result.error).toMatchInlineSnapshot(`
-    ZodError {
-      "issues": [
-        {
-          "code": "too_small",
-          "message": "Too small: expected string to have >6 characters",
-          "minimum": 6,
-          "origin": "string",
-          "path": [
-            "password",
-          ],
-        },
-        {
-          "code": "custom",
-          "message": "Passwords don't match",
-          "path": [
-            "confirm",
-          ],
-        },
-      ],
-    }
+    [ZodError: [
+      {
+        "origin": "string",
+        "code": "too_small",
+        "minimum": 6,
+        "path": [
+          "password"
+        ],
+        "message": "Too small: expected string to have >6 characters"
+      },
+      {
+        "code": "custom",
+        "path": [
+          "confirm"
+        ],
+        "message": "Passwords don't match"
+      }
+    ]]
   `);
   // expect(result.error!.issues.length).toEqual(2);
 });
@@ -689,7 +667,7 @@ test("error inheritance", () => {
   expect(e1).toBeInstanceOf(z.core.$ZodError);
   expect(e1).toBeInstanceOf(z.ZodError);
   expect(e1).toBeInstanceOf(z.ZodRealError);
-  expect(e1).not.toBeInstanceOf(Error);
+  // expect(e1).not.toBeInstanceOf(Error);
 
   try {
     z.string().parse(123);
@@ -697,7 +675,7 @@ test("error inheritance", () => {
     expect(e1).toBeInstanceOf(z.core.$ZodError);
     expect(e2).toBeInstanceOf(z.ZodError);
     expect(e2).toBeInstanceOf(z.ZodRealError);
-    expect(e2).toBeInstanceOf(Error);
+    // expect(e2).toBeInstanceOf(Error);
   }
 });
 
@@ -706,6 +684,15 @@ test("error serialization", () => {
     z.string().parse(123);
   } catch (e) {
     console.dir(e, { depth: null });
-    expect(e).toMatchInlineSnapshot(`[Error]`);
+    expect(e).toMatchInlineSnapshot(`
+      [ZodError: [
+        {
+          "expected": "string",
+          "code": "invalid_type",
+          "path": [],
+          "message": "Invalid input: expected string, received number"
+        }
+      ]]
+    `);
   }
 });

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

@@ -60,18 +60,16 @@ test("literal default error message", () => {
   expect(result.success).toEqual(false);
   expect(result.error!.issues.length).toEqual(1);
   expect(result.error).toMatchInlineSnapshot(`
-    ZodError {
-      "issues": [
-        {
-          "code": "invalid_value",
-          "message": "Invalid input: expected "Tuna"",
-          "path": [],
-          "values": [
-            "Tuna",
-          ],
-        },
-      ],
-    }
+    [ZodError: [
+      {
+        "code": "invalid_value",
+        "values": [
+          "Tuna"
+        ],
+        "path": [],
+        "message": "Invalid input: expected \\"Tuna\\""
+      }
+    ]]
   `);
 });
 

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

@@ -32,24 +32,22 @@ test("valid parse async", async () => {
   const result = await asyncMap.safeParseAsync(new Map([["first", "foo"]]));
   expect(result.success).toEqual(false);
   expect(result.error).toMatchInlineSnapshot(`
-    ZodError {
-      "issues": [
-        {
-          "code": "custom",
-          "message": "bad key",
-          "path": [
-            "first",
-          ],
-        },
-        {
-          "code": "custom",
-          "message": "bad value",
-          "path": [
-            "first",
-          ],
-        },
-      ],
-    }
+    [ZodError: [
+      {
+        "code": "custom",
+        "path": [
+          "first"
+        ],
+        "message": "bad key"
+      },
+      {
+        "code": "custom",
+        "path": [
+          "first"
+        ],
+        "message": "bad value"
+      }
+    ]]
   `);
 });
 
@@ -68,26 +66,24 @@ test("throws when the given map has invalid key and invalid input", () => {
   if (result.success === false) {
     expect(result.error.issues.length).toEqual(2);
     expect(result.error).toMatchInlineSnapshot(`
-      ZodError {
-        "issues": [
-          {
-            "code": "invalid_type",
-            "expected": "string",
-            "message": "Invalid input: expected string, received number",
-            "path": [
-              42,
-            ],
-          },
-          {
-            "code": "invalid_type",
-            "expected": "string",
-            "message": "Invalid input: expected string, received symbol",
-            "path": [
-              42,
-            ],
-          },
-        ],
-      }
+      [ZodError: [
+        {
+          "expected": "string",
+          "code": "invalid_type",
+          "path": [
+            42
+          ],
+          "message": "Invalid input: expected string, received number"
+        },
+        {
+          "expected": "string",
+          "code": "invalid_type",
+          "path": [
+            42
+          ],
+          "message": "Invalid input: expected string, received symbol"
+        }
+      ]]
     `);
   }
 });
@@ -146,24 +142,22 @@ test("dirty", async () => {
   if (!result.success) {
     expect(result.error.issues.length).toEqual(2);
     expect(result.error).toMatchInlineSnapshot(`
-      ZodError {
-        "issues": [
-          {
-            "code": "custom",
-            "message": "Keys must be uppercase",
-            "path": [
-              "first",
-            ],
-          },
-          {
-            "code": "custom",
-            "message": "Keys must be uppercase",
-            "path": [
-              "second",
-            ],
-          },
-        ],
-      }
+      [ZodError: [
+        {
+          "code": "custom",
+          "path": [
+            "first"
+          ],
+          "message": "Keys must be uppercase"
+        },
+        {
+          "code": "custom",
+          "path": [
+            "second"
+          ],
+          "message": "Keys must be uppercase"
+        }
+      ]]
     `);
   }
 });
@@ -188,17 +182,15 @@ test("map with object keys", () => {
   const badResult = map.safeParse(badData);
   expect(badResult.success).toEqual(false);
   expect(badResult.error).toMatchInlineSnapshot(`
-    ZodError {
-      "issues": [
-        {
-          "code": "invalid_type",
-          "expected": "object",
-          "message": "Invalid input: expected object, received string",
-          "path": [
-            "bad",
-          ],
-        },
-      ],
-    }
+    [ZodError: [
+      {
+        "expected": "object",
+        "code": "invalid_type",
+        "path": [
+          "bad"
+        ],
+        "message": "Invalid input: expected object, received string"
+      }
+    ]]
   `);
 });

package/src/v4/classic/tests/nested-refine.test.ts

@@ -40,88 +40,84 @@ test("nested refinements", () => {
   };
   expect(zodSchema.safeParse(DATA)).toMatchInlineSnapshot(`
     {
-      "error": ZodError {
-        "issues": [
-          {
-            "code": "too_small",
-            "message": "Too small: expected string to have >1 characters",
-            "minimum": 1,
-            "origin": "string",
-            "path": [
-              "nested",
-              "confirm",
-            ],
-          },
-          {
-            "code": "custom",
-            "message": "Confirm length should be > 2",
-            "path": [
-              "nested",
-              "confirm",
-            ],
-          },
-          {
-            "code": "custom",
-            "message": "Value must be "bar"",
-            "path": [
-              "nested",
-              "confirm",
-            ],
-          },
-          {
-            "code": "custom",
-            "message": "Password and confirm must match",
-            "path": [
-              "nested",
-              "confirm",
-            ],
-          },
+      "error": [ZodError: [
+      {
+        "origin": "string",
+        "code": "too_small",
+        "minimum": 1,
+        "path": [
+          "nested",
+          "confirm"
         ],
+        "message": "Too small: expected string to have >1 characters"
       },
+      {
+        "code": "custom",
+        "path": [
+          "nested",
+          "confirm"
+        ],
+        "message": "Confirm length should be > 2"
+      },
+      {
+        "code": "custom",
+        "path": [
+          "nested",
+          "confirm"
+        ],
+        "message": "Value must be \\"bar\\""
+      },
+      {
+        "code": "custom",
+        "path": [
+          "nested",
+          "confirm"
+        ],
+        "message": "Password and confirm must match"
+      }
+    ]],
       "success": false,
     }
   `);
 
   expect(zodSchema.safeParse(DATA, { jitless: true })).toMatchInlineSnapshot(`
     {
-      "error": ZodError {
-        "issues": [
-          {
-            "code": "too_small",
-            "message": "Too small: expected string to have >1 characters",
-            "minimum": 1,
-            "origin": "string",
-            "path": [
-              "nested",
-              "confirm",
-            ],
-          },
-          {
-            "code": "custom",
-            "message": "Confirm length should be > 2",
-            "path": [
-              "nested",
-              "confirm",
-            ],
-          },
-          {
-            "code": "custom",
-            "message": "Value must be "bar"",
-            "path": [
-              "nested",
-              "confirm",
-            ],
-          },
-          {
-            "code": "custom",
-            "message": "Password and confirm must match",
-            "path": [
-              "nested",
-              "confirm",
-            ],
-          },
+      "error": [ZodError: [
+      {
+        "origin": "string",
+        "code": "too_small",
+        "minimum": 1,
+        "path": [
+          "nested",
+          "confirm"
         ],
+        "message": "Too small: expected string to have >1 characters"
       },
+      {
+        "code": "custom",
+        "path": [
+          "nested",
+          "confirm"
+        ],
+        "message": "Confirm length should be > 2"
+      },
+      {
+        "code": "custom",
+        "path": [
+          "nested",
+          "confirm"
+        ],
+        "message": "Value must be \\"bar\\""
+      },
+      {
+        "code": "custom",
+        "path": [
+          "nested",
+          "confirm"
+        ],
+        "message": "Password and confirm must match"
+      }
+    ]],
       "success": false,
     }
   `);