zod 3.25.4 → 3.25.6

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"
+      }
+    ]]
   `);
 });
 

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,
     }
   `);