zod 3.25.4 → 3.25.6

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);