zod 4.0.0-beta.20250505T195954 → 4.0.0

package/src/v4/classic/tests/async-parsing.test.ts

@@ -0,0 +1,381 @@
+import { expect, test } from "vitest";
+
+import * as z from "zod/v4";
+
+/// string
+const stringSchema = z.string();
+
+test("string async parse", async () => {
+  const goodData = "XXX";
+  const badData = 12;
+
+  const goodResult = await stringSchema.safeParseAsync(goodData);
+  expect(goodResult.success).toBe(true);
+  if (goodResult.success) expect(goodResult.data).toEqual(goodData);
+
+  const badResult = await stringSchema.safeParseAsync(badData);
+  expect(badResult.success).toBe(false);
+  if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);
+});
+
+/// number
+const numberSchema = z.number();
+test("number async parse", async () => {
+  const goodData = 1234.2353;
+  const badData = "1234";
+
+  const goodResult = await numberSchema.safeParseAsync(goodData);
+  expect(goodResult.success).toBe(true);
+  if (goodResult.success) expect(goodResult.data).toEqual(goodData);
+
+  const badResult = await numberSchema.safeParseAsync(badData);
+  expect(badResult.success).toBe(false);
+  if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);
+});
+
+/// bigInt
+const bigIntSchema = z.bigint();
+test("bigInt async parse", async () => {
+  const goodData = BigInt(145);
+  const badData = 134;
+
+  const goodResult = await bigIntSchema.safeParseAsync(goodData);
+  expect(goodResult.success).toBe(true);
+  if (goodResult.success) expect(goodResult.data).toEqual(goodData);
+
+  const badResult = await bigIntSchema.safeParseAsync(badData);
+  expect(badResult.success).toBe(false);
+  if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);
+});
+
+/// boolean
+const booleanSchema = z.boolean();
+test("boolean async parse", async () => {
+  const goodData = true;
+  const badData = 1;
+
+  const goodResult = await booleanSchema.safeParseAsync(goodData);
+  expect(goodResult.success).toBe(true);
+  if (goodResult.success) expect(goodResult.data).toEqual(goodData);
+
+  const badResult = await booleanSchema.safeParseAsync(badData);
+  expect(badResult.success).toBe(false);
+  if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);
+});
+
+/// date
+const dateSchema = z.date();
+test("date async parse", async () => {
+  const goodData = new Date();
+  const badData = new Date().toISOString();
+
+  const goodResult = await dateSchema.safeParseAsync(goodData);
+  expect(goodResult.success).toBe(true);
+  if (goodResult.success) expect(goodResult.data).toEqual(goodData);
+
+  const badResult = await dateSchema.safeParseAsync(badData);
+  expect(badResult.success).toBe(false);
+  if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);
+});
+
+/// undefined
+const undefinedSchema = z.undefined();
+test("undefined async parse", async () => {
+  const goodData = undefined;
+  const badData = "XXX";
+
+  const goodResult = await undefinedSchema.safeParseAsync(goodData);
+  expect(goodResult.success).toBe(true);
+  if (goodResult.success) expect(goodResult.data).toEqual(undefined);
+
+  const badResult = await undefinedSchema.safeParseAsync(badData);
+  expect(badResult.success).toBe(false);
+  if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);
+});
+
+/// null
+const nullSchema = z.null();
+test("null async parse", async () => {
+  const goodData = null;
+  const badData = undefined;
+
+  const goodResult = await nullSchema.safeParseAsync(goodData);
+  expect(goodResult.success).toBe(true);
+  if (goodResult.success) expect(goodResult.data).toEqual(goodData);
+
+  const badResult = await nullSchema.safeParseAsync(badData);
+  expect(badResult.success).toBe(false);
+  if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);
+});
+
+/// any
+const anySchema = z.any();
+test("any async parse", async () => {
+  const goodData = [{}];
+  // const badData = 'XXX';
+
+  const goodResult = await anySchema.safeParseAsync(goodData);
+  expect(goodResult.success).toBe(true);
+  if (goodResult.success) expect(goodResult.data).toEqual(goodData);
+
+  // const badResult = await anySchema.safeParseAsync(badData);
+  // expect(badResult.success).toBe(false);
+  // if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);
+});
+
+/// unknown
+const unknownSchema = z.unknown();
+test("unknown async parse", async () => {
+  const goodData = ["asdf", 124, () => {}];
+  // const badData = 'XXX';
+
+  const goodResult = await unknownSchema.safeParseAsync(goodData);
+  expect(goodResult.success).toBe(true);
+  if (goodResult.success) expect(goodResult.data).toEqual(goodData);
+
+  // const badResult = await unknownSchema.safeParseAsync(badData);
+  // expect(badResult.success).toBe(false);
+  // if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);
+});
+
+/// void
+const voidSchema = z.void();
+test("void async parse", async () => {
+  const goodData = undefined;
+  const badData = 0;
+
+  const goodResult = await voidSchema.safeParseAsync(goodData);
+  expect(goodResult.success).toBe(true);
+  if (goodResult.success) expect(goodResult.data).toEqual(goodData);
+
+  const badResult = await voidSchema.safeParseAsync(badData);
+  expect(badResult.success).toBe(false);
+  if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);
+});
+
+/// array
+const arraySchema = z.array(z.string());
+test("array async parse", async () => {
+  const goodData = ["XXX"];
+  const badData = "XXX";
+
+  const goodResult = await arraySchema.safeParseAsync(goodData);
+  expect(goodResult.success).toBe(true);
+  if (goodResult.success) expect(goodResult.data).toEqual(goodData);
+
+  const badResult = await arraySchema.safeParseAsync(badData);
+  expect(badResult.success).toBe(false);
+  if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);
+});
+
+/// object
+const objectSchema = z.object({ string: z.string() });
+test("object async parse", async () => {
+  const goodData = { string: "XXX" };
+  const badData = { string: 12 };
+
+  const goodResult = await objectSchema.safeParseAsync(goodData);
+  expect(goodResult.success).toBe(true);
+  if (goodResult.success) expect(goodResult.data).toEqual(goodData);
+
+  const badResult = await objectSchema.safeParseAsync(badData);
+  expect(badResult.success).toBe(false);
+  if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);
+});
+
+/// union
+const unionSchema = z.union([z.string(), z.undefined()]);
+test("union async parse", async () => {
+  const goodData = undefined;
+  const badData = null;
+
+  const goodResult = await unionSchema.safeParseAsync(goodData);
+  expect(goodResult.success).toBe(true);
+  if (goodResult.success) expect(goodResult.data).toEqual(goodData);
+
+  const badResult = await unionSchema.safeParseAsync(badData);
+  expect(badResult.success).toBe(false);
+  if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);
+});
+
+/// record
+const recordSchema = z.record(z.string(), z.object({}));
+test("record async parse", async () => {
+  const goodData = { adsf: {}, asdf: {} };
+  const badData = [{}];
+
+  const goodResult = await recordSchema.safeParseAsync(goodData);
+  expect(goodResult.success).toBe(true);
+  if (goodResult.success) expect(goodResult.data).toEqual(goodData);
+
+  const badResult = await recordSchema.safeParseAsync(badData);
+  expect(badResult.success).toBe(false);
+  if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);
+});
+
+/// function
+// const functionSchema = z.function();
+// test("function async parse", async () => {
+//   const goodData = () => {};
+//   const badData = "XXX";
+
+//   const goodResult = await functionSchema.safeParseAsync(goodData);
+//   expect(goodResult.success).toBe(true);
+//   if (goodResult.success) expect(typeof goodResult.data).toEqual("function");
+
+//   const badResult = await functionSchema.safeParseAsync(badData);
+//   expect(badResult.success).toBe(false);
+//   if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);
+// });
+
+/// literal
+const literalSchema = z.literal("asdf");
+test("literal async parse", async () => {
+  const goodData = "asdf";
+  const badData = "asdff";
+
+  const goodResult = await literalSchema.safeParseAsync(goodData);
+  expect(goodResult.success).toBe(true);
+  if (goodResult.success) expect(goodResult.data).toEqual(goodData);
+
+  const badResult = await literalSchema.safeParseAsync(badData);
+  expect(badResult.success).toBe(false);
+  if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);
+});
+
+/// enum
+const enumSchema = z.enum(["fish", "whale"]);
+test("enum async parse", async () => {
+  const goodData = "whale";
+  const badData = "leopard";
+
+  const goodResult = await enumSchema.safeParseAsync(goodData);
+  expect(goodResult.success).toBe(true);
+  if (goodResult.success) expect(goodResult.data).toEqual(goodData);
+
+  const badResult = await enumSchema.safeParseAsync(badData);
+  expect(badResult.success).toBe(false);
+  if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);
+});
+
+/// nativeEnum
+enum nativeEnumTest {
+  asdf = "qwer",
+}
+// @ts-ignore
+const nativeEnumSchema = z.nativeEnum(nativeEnumTest);
+test("nativeEnum async parse", async () => {
+  const goodData = nativeEnumTest.asdf;
+  const badData = "asdf";
+
+  const goodResult = await nativeEnumSchema.safeParseAsync(goodData);
+  expect(goodResult.success).toBe(true);
+  if (goodResult.success) expect(goodResult.data).toEqual(goodData);
+
+  const badResult = await nativeEnumSchema.safeParseAsync(badData);
+  expect(badResult.success).toBe(false);
+  if (!badResult.success) expect(badResult.error).toBeInstanceOf(z.ZodError);
+});
+
+/// promise
+const promiseSchema = z.promise(z.number());
+test("promise async parse good", async () => {
+  const goodData = Promise.resolve(123);
+
+  const goodResult = await promiseSchema.safeParseAsync(goodData);
+  expect(goodResult.success).toBe(true);
+  expect(typeof goodResult.data).toEqual("number");
+  expect(goodResult.data).toEqual(123);
+});
+
+test("promise async parse bad", async () => {
+  const badData = Promise.resolve("XXX");
+  const badResult = await promiseSchema.safeParseAsync(badData);
+  expect(badResult.success).toBe(false);
+  expect(badResult.error).toBeInstanceOf(z.ZodError);
+});
+
+test("async validation non-empty strings", async () => {
+  const base = z.object({
+    hello: z.string().refine((x) => x && x.length > 0),
+    foo: z.string().refine((x) => x && x.length > 0),
+  });
+
+  const testval = { hello: "", foo: "" };
+  const result1 = base.safeParse(testval);
+  const result2 = base.safeParseAsync(testval);
+
+  const r1 = result1;
+  await result2.then((r2) => {
+    expect(r1.error!.issues.length).toBe(r2.error!.issues.length);
+  });
+});
+
+test("async validation multiple errors 1", async () => {
+  const base = z.object({
+    hello: z.string(),
+    foo: z.number(),
+  });
+
+  const testval = { hello: 3, foo: "hello" };
+  const result1 = base.safeParse(testval);
+  const result2 = base.safeParseAsync(testval);
+
+  await result2.then((result2) => {
+    expect(result2.error!.issues.length).toBe(result1.error!.issues.length);
+  });
+});
+
+test("async validation multiple errors 2", async () => {
+  const base = (is_async?: boolean) =>
+    z.object({
+      hello: z.string(),
+      foo: z.object({
+        bar: z.number().refine(
+          is_async
+            ? async () =>
+                new Promise((resolve) => {
+                  setTimeout(() => resolve(false), 500);
+                })
+            : () => false
+        ),
+      }),
+    });
+
+  const testval = { hello: 3, foo: { bar: 4 } };
+  const result1 = base().safeParse(testval);
+  const result2 = base(true).safeParseAsync(testval);
+
+  await result2.then((result2) => {
+    expect(result1.error!.issues.length).toBe(result2.error!.issues.length);
+  });
+});
+
+test("ensure early async failure prevents follow-up refinement checks", async () => {
+  let count = 0;
+  const base = z.object({
+    hello: z.string(),
+    foo: z
+      .number()
+      .refine(async () => {
+        count++;
+        return true;
+      })
+      .refine(async () => {
+        count++;
+        return true;
+      }, "Good"),
+  });
+
+  const testval = { hello: "bye", foo: 3 };
+  const result = await base.safeParseAsync(testval);
+  if (result.success === false) {
+    expect(result.error.issues.length).toBe(1);
+    expect(count).toBe(1);
+  }
+
+  // await result.then((r) => {
+  //   if (r.success === false) expect(r.error.issues.length).toBe(1);
+  //   expect(count).toBe(2);
+  // });
+});

package/src/v4/classic/tests/async-refinements.test.ts

@@ -0,0 +1,68 @@
+import { expect, test } from "vitest";
+
+import * as z from "zod/v4";
+
+test("async refine .parse()", async () => {
+  // throws ZodAsyncError
+  const s1 = z.string().refine(async (_val) => true);
+  expect(() => s1.safeParse("asdf")).toThrow();
+});
+
+test("async refine", async () => {
+  const s1 = z.string().refine(async (_val) => true);
+  const r1 = await s1.parseAsync("asdf");
+  expect(r1).toEqual("asdf");
+
+  const s2 = z.string().refine(async (_val) => false);
+  const r2 = await s2.safeParseAsync("asdf");
+  expect(r2.success).toBe(false);
+  expect(r2).toMatchInlineSnapshot(`
+    {
+      "error": [ZodError: [
+      {
+        "code": "custom",
+        "path": [],
+        "message": "Invalid input"
+      }
+    ]],
+      "success": false,
+    }
+  `);
+});
+
+test("async refine with Promises", async () => {
+  // expect.assertions(2);
+
+  const schema1 = z.string().refine((_val) => Promise.resolve(true));
+  const v1 = await schema1.parseAsync("asdf");
+  expect(v1).toEqual("asdf");
+
+  const schema2 = z.string().refine((_val) => Promise.resolve(false));
+  await expect(schema2.parseAsync("asdf")).rejects.toBeDefined();
+
+  const schema3 = z.string().refine((_val) => Promise.resolve(true));
+  await expect(schema3.parseAsync("asdf")).resolves.toEqual("asdf");
+  return await expect(schema3.parseAsync("qwer")).resolves.toEqual("qwer");
+});
+
+test("async refine that uses value", async () => {
+  const schema1 = z.string().refine(async (val) => {
+    return val.length > 5;
+  });
+
+  const r1 = await schema1.safeParseAsync("asdf");
+  expect(r1.success).toBe(false);
+  expect(r1.error).toMatchInlineSnapshot(`
+    [ZodError: [
+      {
+        "code": "custom",
+        "path": [],
+        "message": "Invalid input"
+      }
+    ]]
+  `);
+
+  const r2 = await schema1.safeParseAsync("asdf123");
+  expect(r2.success).toBe(true);
+  expect(r2.data).toEqual("asdf123");
+});

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

@@ -0,0 +1,7 @@
+import { expect, test } from "vitest";
+import * as z from "zod/v4";
+
+test("test this binding", () => {
+  const parse = z.string().parse;
+  expect(parse("asdf")).toBe("asdf");
+});

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

@@ -0,0 +1,54 @@
+import { expect, test } from "vitest";
+
+import * as z from "zod/v4";
+
+const gtFive = z.bigint().gt(BigInt(5));
+const gteFive = z.bigint().gte(BigInt(5));
+const ltFive = z.bigint().lt(BigInt(5));
+const lteFive = z.bigint().lte(BigInt(5));
+const positive = z.bigint().positive();
+const negative = z.bigint().negative();
+const nonnegative = z.bigint().nonnegative();
+const nonpositive = z.bigint().nonpositive();
+const multipleOfFive = z.bigint().multipleOf(BigInt(5));
+
+test("passing validations", () => {
+  z.bigint().parse(BigInt(1));
+  z.bigint().parse(BigInt(0));
+  z.bigint().parse(BigInt(-1));
+  gtFive.parse(BigInt(6));
+  gteFive.parse(BigInt(5));
+  gteFive.parse(BigInt(6));
+  ltFive.parse(BigInt(4));
+  lteFive.parse(BigInt(5));
+  lteFive.parse(BigInt(4));
+  positive.parse(BigInt(3));
+  negative.parse(BigInt(-2));
+  nonnegative.parse(BigInt(0));
+  nonnegative.parse(BigInt(7));
+  nonpositive.parse(BigInt(0));
+  nonpositive.parse(BigInt(-12));
+  multipleOfFive.parse(BigInt(15));
+});
+
+test("failing validations", () => {
+  expect(() => gtFive.parse(BigInt(5))).toThrow();
+  expect(() => gteFive.parse(BigInt(4))).toThrow();
+  expect(() => ltFive.parse(BigInt(5))).toThrow();
+  expect(() => lteFive.parse(BigInt(6))).toThrow();
+  expect(() => positive.parse(BigInt(0))).toThrow();
+  expect(() => positive.parse(BigInt(-2))).toThrow();
+  expect(() => negative.parse(BigInt(0))).toThrow();
+  expect(() => negative.parse(BigInt(3))).toThrow();
+  expect(() => nonnegative.parse(BigInt(-1))).toThrow();
+  expect(() => nonpositive.parse(BigInt(1))).toThrow();
+  expect(() => multipleOfFive.parse(BigInt(13))).toThrow();
+});
+
+test("min max getters", () => {
+  expect(z.bigint().min(BigInt(5)).minValue).toEqual(BigInt(5));
+  expect(z.bigint().min(BigInt(5)).min(BigInt(10)).minValue).toEqual(BigInt(10));
+
+  expect(z.bigint().max(BigInt(5)).maxValue).toEqual(BigInt(5));
+  expect(z.bigint().max(BigInt(5)).max(BigInt(1)).maxValue).toEqual(BigInt(1));
+});

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

@@ -0,0 +1,63 @@
+import { expectTypeOf, test } from "vitest";
+import * as z from "zod/v4";
+
+test("branded types", () => {
+  const mySchema = z
+    .object({
+      name: z.string(),
+    })
+    .brand<"superschema">();
+
+  // simple branding
+  type MySchema = z.infer<typeof mySchema>;
+
+  expectTypeOf<MySchema>().toEqualTypeOf<{ name: string } & z.$brand<"superschema">>();
+
+  const doStuff = (arg: MySchema) => arg;
+  doStuff(mySchema.parse({ name: "hello there" }));
+
+  // inheritance
+  const extendedSchema = mySchema.brand<"subschema">();
+  type ExtendedSchema = z.infer<typeof extendedSchema>;
+  expectTypeOf<ExtendedSchema>().toEqualTypeOf<{ name: string } & z.BRAND<"superschema"> & z.BRAND<"subschema">>();
+
+  doStuff(extendedSchema.parse({ name: "hello again" }));
+
+  // number branding
+  const numberSchema = z.number().brand<42>();
+  type NumberSchema = z.infer<typeof numberSchema>;
+  expectTypeOf<NumberSchema>().toEqualTypeOf<number & { [z.$brand]: { 42: true } }>();
+
+  // symbol branding
+  const MyBrand: unique symbol = Symbol("hello");
+  type MyBrand = typeof MyBrand;
+  const symbolBrand = z.number().brand<"sup">().brand<typeof MyBrand>();
+  type SymbolBrand = z.infer<typeof symbolBrand>;
+  // number & { [z.BRAND]: { sup: true, [MyBrand]: true } }
+  expectTypeOf<SymbolBrand>().toEqualTypeOf<number & z.BRAND<"sup"> & z.BRAND<MyBrand>>();
+
+  // keeping brands out of input types
+  const age = z.number().brand<"age">();
+
+  type Age = z.infer<typeof age>;
+  type AgeInput = z.input<typeof age>;
+
+  expectTypeOf<AgeInput>().not.toEqualTypeOf<Age>();
+  expectTypeOf<number>().toEqualTypeOf<AgeInput>();
+  expectTypeOf<number & z.BRAND<"age">>().toEqualTypeOf<Age>();
+
+  // @ts-expect-error
+  doStuff({ name: "hello there!" });
+});
+
+test("$branded", () => {
+  const a = z.string().brand<"a">();
+
+  expectTypeOf<typeof a>().toEqualTypeOf<z.core.$ZodBranded<z.ZodString, "a">>();
+});
+
+test("branded record", () => {
+  const recordWithBrandedNumberKeys = z.record(z.string().brand("SomeBrand"), z.number());
+  type recordWithBrandedNumberKeys = z.infer<typeof recordWithBrandedNumberKeys>;
+  expectTypeOf<recordWithBrandedNumberKeys>().toEqualTypeOf<Record<string & z.core.$brand<"SomeBrand">, number>>();
+});