zod 3.25.13 → 3.25.15

package/dist/v3/tests/discriminated-unions.test.js

@@ -0,0 +1,321 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-ignore TS6133
+const vitest_1 = require("vitest");
+const z = __importStar(require("zod/v3"));
+(0, vitest_1.test)("valid", () => {
+    (0, vitest_1.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" });
+});
+(0, vitest_1.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) }),
+    ]);
+    (0, vitest_1.expect)(schema.parse({ type: "1", val: 1 })).toEqual({ type: "1", val: 1 });
+    (0, vitest_1.expect)(schema.parse({ type: 1, val: 2 })).toEqual({ type: 1, val: 2 });
+    (0, vitest_1.expect)(schema.parse({ type: BigInt(1), val: 3 })).toEqual({
+        type: BigInt(1),
+        val: 3,
+    });
+    (0, vitest_1.expect)(schema.parse({ type: "true", val: 4 })).toEqual({
+        type: "true",
+        val: 4,
+    });
+    (0, vitest_1.expect)(schema.parse({ type: true, val: 5 })).toEqual({
+        type: true,
+        val: 5,
+    });
+    (0, vitest_1.expect)(schema.parse({ type: "null", val: 6 })).toEqual({
+        type: "null",
+        val: 6,
+    });
+    (0, vitest_1.expect)(schema.parse({ type: null, val: 7 })).toEqual({
+        type: null,
+        val: 7,
+    });
+    (0, vitest_1.expect)(schema.parse({ type: "undefined", val: 8 })).toEqual({
+        type: "undefined",
+        val: 8,
+    });
+    (0, vitest_1.expect)(schema.parse({ type: undefined, val: 9 })).toEqual({
+        type: undefined,
+        val: 9,
+    });
+});
+(0, vitest_1.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) {
+        (0, vitest_1.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: [],
+            },
+        ]);
+    }
+});
+(0, vitest_1.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) {
+        (0, vitest_1.expect)(JSON.parse(e.message)).toEqual([
+            {
+                code: z.ZodIssueCode.invalid_union_discriminator,
+                options: ["a", "b"],
+                message: "Invalid discriminator value. Expected 'a' | 'b'",
+                path: ["type"],
+            },
+        ]);
+    }
+});
+(0, vitest_1.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) {
+        (0, vitest_1.expect)(JSON.parse(e.message)).toEqual([
+            {
+                code: z.ZodIssueCode.invalid_type,
+                expected: z.ZodParsedType.string,
+                message: "Required",
+                path: ["a"],
+                received: z.ZodParsedType.undefined,
+            },
+        ]);
+    }
+});
+(0, vitest_1.test)("wrong schema - missing discriminator", () => {
+    try {
+        z.discriminatedUnion("type", [
+            z.object({ type: z.literal("a"), a: z.string() }),
+            z.object({ b: z.string() }),
+        ]);
+        throw new Error();
+    }
+    catch (e) {
+        (0, vitest_1.expect)(e.message.includes("could not be extracted")).toBe(true);
+    }
+});
+(0, vitest_1.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) {
+        (0, vitest_1.expect)(e.message.includes("has duplicate value")).toEqual(true);
+    }
+});
+(0, vitest_1.test)("async - valid", async () => {
+    (0, vitest_1.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 });
+});
+(0, vitest_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) {
+        (0, vitest_1.expect)(JSON.parse(e.message)).toEqual([
+            {
+                code: "invalid_type",
+                expected: "string",
+                received: "number",
+                path: ["a"],
+                message: "Expected string, received number",
+            },
+        ]);
+    }
+});
+(0, vitest_1.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(),
+        }),
+    ]);
+    (0, vitest_1.expect)(schema.parse({ type: "foo", a: "foo" })).toEqual({
+        type: "foo",
+        a: "foo",
+    });
+});
+(0, vitest_1.test)("enum and nativeEnum", () => {
+    let MyEnum;
+    (function (MyEnum) {
+        MyEnum[MyEnum["d"] = 0] = "d";
+        MyEnum["e"] = "e";
+    })(MyEnum || (MyEnum = {}));
+    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" });
+});
+(0, vitest_1.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" });
+    (0, vitest_1.expect)(() => {
+        schema.parse({ key: "c" });
+    }).toThrow();
+});
+(0, vitest_1.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
+        }),
+    ]);
+    z.util.assertEqual(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 });
+    (0, vitest_1.expect)(() => {
+        schema.parse({ key: null, a: true });
+    }).toThrow();
+    (0, vitest_1.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;
+});
+(0, vitest_1.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) }),
+    ];
+    (0, vitest_1.expect)(z.discriminatedUnion("type", options).parse({ type: "x", val: 1 })).toEqual({ type: "x", val: 1 });
+});

package/dist/v3/tests/enum.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/v3/tests/enum.test.js

@@ -0,0 +1,91 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-ignore TS6133
+const vitest_1 = require("vitest");
+const z = __importStar(require("zod/v3"));
+const util_js_1 = require("../helpers/util.js");
+(0, vitest_1.test)("create enum", () => {
+    const MyEnum = z.enum(["Red", "Green", "Blue"]);
+    (0, vitest_1.expect)(MyEnum.Values.Red).toEqual("Red");
+    (0, vitest_1.expect)(MyEnum.Enum.Red).toEqual("Red");
+    (0, vitest_1.expect)(MyEnum.enum.Red).toEqual("Red");
+});
+(0, vitest_1.test)("infer enum", () => {
+    const MyEnum = z.enum(["Red", "Green", "Blue"]);
+    util_js_1.util.assertEqual(true);
+});
+(0, vitest_1.test)("get options", () => {
+    (0, vitest_1.expect)(z.enum(["tuna", "trout"]).options).toEqual(["tuna", "trout"]);
+});
+(0, vitest_1.test)("readonly enum", () => {
+    const HTTP_SUCCESS = ["200", "201"];
+    const arg = z.enum(HTTP_SUCCESS);
+    util_js_1.util.assertEqual(true);
+    arg.parse("201");
+    (0, vitest_1.expect)(() => arg.parse("202")).toThrow();
+});
+(0, vitest_1.test)("error params", () => {
+    const result = z.enum(["test"], { required_error: "REQUIRED" }).safeParse(undefined);
+    (0, vitest_1.expect)(result.success).toEqual(false);
+    if (!result.success) {
+        (0, vitest_1.expect)(result.error.issues[0].message).toEqual("REQUIRED");
+    }
+});
+(0, vitest_1.test)("extract/exclude", () => {
+    const foods = ["Pasta", "Pizza", "Tacos", "Burgers", "Salad"];
+    const FoodEnum = z.enum(foods);
+    const ItalianEnum = FoodEnum.extract(["Pasta", "Pizza"]);
+    const UnhealthyEnum = FoodEnum.exclude(["Salad"]);
+    const EmptyFoodEnum = FoodEnum.exclude(foods);
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+    // @ts-expect-error TS2344
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+});
+(0, vitest_1.test)("error map in extract/exclude", () => {
+    const foods = ["Pasta", "Pizza", "Tacos", "Burgers", "Salad"];
+    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) {
+        (0, vitest_1.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) {
+        (0, vitest_1.expect)(unhealthyError.error.issues[0].message).toEqual("This is not healthy food!");
+    }
+});
+(0, vitest_1.test)("readonly in ZodEnumDef", () => {
+    let _t;
+    _t;
+});

package/dist/v3/tests/error.test.d.ts

@@ -0,0 +1 @@
+export {};