zod 3.26.0-canary.20250703T011142 → 3.26.0-canary.20250703T025502

package/src/v3/tests/default.test.ts

@@ -0,0 +1,112 @@
+// @ts-ignore TS6133
+import { expect, test } from "vitest";
+
+import { z } from "zod/v3";
+import { util } from "../helpers/util.js";
+
+test("basic defaults", () => {
+  expect(z.string().default("default").parse(undefined)).toBe("default");
+});
+
+test("default with transform", () => {
+  const stringWithDefault = z
+    .string()
+    .transform((val) => val.toUpperCase())
+    .default("default");
+  expect(stringWithDefault.parse(undefined)).toBe("DEFAULT");
+  expect(stringWithDefault).toBeInstanceOf(z.ZodDefault);
+  expect(stringWithDefault._def.innerType).toBeInstanceOf(z.ZodEffects);
+  expect(stringWithDefault._def.innerType._def.schema).toBeInstanceOf(z.ZodSchema);
+
+  type inp = z.input<typeof stringWithDefault>;
+  util.assertEqual<inp, string | undefined>(true);
+  type out = z.output<typeof stringWithDefault>;
+  util.assertEqual<out, string>(true);
+});
+
+test("default on existing optional", () => {
+  const stringWithDefault = z.string().optional().default("asdf");
+  expect(stringWithDefault.parse(undefined)).toBe("asdf");
+  expect(stringWithDefault).toBeInstanceOf(z.ZodDefault);
+  expect(stringWithDefault._def.innerType).toBeInstanceOf(z.ZodOptional);
+  expect(stringWithDefault._def.innerType._def.innerType).toBeInstanceOf(z.ZodString);
+
+  type inp = z.input<typeof stringWithDefault>;
+  util.assertEqual<inp, string | undefined>(true);
+  type out = z.output<typeof stringWithDefault>;
+  util.assertEqual<out, string>(true);
+});
+
+test("optional on default", () => {
+  const stringWithDefault = z.string().default("asdf").optional();
+
+  type inp = z.input<typeof stringWithDefault>;
+  util.assertEqual<inp, string | undefined>(true);
+  type out = z.output<typeof stringWithDefault>;
+  util.assertEqual<out, string | undefined>(true);
+});
+
+test("complex chain example", () => {
+  const complex = z
+    .string()
+    .default("asdf")
+    .transform((val) => val.toUpperCase())
+    .default("qwer")
+    .removeDefault()
+    .optional()
+    .default("asdfasdf");
+
+  expect(complex.parse(undefined)).toBe("ASDFASDF");
+});
+
+test("removeDefault", () => {
+  const stringWithRemovedDefault = z.string().default("asdf").removeDefault();
+
+  type out = z.output<typeof stringWithRemovedDefault>;
+  util.assertEqual<out, string>(true);
+});
+
+test("nested", () => {
+  const inner = z.string().default("asdf");
+  const outer = z.object({ inner }).default({
+    inner: undefined,
+  });
+  type input = z.input<typeof outer>;
+  util.assertEqual<input, { inner?: string | undefined } | undefined>(true);
+  type out = z.output<typeof outer>;
+  util.assertEqual<out, { inner: string }>(true);
+  expect(outer.parse(undefined)).toEqual({ inner: "asdf" });
+  expect(outer.parse({})).toEqual({ inner: "asdf" });
+  expect(outer.parse({ inner: undefined })).toEqual({ inner: "asdf" });
+});
+
+test("chained defaults", () => {
+  const stringWithDefault = z.string().default("inner").default("outer");
+  const result = stringWithDefault.parse(undefined);
+  expect(result).toEqual("outer");
+});
+
+test("factory", () => {
+  expect(z.ZodDefault.create(z.string(), { default: "asdf" }).parse(undefined)).toEqual("asdf");
+});
+
+test("native enum", () => {
+  enum Fruits {
+    apple = "apple",
+    orange = "orange",
+  }
+
+  const schema = z.object({
+    fruit: z.nativeEnum(Fruits).default(Fruits.apple),
+  });
+
+  expect(schema.parse({})).toEqual({ fruit: Fruits.apple });
+});
+
+test("enum", () => {
+  const schema = z.object({
+    fruit: z.enum(["apple", "orange"]).default("apple"),
+  });
+
+  expect(schema.parse({})).toEqual({ fruit: "apple" });
+});

package/src/v3/tests/description.test.ts

@@ -0,0 +1,33 @@
+// @ts-ignore TS6133
+import { expect, test } from "vitest";
+
+import * as z from "zod/v3";
+
+const description = "a description";
+
+test("passing `description` to schema should add a description", () => {
+  expect(z.string({ description }).description).toEqual(description);
+  expect(z.number({ description }).description).toEqual(description);
+  expect(z.boolean({ description }).description).toEqual(description);
+});
+
+test("`.describe` should add a description", () => {
+  expect(z.string().describe(description).description).toEqual(description);
+  expect(z.number().describe(description).description).toEqual(description);
+  expect(z.boolean().describe(description).description).toEqual(description);
+});
+
+test("description should carry over to chained schemas", () => {
+  const schema = z.string({ description });
+  expect(schema.description).toEqual(description);
+  expect(schema.optional().description).toEqual(description);
+  expect(schema.optional().nullable().default("default").description).toEqual(description);
+});
+
+test("description should not carry over to chained array schema", () => {
+  const schema = z.string().describe(description);
+
+  expect(schema.description).toEqual(description);
+  expect(schema.array().description).toEqual(undefined);
+  expect(z.array(schema).description).toEqual(undefined);
+});

package/src/v3/tests/discriminated-unions.test.ts

@@ -0,0 +1,315 @@
+// @ts-ignore TS6133
+import { expect, test } from "vitest";
+
+import * as z from "zod/v3";
+
+test("valid", () => {
+  expect(
+    z
+      .discriminatedUnion("type", [
+        z.object({ type: z.literal("a"), a: z.string() }),
+        z.object({ type: z.literal("b"), b: z.string() }),
+      ])
+      .parse({ type: "a", a: "abc" })
+  ).toEqual({ type: "a", a: "abc" });
+});
+
+test("valid - discriminator value of various primitive types", () => {
+  const schema = z.discriminatedUnion("type", [
+    z.object({ type: z.literal("1"), val: z.literal(1) }),
+    z.object({ type: z.literal(1), val: z.literal(2) }),
+    z.object({ type: z.literal(BigInt(1)), val: z.literal(3) }),
+    z.object({ type: z.literal("true"), val: z.literal(4) }),
+    z.object({ type: z.literal(true), val: z.literal(5) }),
+    z.object({ type: z.literal("null"), val: z.literal(6) }),
+    z.object({ type: z.literal(null), val: z.literal(7) }),
+    z.object({ type: z.literal("undefined"), val: z.literal(8) }),
+    z.object({ type: z.literal(undefined), val: z.literal(9) }),
+    z.object({ type: z.literal("transform"), val: z.literal(10) }),
+    z.object({ type: z.literal("refine"), val: z.literal(11) }),
+    z.object({ type: z.literal("superRefine"), val: z.literal(12) }),
+  ]);
+
+  expect(schema.parse({ type: "1", val: 1 })).toEqual({ type: "1", val: 1 });
+  expect(schema.parse({ type: 1, val: 2 })).toEqual({ type: 1, val: 2 });
+  expect(schema.parse({ type: BigInt(1), val: 3 })).toEqual({
+    type: BigInt(1),
+    val: 3,
+  });
+  expect(schema.parse({ type: "true", val: 4 })).toEqual({
+    type: "true",
+    val: 4,
+  });
+  expect(schema.parse({ type: true, val: 5 })).toEqual({
+    type: true,
+    val: 5,
+  });
+  expect(schema.parse({ type: "null", val: 6 })).toEqual({
+    type: "null",
+    val: 6,
+  });
+  expect(schema.parse({ type: null, val: 7 })).toEqual({
+    type: null,
+    val: 7,
+  });
+  expect(schema.parse({ type: "undefined", val: 8 })).toEqual({
+    type: "undefined",
+    val: 8,
+  });
+  expect(schema.parse({ type: undefined, val: 9 })).toEqual({
+    type: undefined,
+    val: 9,
+  });
+});
+
+test("invalid - null", () => {
+  try {
+    z.discriminatedUnion("type", [
+      z.object({ type: z.literal("a"), a: z.string() }),
+      z.object({ type: z.literal("b"), b: z.string() }),
+    ]).parse(null);
+    throw new Error();
+  } catch (e: any) {
+    expect(JSON.parse(e.message)).toEqual([
+      {
+        code: z.ZodIssueCode.invalid_type,
+        expected: z.ZodParsedType.object,
+        message: "Expected object, received null",
+        received: z.ZodParsedType.null,
+        path: [],
+      },
+    ]);
+  }
+});
+
+test("invalid discriminator value", () => {
+  try {
+    z.discriminatedUnion("type", [
+      z.object({ type: z.literal("a"), a: z.string() }),
+      z.object({ type: z.literal("b"), b: z.string() }),
+    ]).parse({ type: "x", a: "abc" });
+    throw new Error();
+  } catch (e: any) {
+    expect(JSON.parse(e.message)).toEqual([
+      {
+        code: z.ZodIssueCode.invalid_union_discriminator,
+        options: ["a", "b"],
+        message: "Invalid discriminator value. Expected 'a' | 'b'",
+        path: ["type"],
+      },
+    ]);
+  }
+});
+
+test("valid discriminator value, invalid data", () => {
+  try {
+    z.discriminatedUnion("type", [
+      z.object({ type: z.literal("a"), a: z.string() }),
+      z.object({ type: z.literal("b"), b: z.string() }),
+    ]).parse({ type: "a", b: "abc" });
+    throw new Error();
+  } catch (e: any) {
+    expect(JSON.parse(e.message)).toEqual([
+      {
+        code: z.ZodIssueCode.invalid_type,
+        expected: z.ZodParsedType.string,
+        message: "Required",
+        path: ["a"],
+        received: z.ZodParsedType.undefined,
+      },
+    ]);
+  }
+});
+
+test("wrong schema - missing discriminator", () => {
+  try {
+    z.discriminatedUnion("type", [
+      z.object({ type: z.literal("a"), a: z.string() }),
+      z.object({ b: z.string() }) as any,
+    ]);
+    throw new Error();
+  } catch (e: any) {
+    expect(e.message.includes("could not be extracted")).toBe(true);
+  }
+});
+
+test("wrong schema - duplicate discriminator values", () => {
+  try {
+    z.discriminatedUnion("type", [
+      z.object({ type: z.literal("a"), a: z.string() }),
+      z.object({ type: z.literal("a"), b: z.string() }),
+    ]);
+    throw new Error();
+  } catch (e: any) {
+    expect(e.message.includes("has duplicate value")).toEqual(true);
+  }
+});
+
+test("async - valid", async () => {
+  expect(
+    await z
+      .discriminatedUnion("type", [
+        z.object({
+          type: z.literal("a"),
+          a: z
+            .string()
+            .refine(async () => true)
+            .transform(async (val) => Number(val)),
+        }),
+        z.object({
+          type: z.literal("b"),
+          b: z.string(),
+        }),
+      ])
+      .parseAsync({ type: "a", a: "1" })
+  ).toEqual({ type: "a", a: 1 });
+});
+
+test("async - invalid", async () => {
+  try {
+    await z
+      .discriminatedUnion("type", [
+        z.object({
+          type: z.literal("a"),
+          a: z
+            .string()
+            .refine(async () => true)
+            .transform(async (val) => val),
+        }),
+        z.object({
+          type: z.literal("b"),
+          b: z.string(),
+        }),
+      ])
+      .parseAsync({ type: "a", a: 1 });
+    throw new Error();
+  } catch (e: any) {
+    expect(JSON.parse(e.message)).toEqual([
+      {
+        code: "invalid_type",
+        expected: "string",
+        received: "number",
+        path: ["a"],
+        message: "Expected string, received number",
+      },
+    ]);
+  }
+});
+
+test("valid - literals with .default or .preprocess", () => {
+  const schema = z.discriminatedUnion("type", [
+    z.object({
+      type: z.literal("foo").default("foo"),
+      a: z.string(),
+    }),
+    z.object({
+      type: z.literal("custom"),
+      method: z.string(),
+    }),
+    z.object({
+      type: z.preprocess((val) => String(val), z.literal("bar")),
+      c: z.string(),
+    }),
+  ]);
+  expect(schema.parse({ type: "foo", a: "foo" })).toEqual({
+    type: "foo",
+    a: "foo",
+  });
+});
+
+test("enum and nativeEnum", () => {
+  enum MyEnum {
+    d = 0,
+    e = "e",
+  }
+
+  const schema = z.discriminatedUnion("key", [
+    z.object({
+      key: z.literal("a"),
+      // Add other properties specific to this option
+    }),
+    z.object({
+      key: z.enum(["b", "c"]),
+      // Add other properties specific to this option
+    }),
+    z.object({
+      key: z.nativeEnum(MyEnum),
+      // Add other properties specific to this option
+    }),
+  ]);
+
+  // type schema = z.infer<typeof schema>;
+
+  schema.parse({ key: "a" });
+  schema.parse({ key: "b" });
+  schema.parse({ key: "c" });
+  schema.parse({ key: MyEnum.d });
+  schema.parse({ key: MyEnum.e });
+  schema.parse({ key: "e" });
+});
+
+test("branded", () => {
+  const schema = z.discriminatedUnion("key", [
+    z.object({
+      key: z.literal("a"),
+      // Add other properties specific to this option
+    }),
+    z.object({
+      key: z.literal("b").brand("asdfaf"),
+      // Add other properties specific to this option
+    }),
+  ]);
+
+  // type schema = z.infer<typeof schema>;
+
+  schema.parse({ key: "a" });
+  schema.parse({ key: "b" });
+  expect(() => {
+    schema.parse({ key: "c" });
+  }).toThrow();
+});
+
+test("optional and nullable", () => {
+  const schema = z.discriminatedUnion("key", [
+    z.object({
+      key: z.literal("a").optional(),
+      a: z.literal(true),
+    }),
+    z.object({
+      key: z.literal("b").nullable(),
+      b: z.literal(true),
+      // Add other properties specific to this option
+    }),
+  ]);
+
+  type schema = z.infer<typeof schema>;
+  z.util.assertEqual<schema, { key?: "a" | undefined; a: true } | { key: "b" | null; b: true }>(true);
+
+  schema.parse({ key: "a", a: true });
+  schema.parse({ key: undefined, a: true });
+  schema.parse({ key: "b", b: true });
+  schema.parse({ key: null, b: true });
+  expect(() => {
+    schema.parse({ key: null, a: true });
+  }).toThrow();
+  expect(() => {
+    schema.parse({ key: "b", a: true });
+  }).toThrow();
+
+  const value = schema.parse({ key: null, b: true });
+
+  if (!("key" in value)) value.a;
+  if (value.key === undefined) value.a;
+  if (value.key === "a") value.a;
+  if (value.key === "b") value.b;
+  if (value.key === null) value.b;
+});
+
+test("readonly array of options", () => {
+  const options = [
+    z.object({ type: z.literal("x"), val: z.literal(1) }),
+    z.object({ type: z.literal("y"), val: z.literal(2) }),
+  ] as const;
+
+  expect(z.discriminatedUnion("type", options).parse({ type: "x", val: 1 })).toEqual({ type: "x", val: 1 });
+});

package/src/v3/tests/enum.test.ts

@@ -0,0 +1,80 @@
+// @ts-ignore TS6133
+import { expect, test } from "vitest";
+
+import * as z from "zod/v3";
+import { util } from "../helpers/util.js";
+
+test("create enum", () => {
+  const MyEnum = z.enum(["Red", "Green", "Blue"]);
+  expect(MyEnum.Values.Red).toEqual("Red");
+  expect(MyEnum.Enum.Red).toEqual("Red");
+  expect(MyEnum.enum.Red).toEqual("Red");
+});
+
+test("infer enum", () => {
+  const MyEnum = z.enum(["Red", "Green", "Blue"]);
+  type MyEnum = z.infer<typeof MyEnum>;
+  util.assertEqual<MyEnum, "Red" | "Green" | "Blue">(true);
+});
+
+test("get options", () => {
+  expect(z.enum(["tuna", "trout"]).options).toEqual(["tuna", "trout"]);
+});
+
+test("readonly enum", () => {
+  const HTTP_SUCCESS = ["200", "201"] as const;
+  const arg = z.enum(HTTP_SUCCESS);
+  type arg = z.infer<typeof arg>;
+  util.assertEqual<arg, "200" | "201">(true);
+
+  arg.parse("201");
+  expect(() => arg.parse("202")).toThrow();
+});
+
+test("error params", () => {
+  const result = z.enum(["test"], { required_error: "REQUIRED" }).safeParse(undefined);
+  expect(result.success).toEqual(false);
+  if (!result.success) {
+    expect(result.error.issues[0].message).toEqual("REQUIRED");
+  }
+});
+
+test("extract/exclude", () => {
+  const foods = ["Pasta", "Pizza", "Tacos", "Burgers", "Salad"] as const;
+  const FoodEnum = z.enum(foods);
+  const ItalianEnum = FoodEnum.extract(["Pasta", "Pizza"]);
+  const UnhealthyEnum = FoodEnum.exclude(["Salad"]);
+  const EmptyFoodEnum = FoodEnum.exclude(foods);
+
+  util.assertEqual<z.infer<typeof ItalianEnum>, "Pasta" | "Pizza">(true);
+  util.assertEqual<z.infer<typeof UnhealthyEnum>, "Pasta" | "Pizza" | "Tacos" | "Burgers">(true);
+  // @ts-expect-error TS2344
+  util.assertEqual<typeof EmptyFoodEnum, z.ZodEnum<[]>>(true);
+  util.assertEqual<z.infer<typeof EmptyFoodEnum>, never>(true);
+});
+
+test("error map in extract/exclude", () => {
+  const foods = ["Pasta", "Pizza", "Tacos", "Burgers", "Salad"] as const;
+  const FoodEnum = z.enum(foods, {
+    errorMap: () => ({ message: "This is not food!" }),
+  });
+  const ItalianEnum = FoodEnum.extract(["Pasta", "Pizza"]);
+  const foodsError = FoodEnum.safeParse("Cucumbers");
+  const italianError = ItalianEnum.safeParse("Tacos");
+  if (!foodsError.success && !italianError.success) {
+    expect(foodsError.error.issues[0].message).toEqual(italianError.error.issues[0].message);
+  }
+
+  const UnhealthyEnum = FoodEnum.exclude(["Salad"], {
+    errorMap: () => ({ message: "This is not healthy food!" }),
+  });
+  const unhealthyError = UnhealthyEnum.safeParse("Salad");
+  if (!unhealthyError.success) {
+    expect(unhealthyError.error.issues[0].message).toEqual("This is not healthy food!");
+  }
+});
+
+test("readonly in ZodEnumDef", () => {
+  let _t!: z.ZodEnumDef<readonly ["a", "b"]>;
+  _t;
+});