zod 3.26.0-canary.20250703T013930 → 3.26.0-canary.20250703T214020

package/src/v3/tests/language-server.test.ts

@@ -0,0 +1,207 @@
+import { test } from "vitest";
+// import path from "path";
+// import { Node, Project, SyntaxKind } from "ts-morph";
+
+// import { filePath } from "./language-server.source";
+
+// The following tool is helpful for understanding the TypeScript AST associated with these tests:
+// https://ts-ast-viewer.com/ (just copy the contents of language-server.source into the viewer)
+
+test("", () => {});
+// describe("Executing Go To Definition (and therefore Find Usages and Rename Refactoring) using an IDE works on inferred object properties", () => {
+//   // Compile file developmentEnvironment.source
+//   const project = new Project({
+//     tsConfigFilePath: path.join(__dirname, "..", "..", "tsconfig.json"),
+//     skipAddingFilesFromTsConfig: true,
+//   });
+//   const sourceFile = project.addSourceFileAtPath(filePath);
+
+//   test("works for object properties inferred from z.object()", () => {
+//     // Find usage of Test.f1 property
+//     const instanceVariable =
+//       sourceFile.getVariableDeclarationOrThrow("instanceOfTest");
+//     const propertyBeingAssigned = getPropertyBeingAssigned(
+//       instanceVariable,
+//       "f1"
+//     );
+
+//     // Find definition of Test.f1 property
+//     const definitionOfProperty = propertyBeingAssigned?.getDefinitionNodes()[0];
+//     const parentOfProperty = definitionOfProperty?.getFirstAncestorByKind(
+//       SyntaxKind.VariableDeclaration
+//     );
+
+//     // Assert that find definition returned the Zod definition of Test
+//     expect(definitionOfProperty?.getText()).toEqual("f1: z.number()");
+//     expect(parentOfProperty?.getName()).toEqual("Test");
+//   });
+
+//   // test("works for first object properties inferred from z.object().merge()", () => {
+//   //   // Find usage of TestMerge.f1 property
+//   //   const instanceVariable = sourceFile.getVariableDeclarationOrThrow(
+//   //     "instanceOfTestMerge"
+//   //   );
+//   //   const propertyBeingAssigned = getPropertyBeingAssigned(
+//   //     instanceVariable,
+//   //     "f1"
+//   //   );
+
+//   //   // Find definition of TestMerge.f1 property
+//   //   const definitionOfProperty = propertyBeingAssigned?.getDefinitionNodes()[0];
+//   //   const parentOfProperty = definitionOfProperty?.getFirstAncestorByKind(
+//   //     SyntaxKind.VariableDeclaration
+//   //   );
+
+//   //   // Assert that find definition returned the Zod definition of Test
+//   //   expect(definitionOfProperty?.getText()).toEqual("f1: z.number()");
+//   //   expect(parentOfProperty?.getName()).toEqual("Test");
+//   // });
+
+//   // test("works for second object properties inferred from z.object().merge()", () => {
+//   //   // Find usage of TestMerge.f2 property
+//   //   const instanceVariable = sourceFile.getVariableDeclarationOrThrow(
+//   //     "instanceOfTestMerge"
+//   //   );
+//   //   const propertyBeingAssigned = getPropertyBeingAssigned(
+//   //     instanceVariable,
+//   //     "f2"
+//   //   );
+
+//   //   // Find definition of TestMerge.f2 property
+//   //   const definitionOfProperty = propertyBeingAssigned?.getDefinitionNodes()[0];
+//   //   const parentOfProperty = definitionOfProperty?.getFirstAncestorByKind(
+//   //     SyntaxKind.VariableDeclaration
+//   //   );
+
+//   //   // Assert that find definition returned the Zod definition of TestMerge
+//   //   expect(definitionOfProperty?.getText()).toEqual(
+//   //     "f2: z.string().optional()"
+//   //   );
+//   //   expect(parentOfProperty?.getName()).toEqual("TestMerge");
+//   // });
+
+//   test("works for first object properties inferred from z.union()", () => {
+//     // Find usage of TestUnion.f1 property
+//     const instanceVariable = sourceFile.getVariableDeclarationOrThrow(
+//       "instanceOfTestUnion"
+//     );
+//     const propertyBeingAssigned = getPropertyBeingAssigned(
+//       instanceVariable,
+//       "f1"
+//     );
+
+//     // Find definition of TestUnion.f1 property
+//     const definitionOfProperty = propertyBeingAssigned?.getDefinitionNodes()[0];
+//     const parentOfProperty = definitionOfProperty?.getFirstAncestorByKind(
+//       SyntaxKind.VariableDeclaration
+//     );
+
+//     // Assert that find definition returned the Zod definition of Test
+//     expect(definitionOfProperty?.getText()).toEqual("f1: z.number()");
+//     expect(parentOfProperty?.getName()).toEqual("Test");
+//   });
+
+//   test("works for second object properties inferred from z.union()", () => {
+//     // Find usage of TestUnion.f2 property
+//     const instanceVariable = sourceFile.getVariableDeclarationOrThrow(
+//       "instanceOfTestUnion"
+//     );
+//     const propertyBeingAssigned = getPropertyBeingAssigned(
+//       instanceVariable,
+//       "f2"
+//     );
+
+//     // Find definition of TestUnion.f2 property
+//     const definitionOfProperty = propertyBeingAssigned?.getDefinitionNodes()[0];
+//     const parentOfProperty = definitionOfProperty?.getFirstAncestorByKind(
+//       SyntaxKind.VariableDeclaration
+//     );
+
+//     // Assert that find definition returned the Zod definition of TestUnion
+//     expect(definitionOfProperty?.getText()).toEqual(
+//       "f2: z.string().optional()"
+//     );
+//     expect(parentOfProperty?.getName()).toEqual("TestUnion");
+//   });
+
+//   test("works for object properties inferred from z.object().partial()", () => {
+//     // Find usage of TestPartial.f1 property
+//     const instanceVariable = sourceFile.getVariableDeclarationOrThrow(
+//       "instanceOfTestPartial"
+//     );
+//     const propertyBeingAssigned = getPropertyBeingAssigned(
+//       instanceVariable,
+//       "f1"
+//     );
+
+//     // Find definition of TestPartial.f1 property
+//     const definitionOfProperty = propertyBeingAssigned?.getDefinitionNodes()[0];
+//     const parentOfProperty = definitionOfProperty?.getFirstAncestorByKind(
+//       SyntaxKind.VariableDeclaration
+//     );
+
+//     // Assert that find definition returned the Zod definition of Test
+//     expect(definitionOfProperty?.getText()).toEqual("f1: z.number()");
+//     expect(parentOfProperty?.getName()).toEqual("Test");
+//   });
+
+//   test("works for object properties inferred from z.object().pick()", () => {
+//     // Find usage of TestPick.f1 property
+//     const instanceVariable =
+//       sourceFile.getVariableDeclarationOrThrow("instanceOfTestPick");
+//     const propertyBeingAssigned = getPropertyBeingAssigned(
+//       instanceVariable,
+//       "f1"
+//     );
+
+//     // Find definition of TestPick.f1 property
+//     const definitionOfProperty = propertyBeingAssigned?.getDefinitionNodes()[0];
+//     const parentOfProperty = definitionOfProperty?.getFirstAncestorByKind(
+//       SyntaxKind.VariableDeclaration
+//     );
+
+//     // Assert that find definition returned the Zod definition of Test
+//     expect(definitionOfProperty?.getText()).toEqual("f1: z.number()");
+//     expect(parentOfProperty?.getName()).toEqual("Test");
+//   });
+
+//   test("works for object properties inferred from z.object().omit()", () => {
+//     // Find usage of TestOmit.f1 property
+//     const instanceVariable =
+//       sourceFile.getVariableDeclarationOrThrow("instanceOfTestOmit");
+//     const propertyBeingAssigned = getPropertyBeingAssigned(
+//       instanceVariable,
+//       "f1"
+//     );
+
+//     // Find definition of TestOmit.f1 property
+//     const definitionOfProperty = propertyBeingAssigned?.getDefinitionNodes()[0];
+//     const parentOfProperty = definitionOfProperty?.getFirstAncestorByKind(
+//       SyntaxKind.VariableDeclaration
+//     );
+
+//     // Assert that find definition returned the Zod definition of Test
+//     expect(definitionOfProperty?.getText()).toEqual("f1: z.number()");
+//     expect(parentOfProperty?.getName()).toEqual("Test");
+//   });
+// });
+
+// const getPropertyBeingAssigned = (node: Node, name: string) => {
+//   const propertyAssignment = node.forEachDescendant((descendent) =>
+//     Node.isPropertyAssignment(descendent) && descendent.getName() == name
+//       ? descendent
+//       : undefined
+//   );
+
+//   if (propertyAssignment == null)
+//     fail(`Could not find property assignment with name ${name}`);
+
+//   const propertyLiteral = propertyAssignment.getFirstDescendantByKind(
+//     SyntaxKind.Identifier
+//   );
+
+//   if (propertyLiteral == null)
+//     fail(`Could not find property literal with name ${name}`);
+
+//   return propertyLiteral;
+// };

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

@@ -0,0 +1,36 @@
+// @ts-ignore TS6133
+import { expect, test } from "vitest";
+
+import * as z from "zod/v3";
+
+const literalTuna = z.literal("tuna");
+const literalFortyTwo = z.literal(42);
+const literalTrue = z.literal(true);
+
+const terrificSymbol = Symbol("terrific");
+const literalTerrificSymbol = z.literal(terrificSymbol);
+
+test("passing validations", () => {
+  literalTuna.parse("tuna");
+  literalFortyTwo.parse(42);
+  literalTrue.parse(true);
+  literalTerrificSymbol.parse(terrificSymbol);
+});
+
+test("failing validations", () => {
+  expect(() => literalTuna.parse("shark")).toThrow();
+  expect(() => literalFortyTwo.parse(43)).toThrow();
+  expect(() => literalTrue.parse(false)).toThrow();
+  expect(() => literalTerrificSymbol.parse(Symbol("terrific"))).toThrow();
+});
+
+test("invalid_literal should have `received` field with data", () => {
+  const data = "shark";
+  const result = literalTuna.safeParse(data);
+  if (!result.success) {
+    const issue = result.error.issues[0];
+    if (issue.code === "invalid_literal") {
+      expect(issue.received).toBe(data);
+    }
+  }
+});

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

@@ -0,0 +1,110 @@
+// @ts-ignore TS6133
+import { expect, test } from "vitest";
+
+import * as z from "zod/v3";
+import { ZodIssueCode } from "zod/v3";
+import { util } from "../helpers/util.js";
+
+const stringMap = z.map(z.string(), z.string());
+type stringMap = z.infer<typeof stringMap>;
+
+test("type inference", () => {
+  util.assertEqual<stringMap, Map<string, string>>(true);
+});
+
+test("valid parse", () => {
+  const result = stringMap.safeParse(
+    new Map([
+      ["first", "foo"],
+      ["second", "bar"],
+    ])
+  );
+  expect(result.success).toEqual(true);
+  if (result.success) {
+    expect(result.data.has("first")).toEqual(true);
+    expect(result.data.has("second")).toEqual(true);
+    expect(result.data.get("first")).toEqual("foo");
+    expect(result.data.get("second")).toEqual("bar");
+  }
+});
+
+test("valid parse async", async () => {
+  const result = await stringMap.spa(
+    new Map([
+      ["first", "foo"],
+      ["second", "bar"],
+    ])
+  );
+  expect(result.success).toEqual(true);
+  if (result.success) {
+    expect(result.data.has("first")).toEqual(true);
+    expect(result.data.has("second")).toEqual(true);
+    expect(result.data.get("first")).toEqual("foo");
+    expect(result.data.get("second")).toEqual("bar");
+  }
+});
+
+test("throws when a Set is given", () => {
+  const result = stringMap.safeParse(new Set([]));
+  expect(result.success).toEqual(false);
+  if (result.success === false) {
+    expect(result.error.issues.length).toEqual(1);
+    expect(result.error.issues[0].code).toEqual(ZodIssueCode.invalid_type);
+  }
+});
+
+test("throws when the given map has invalid key and invalid input", () => {
+  const result = stringMap.safeParse(new Map([[42, Symbol()]]));
+  expect(result.success).toEqual(false);
+  if (result.success === false) {
+    expect(result.error.issues.length).toEqual(2);
+    expect(result.error.issues[0].code).toEqual(ZodIssueCode.invalid_type);
+    expect(result.error.issues[0].path).toEqual([0, "key"]);
+    expect(result.error.issues[1].code).toEqual(ZodIssueCode.invalid_type);
+    expect(result.error.issues[1].path).toEqual([0, "value"]);
+  }
+});
+
+test("throws when the given map has multiple invalid entries", () => {
+  // const result = stringMap.safeParse(new Map([[42, Symbol()]]));
+
+  const result = stringMap.safeParse(
+    new Map([
+      [1, "foo"],
+      ["bar", 2],
+    ] as [any, any][]) as Map<any, any>
+  );
+
+  // const result = stringMap.safeParse(new Map([[42, Symbol()]]));
+  expect(result.success).toEqual(false);
+  if (result.success === false) {
+    expect(result.error.issues.length).toEqual(2);
+    expect(result.error.issues[0].code).toEqual(ZodIssueCode.invalid_type);
+    expect(result.error.issues[0].path).toEqual([0, "key"]);
+    expect(result.error.issues[1].code).toEqual(ZodIssueCode.invalid_type);
+    expect(result.error.issues[1].path).toEqual([1, "value"]);
+  }
+});
+
+test("dirty", async () => {
+  const map = z.map(
+    z.string().refine((val) => val === val.toUpperCase(), {
+      message: "Keys must be uppercase",
+    }),
+    z.string()
+  );
+  const result = await map.spa(
+    new Map([
+      ["first", "foo"],
+      ["second", "bar"],
+    ])
+  );
+  expect(result.success).toEqual(false);
+  if (!result.success) {
+    expect(result.error.issues.length).toEqual(2);
+    expect(result.error.issues[0].code).toEqual(z.ZodIssueCode.custom);
+    expect(result.error.issues[0].message).toEqual("Keys must be uppercase");
+    expect(result.error.issues[1].code).toEqual(z.ZodIssueCode.custom);
+    expect(result.error.issues[1].message).toEqual("Keys must be uppercase");
+  }
+});

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

@@ -0,0 +1,4 @@
+// @ts-ignore TS6133
+import { test } from "vitest";
+
+test("masking test", () => {});

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

@@ -0,0 +1,19 @@
+// @ts-ignore TS6133
+import { test } from "vitest";
+
+import { Mocker } from "./Mocker.js";
+
+test("mocker", () => {
+  const mocker = new Mocker();
+  mocker.string;
+  mocker.number;
+  mocker.boolean;
+  mocker.null;
+  mocker.undefined;
+  mocker.stringOptional;
+  mocker.stringNullable;
+  mocker.numberOptional;
+  mocker.numberNullable;
+  mocker.booleanOptional;
+  mocker.booleanNullable;
+});

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

@@ -0,0 +1,21 @@
+// @ts-ignore TS6133
+import { expect, test } from "vitest";
+
+import * as z from "zod/v3";
+
+const schema = z.nan();
+
+test("passing validations", () => {
+  schema.parse(Number.NaN);
+  schema.parse(Number("Not a number"));
+});
+
+test("failing validations", () => {
+  expect(() => schema.parse(5)).toThrow();
+  expect(() => schema.parse("John")).toThrow();
+  expect(() => schema.parse(true)).toThrow();
+  expect(() => schema.parse(null)).toThrow();
+  expect(() => schema.parse(undefined)).toThrow();
+  expect(() => schema.parse({})).toThrow();
+  expect(() => schema.parse([])).toThrow();
+});

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

@@ -0,0 +1,87 @@
+// @ts-ignore TS6133
+import { expect, test } from "vitest";
+
+import * as z from "zod/v3";
+import { util } from "../helpers/util.js";
+
+test("nativeEnum test with consts", () => {
+  const Fruits: { Apple: "apple"; Banana: "banana" } = {
+    Apple: "apple",
+    Banana: "banana",
+  };
+  const fruitEnum = z.nativeEnum(Fruits);
+  type fruitEnum = z.infer<typeof fruitEnum>;
+  fruitEnum.parse("apple");
+  fruitEnum.parse("banana");
+  fruitEnum.parse(Fruits.Apple);
+  fruitEnum.parse(Fruits.Banana);
+  util.assertEqual<fruitEnum, "apple" | "banana">(true);
+});
+
+test("nativeEnum test with real enum", () => {
+  enum Fruits {
+    Apple = "apple",
+    Banana = "banana",
+  }
+  // @ts-ignore
+  const fruitEnum = z.nativeEnum(Fruits);
+  type fruitEnum = z.infer<typeof fruitEnum>;
+  fruitEnum.parse("apple");
+  fruitEnum.parse("banana");
+  fruitEnum.parse(Fruits.Apple);
+  fruitEnum.parse(Fruits.Banana);
+  util.assertIs<fruitEnum extends Fruits ? true : false>(true);
+});
+
+test("nativeEnum test with const with numeric keys", () => {
+  const FruitValues = {
+    Apple: 10,
+    Banana: 20,
+    // @ts-ignore
+  } as const;
+  const fruitEnum = z.nativeEnum(FruitValues);
+  type fruitEnum = z.infer<typeof fruitEnum>;
+  fruitEnum.parse(10);
+  fruitEnum.parse(20);
+  fruitEnum.parse(FruitValues.Apple);
+  fruitEnum.parse(FruitValues.Banana);
+  util.assertEqual<fruitEnum, 10 | 20>(true);
+});
+
+test("from enum", () => {
+  enum Fruits {
+    Cantaloupe = 0,
+    Apple = "apple",
+    Banana = "banana",
+  }
+
+  const FruitEnum = z.nativeEnum(Fruits as any);
+  type _FruitEnum = z.infer<typeof FruitEnum>;
+  FruitEnum.parse(Fruits.Cantaloupe);
+  FruitEnum.parse(Fruits.Apple);
+  FruitEnum.parse("apple");
+  FruitEnum.parse(0);
+  expect(() => FruitEnum.parse(1)).toThrow();
+  expect(() => FruitEnum.parse("Apple")).toThrow();
+  expect(() => FruitEnum.parse("Cantaloupe")).toThrow();
+});
+
+test("from const", () => {
+  const Greek = {
+    Alpha: "a",
+    Beta: "b",
+    Gamma: 3,
+    // @ts-ignore
+  } as const;
+
+  const GreekEnum = z.nativeEnum(Greek);
+  type _GreekEnum = z.infer<typeof GreekEnum>;
+  GreekEnum.parse("a");
+  GreekEnum.parse("b");
+  GreekEnum.parse(3);
+  expect(() => GreekEnum.parse("v")).toThrow();
+  expect(() => GreekEnum.parse("Alpha")).toThrow();
+  expect(() => GreekEnum.parse(2)).toThrow();
+
+  expect(GreekEnum.enum.Alpha).toEqual("a");
+});

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

@@ -0,0 +1,42 @@
+// @ts-ignore TS6133
+import { expect, test } from "vitest";
+
+import * as z from "zod/v3";
+
+function checkErrors(a: z.ZodTypeAny, bad: any) {
+  let expected: any;
+  try {
+    a.parse(bad);
+  } catch (error) {
+    expected = (error as z.ZodError).formErrors;
+  }
+  try {
+    a.nullable().parse(bad);
+  } catch (error) {
+    expect((error as z.ZodError).formErrors).toEqual(expected);
+  }
+}
+
+test("Should have error messages appropriate for the underlying type", () => {
+  checkErrors(z.string().min(2), 1);
+  z.string().min(2).nullable().parse(null);
+  checkErrors(z.number().gte(2), 1);
+  z.number().gte(2).nullable().parse(null);
+  checkErrors(z.boolean(), "");
+  z.boolean().nullable().parse(null);
+  checkErrors(z.null(), null);
+  z.null().nullable().parse(null);
+  checkErrors(z.null(), {});
+  z.null().nullable().parse(null);
+  checkErrors(z.object({}), 1);
+  z.object({}).nullable().parse(null);
+  checkErrors(z.tuple([]), 1);
+  z.tuple([]).nullable().parse(null);
+  checkErrors(z.unknown(), 1);
+  z.unknown().nullable().parse(null);
+});
+
+test("unwrap", () => {
+  const unwrapped = z.string().nullable().unwrap();
+  expect(unwrapped).toBeInstanceOf(z.ZodString);
+});