zod 3.25.4 → 3.25.5

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

@@ -32,15 +32,13 @@ test("ctx.addIssue accepts string", () => {
   expect(result.error!.issues).toHaveLength(1);
   expect(result).toMatchInlineSnapshot(`
     {
-      "error": ZodError {
-        "issues": [
-          {
-            "code": "custom",
-            "message": "bad stuff",
-            "path": [],
-          },
-        ],
-      },
+      "error": [ZodError: [
+      {
+        "message": "bad stuff",
+        "code": "custom",
+        "path": []
+      }
+    ]],
       "success": false,
     }
   `);
@@ -63,15 +61,13 @@ test("preprocess ctx.addIssue with parse", () => {
   expect(result.error!.issues).toHaveLength(1);
   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,
     }
   `);
@@ -90,21 +86,19 @@ test("preprocess ctx.addIssue non-fatal by default", () => {
   expect(result.error!.issues).toHaveLength(2);
   expect(result).toMatchInlineSnapshot(`
     {
-      "error": ZodError {
-        "issues": [
-          {
-            "code": "custom",
-            "message": "custom error",
-            "path": [],
-          },
-          {
-            "code": "invalid_type",
-            "expected": "string",
-            "message": "Invalid input: expected string, received number",
-            "path": [],
-          },
-        ],
+      "error": [ZodError: [
+      {
+        "code": "custom",
+        "message": "custom error",
+        "path": []
       },
+      {
+        "expected": "string",
+        "code": "invalid_type",
+        "path": [],
+        "message": "Invalid input: expected string, received number"
+      }
+    ]],
       "success": false,
     }
   `);
@@ -127,17 +121,15 @@ test("preprocess ctx.addIssue fatal true", () => {
   expect(result.error!.issues).toHaveLength(1);
   expect(result).toMatchInlineSnapshot(`
     {
-      "error": ZodError {
-        "issues": [
-          {
-            "code": "custom",
-            "fatal": true,
-            "message": "custom error",
-            "origin": "custom",
-            "path": [],
-          },
-        ],
-      },
+      "error": [ZodError: [
+      {
+        "code": "custom",
+        "origin": "custom",
+        "message": "custom error",
+        "fatal": true,
+        "path": []
+      }
+    ]],
       "success": false,
     }
   `);
@@ -158,15 +150,13 @@ test("async preprocess ctx.addIssue with parseAsync", async () => {
   expect(result.error!.issues).toHaveLength(1);
   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,
     }
   `);
@@ -188,21 +178,19 @@ test("z.NEVER in preprocess", () => {
   expect(result.error!.issues).toHaveLength(2);
   expect(result).toMatchInlineSnapshot(`
     {
-      "error": ZodError {
-        "issues": [
-          {
-            "code": "custom",
-            "message": "bad",
-            "path": [],
-          },
-          {
-            "code": "invalid_type",
-            "expected": "number",
-            "message": "Invalid input: expected number, received object",
-            "path": [],
-          },
-        ],
+      "error": [ZodError: [
+      {
+        "code": "custom",
+        "message": "bad",
+        "path": []
       },
+      {
+        "expected": "number",
+        "code": "invalid_type",
+        "path": [],
+        "message": "Invalid input: expected number, received object"
+      }
+    ]],
       "success": false,
     }
   `);
@@ -221,29 +209,27 @@ test("preprocess as the second property of object", () => {
   expect(result.error!.issues).toHaveLength(2);
   expect(result).toMatchInlineSnapshot(`
     {
-      "error": ZodError {
-        "issues": [
-          {
-            "code": "too_small",
-            "message": "Too small: expected string to have >1 characters",
-            "minimum": 1,
-            "origin": "string",
-            "path": [
-              "nonEmptyStr",
-            ],
-          },
-          {
-            "code": "too_small",
-            "inclusive": false,
-            "message": "Too small: expected number to be >0",
-            "minimum": 0,
-            "origin": "number",
-            "path": [
-              "positiveNum",
-            ],
-          },
+      "error": [ZodError: [
+      {
+        "origin": "string",
+        "code": "too_small",
+        "minimum": 1,
+        "path": [
+          "nonEmptyStr"
         ],
+        "message": "Too small: expected string to have >1 characters"
       },
+      {
+        "origin": "number",
+        "code": "too_small",
+        "minimum": 0,
+        "inclusive": false,
+        "path": [
+          "positiveNum"
+        ],
+        "message": "Too small: expected number to be >0"
+      }
+    ]],
       "success": false,
     }
   `);
@@ -260,28 +246,26 @@ test("preprocess validates with sibling errors", () => {
   expect(result.error!.issues).toHaveLength(2);
   expect(result).toMatchInlineSnapshot(`
     {
-      "error": ZodError {
-        "issues": [
-          {
-            "code": "invalid_type",
-            "expected": "string",
-            "message": "Invalid input: expected string, received undefined",
-            "path": [
-              "missing",
-            ],
-          },
-          {
-            "code": "invalid_format",
-            "format": "regex",
-            "message": "Invalid string: must match pattern / asdf/",
-            "origin": "string",
-            "path": [
-              "preprocess",
-            ],
-            "pattern": "/ asdf/",
-          },
+      "error": [ZodError: [
+      {
+        "expected": "string",
+        "code": "invalid_type",
+        "path": [
+          "missing"
         ],
+        "message": "Invalid input: expected string, received undefined"
       },
+      {
+        "origin": "string",
+        "code": "invalid_format",
+        "format": "regex",
+        "pattern": "/ asdf/",
+        "path": [
+          "preprocess"
+        ],
+        "message": "Invalid string: must match pattern / asdf/"
+      }
+    ]],
       "success": false,
     }
   `);

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

@@ -102,17 +102,15 @@ test("date schema", async () => {
   expect(() => dateSchema.parse(null)).toThrow();
   expect(await dateSchema.safeParseAsync(new Date("invalid"))).toMatchInlineSnapshot(`
     {
-      "error": ZodError {
-        "issues": [
-          {
-            "code": "invalid_type",
-            "expected": "date",
-            "message": "Invalid input: expected date, received Date",
-            "path": [],
-            "received": "Invalid Date",
-          },
-        ],
-      },
+      "error": [ZodError: [
+      {
+        "expected": "date",
+        "code": "invalid_type",
+        "received": "Invalid Date",
+        "path": [],
+        "message": "Invalid input: expected date, received Date"
+      }
+    ]],
       "success": false,
     }
   `);

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

@@ -34,35 +34,31 @@ test("enum exhaustiveness", () => {
 
   expect(schema.safeParse({ Tuna: "asdf", Salmon: "asdf", Trout: "asdf" })).toMatchInlineSnapshot(`
     {
-      "error": ZodError {
-        "issues": [
-          {
-            "code": "unrecognized_keys",
-            "keys": [
-              "Trout",
-            ],
-            "message": "Unrecognized key: "Trout"",
-            "path": [],
-          },
+      "error": [ZodError: [
+      {
+        "code": "unrecognized_keys",
+        "keys": [
+          "Trout"
         ],
-      },
+        "path": [],
+        "message": "Unrecognized key: \\"Trout\\""
+      }
+    ]],
       "success": false,
     }
   `);
   expect(schema.safeParse({ Tuna: "asdf" })).toMatchInlineSnapshot(`
     {
-      "error": ZodError {
-        "issues": [
-          {
-            "code": "invalid_type",
-            "expected": "string",
-            "message": "Invalid input: expected string, received undefined",
-            "path": [
-              "Salmon",
-            ],
-          },
+      "error": [ZodError: [
+      {
+        "expected": "string",
+        "code": "invalid_type",
+        "path": [
+          "Salmon"
         ],
-      },
+        "message": "Invalid input: expected string, received undefined"
+      }
+    ]],
       "success": false,
     }
   `);
@@ -77,35 +73,31 @@ test("literal exhaustiveness", () => {
 
   expect(schema.safeParse({ Tuna: "asdf", Salmon: "asdf", Trout: "asdf" })).toMatchInlineSnapshot(`
     {
-      "error": ZodError {
-        "issues": [
-          {
-            "code": "unrecognized_keys",
-            "keys": [
-              "Trout",
-            ],
-            "message": "Unrecognized key: "Trout"",
-            "path": [],
-          },
+      "error": [ZodError: [
+      {
+        "code": "unrecognized_keys",
+        "keys": [
+          "Trout"
         ],
-      },
+        "path": [],
+        "message": "Unrecognized key: \\"Trout\\""
+      }
+    ]],
       "success": false,
     }
   `);
   expect(schema.safeParse({ Tuna: "asdf" })).toMatchInlineSnapshot(`
     {
-      "error": ZodError {
-        "issues": [
-          {
-            "code": "invalid_type",
-            "expected": "string",
-            "message": "Invalid input: expected string, received undefined",
-            "path": [
-              "Salmon",
-            ],
-          },
+      "error": [ZodError: [
+      {
+        "expected": "string",
+        "code": "invalid_type",
+        "path": [
+          "Salmon"
         ],
-      },
+        "message": "Invalid input: expected string, received undefined"
+      }
+    ]],
       "success": false,
     }
   `);
@@ -120,35 +112,31 @@ test("pipe exhaustiveness", () => {
 
   expect(schema.safeParse({ Tuna: "asdf", Salmon: "asdf", Trout: "asdf" })).toMatchInlineSnapshot(`
     {
-      "error": ZodError {
-        "issues": [
-          {
-            "code": "unrecognized_keys",
-            "keys": [
-              "Trout",
-            ],
-            "message": "Unrecognized key: "Trout"",
-            "path": [],
-          },
+      "error": [ZodError: [
+      {
+        "code": "unrecognized_keys",
+        "keys": [
+          "Trout"
         ],
-      },
+        "path": [],
+        "message": "Unrecognized key: \\"Trout\\""
+      }
+    ]],
       "success": false,
     }
   `);
   expect(schema.safeParse({ Tuna: "asdf" })).toMatchInlineSnapshot(`
     {
-      "error": ZodError {
-        "issues": [
-          {
-            "code": "invalid_type",
-            "expected": "string",
-            "message": "Invalid input: expected string, received undefined",
-            "path": [
-              "Salmon",
-            ],
-          },
+      "error": [ZodError: [
+      {
+        "expected": "string",
+        "code": "invalid_type",
+        "path": [
+          "Salmon"
         ],
-      },
+        "message": "Invalid input: expected string, received undefined"
+      }
+    ]],
       "success": false,
     }
   `);
@@ -163,35 +151,31 @@ test("union exhaustiveness", () => {
 
   expect(schema.safeParse({ Tuna: "asdf", Salmon: "asdf", Trout: "asdf" })).toMatchInlineSnapshot(`
     {
-      "error": ZodError {
-        "issues": [
-          {
-            "code": "unrecognized_keys",
-            "keys": [
-              "Trout",
-            ],
-            "message": "Unrecognized key: "Trout"",
-            "path": [],
-          },
+      "error": [ZodError: [
+      {
+        "code": "unrecognized_keys",
+        "keys": [
+          "Trout"
         ],
-      },
+        "path": [],
+        "message": "Unrecognized key: \\"Trout\\""
+      }
+    ]],
       "success": false,
     }
   `);
   expect(schema.safeParse({ Tuna: "asdf" })).toMatchInlineSnapshot(`
     {
-      "error": ZodError {
-        "issues": [
-          {
-            "code": "invalid_type",
-            "expected": "string",
-            "message": "Invalid input: expected string, received undefined",
-            "path": [
-              "Salmon",
-            ],
-          },
+      "error": [ZodError: [
+      {
+        "expected": "string",
+        "code": "invalid_type",
+        "path": [
+          "Salmon"
         ],
-      },
+        "message": "Invalid input: expected string, received undefined"
+      }
+    ]],
       "success": false,
     }
   `);
@@ -208,16 +192,14 @@ test("string record parse - pass", () => {
   expect(schema.safeParse({ asdf: 1234 }).success).toEqual(false);
   expect(schema.safeParse("asdf")).toMatchInlineSnapshot(`
     {
-      "error": ZodError {
-        "issues": [
-          {
-            "code": "invalid_type",
-            "expected": "record",
-            "message": "Invalid input: expected record, received string",
-            "path": [],
-          },
-        ],
-      },
+      "error": [ZodError: [
+      {
+        "expected": "record",
+        "code": "invalid_type",
+        "path": [],
+        "message": "Invalid input: expected record, received string"
+      }
+    ]],
       "success": false,
     }
   `);
@@ -325,28 +307,26 @@ test("async parsing", async () => {
   const result = await schema.safeParseAsync(data);
   expect(result.success).toEqual(false);
   expect(result.error).toMatchInlineSnapshot(`
-    ZodError {
-      "issues": [
-        {
-          "code": "custom",
-          "message": "Invalid input",
-          "path": [
-            "foo",
-          ],
-        },
-        {
-          "code": "custom",
-          "message": "Invalid input",
-          "path": [
-            "baz",
-          ],
-        },
-        {
-          "code": "custom",
-          "message": "Invalid input",
-          "path": [],
-        },
-      ],
-    }
+    [ZodError: [
+      {
+        "code": "custom",
+        "path": [
+          "foo"
+        ],
+        "message": "Invalid input"
+      },
+      {
+        "code": "custom",
+        "path": [
+          "baz"
+        ],
+        "message": "Invalid input"
+      },
+      {
+        "code": "custom",
+        "path": [],
+        "message": "Invalid input"
+      }
+    ]]
   `);
 });

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

@@ -94,16 +94,14 @@ test("throws when a Map is given", () => {
   const result = stringSet.safeParse(new Map([]));
   expect(result.success).toEqual(false);
   expect(result.error).toMatchInlineSnapshot(`
-    ZodError {
-      "issues": [
-        {
-          "code": "invalid_type",
-          "expected": "set",
-          "message": "Invalid input: expected set, received Map",
-          "path": [],
-        },
-      ],
-    }
+    [ZodError: [
+      {
+        "expected": "set",
+        "code": "invalid_type",
+        "path": [],
+        "message": "Invalid input: expected set, received Map"
+      }
+    ]]
   `);
 });
 
@@ -112,16 +110,14 @@ test("throws when the given set has invalid input", () => {
   expect(result.success).toEqual(false);
   expect(result.error!.issues.length).toEqual(1);
   expect(result.error).toMatchInlineSnapshot(`
-    ZodError {
-      "issues": [
-        {
-          "code": "invalid_type",
-          "expected": "string",
-          "message": "Invalid input: expected string, received symbol",
-          "path": [],
-        },
-      ],
-    }
+    [ZodError: [
+      {
+        "expected": "string",
+        "code": "invalid_type",
+        "path": [],
+        "message": "Invalid input: expected string, received symbol"
+      }
+    ]]
   `);
 });
 
@@ -130,22 +126,20 @@ test("throws when the given set has multiple invalid entries", () => {
   expect(result.success).toEqual(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": [],
-        },
-        {
-          "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"
+      },
+      {
+        "expected": "string",
+        "code": "invalid_type",
+        "path": [],
+        "message": "Invalid input: expected string, received number"
+      }
+    ]]
   `);
 });