zod 3.25.13 → 3.25.15

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

@@ -0,0 +1,190 @@
+"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");
+var testEnum;
+(function (testEnum) {
+    testEnum[testEnum["A"] = 0] = "A";
+    testEnum[testEnum["B"] = 1] = "B";
+})(testEnum || (testEnum = {}));
+const schemas = [
+    z.string().readonly(),
+    z.number().readonly(),
+    z.nan().readonly(),
+    z.bigint().readonly(),
+    z.boolean().readonly(),
+    z.date().readonly(),
+    z.undefined().readonly(),
+    z.null().readonly(),
+    z.any().readonly(),
+    z.unknown().readonly(),
+    z.void().readonly(),
+    z.function().args(z.string(), z.number()).readonly(),
+    z.array(z.string()).readonly(),
+    z.tuple([z.string(), z.number()]).readonly(),
+    z.map(z.string(), z.date()).readonly(),
+    z.set(z.promise(z.string())).readonly(),
+    z.record(z.string()).readonly(),
+    z.record(z.string(), z.number()).readonly(),
+    z.object({ a: z.string(), 1: z.number() }).readonly(),
+    z.nativeEnum(testEnum).readonly(),
+    z.promise(z.string()).readonly(),
+];
+(0, vitest_1.test)("flat inference", () => {
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+});
+// test("deep inference", () => {
+//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[0]>, string>(true);
+//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[1]>, number>(true);
+//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[2]>, number>(true);
+//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[3]>, bigint>(true);
+//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[4]>, boolean>(true);
+//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[5]>, Date>(true);
+//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[6]>, undefined>(true);
+//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[7]>, null>(true);
+//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[8]>, any>(true);
+//   util.assertEqual<
+//     z.infer<(typeof deepReadonlySchemas_0)[9]>,
+//     Readonly<unknown>
+//   >(true);
+//   util.assertEqual<z.infer<(typeof deepReadonlySchemas_0)[10]>, void>(true);
+//   util.assertEqual<
+//     z.infer<(typeof deepReadonlySchemas_0)[11]>,
+//     (args_0: string, args_1: number, ...args_2: unknown[]) => unknown
+//   >(true);
+//   util.assertEqual<
+//     z.infer<(typeof deepReadonlySchemas_0)[12]>,
+//     readonly string[]
+//   >(true);
+//   util.assertEqual<
+//     z.infer<(typeof deepReadonlySchemas_0)[13]>,
+//     readonly [string, number]
+//   >(true);
+//   util.assertEqual<
+//     z.infer<(typeof deepReadonlySchemas_0)[14]>,
+//     ReadonlyMap<string, Date>
+//   >(true);
+//   util.assertEqual<
+//     z.infer<(typeof deepReadonlySchemas_0)[15]>,
+//     ReadonlySet<Promise<string>>
+//   >(true);
+//   util.assertEqual<
+//     z.infer<(typeof deepReadonlySchemas_0)[16]>,
+//     Readonly<Record<string, string>>
+//   >(true);
+//   util.assertEqual<
+//     z.infer<(typeof deepReadonlySchemas_0)[17]>,
+//     Readonly<Record<string, number>>
+//   >(true);
+//   util.assertEqual<
+//     z.infer<(typeof deepReadonlySchemas_0)[18]>,
+//     { readonly a: string; readonly 1: number }
+//   >(true);
+//   util.assertEqual<
+//     z.infer<(typeof deepReadonlySchemas_0)[19]>,
+//     Readonly<testEnum>
+//   >(true);
+//   util.assertEqual<
+//     z.infer<(typeof deepReadonlySchemas_0)[20]>,
+//     Promise<string>
+//   >(true);
+//   util.assertEqual<
+//     z.infer<typeof crazyDeepReadonlySchema>,
+//     ReadonlyMap<
+//       ReadonlySet<readonly [string, number]>,
+//       {
+//         readonly a: {
+//           readonly [x: string]: readonly any[];
+//         };
+//         readonly b: {
+//           readonly c: {
+//             readonly d: {
+//               readonly e: {
+//                 readonly f: {
+//                   readonly g?: {};
+//                 };
+//               };
+//             };
+//           };
+//         };
+//       }
+//     >
+//   >(true);
+// });
+(0, vitest_1.test)("object freezing", () => {
+    (0, vitest_1.expect)(Object.isFrozen(z.array(z.string()).readonly().parse(["a"]))).toBe(true);
+    (0, vitest_1.expect)(Object.isFrozen(z.tuple([z.string(), z.number()]).readonly().parse(["a", 1]))).toBe(true);
+    (0, vitest_1.expect)(Object.isFrozen(z
+        .map(z.string(), z.date())
+        .readonly()
+        .parse(new Map([["a", new Date()]])))).toBe(true);
+    (0, vitest_1.expect)(Object.isFrozen(z
+        .set(z.promise(z.string()))
+        .readonly()
+        .parse(new Set([Promise.resolve("a")])))).toBe(true);
+    (0, vitest_1.expect)(Object.isFrozen(z.record(z.string()).readonly().parse({ a: "b" }))).toBe(true);
+    (0, vitest_1.expect)(Object.isFrozen(z.record(z.string(), z.number()).readonly().parse({ a: 1 }))).toBe(true);
+    (0, vitest_1.expect)(Object.isFrozen(z.object({ a: z.string(), 1: z.number() }).readonly().parse({ a: "b", 1: 2 }))).toBe(true);
+    (0, vitest_1.expect)(Object.isFrozen(z.promise(z.string()).readonly().parse(Promise.resolve("a")))).toBe(true);
+});
+(0, vitest_1.test)("async object freezing", async () => {
+    (0, vitest_1.expect)(Object.isFrozen(await z.array(z.string()).readonly().parseAsync(["a"]))).toBe(true);
+    (0, vitest_1.expect)(Object.isFrozen(await z.tuple([z.string(), z.number()]).readonly().parseAsync(["a", 1]))).toBe(true);
+    (0, vitest_1.expect)(Object.isFrozen(await z
+        .map(z.string(), z.date())
+        .readonly()
+        .parseAsync(new Map([["a", new Date()]])))).toBe(true);
+    (0, vitest_1.expect)(Object.isFrozen(await z
+        .set(z.promise(z.string()))
+        .readonly()
+        .parseAsync(new Set([Promise.resolve("a")])))).toBe(true);
+    (0, vitest_1.expect)(Object.isFrozen(await z.record(z.string()).readonly().parseAsync({ a: "b" }))).toBe(true);
+    (0, vitest_1.expect)(Object.isFrozen(await z.record(z.string(), z.number()).readonly().parseAsync({ a: 1 }))).toBe(true);
+    (0, vitest_1.expect)(Object.isFrozen(await z.object({ a: z.string(), 1: z.number() }).readonly().parseAsync({ a: "b", 1: 2 }))).toBe(true);
+    (0, vitest_1.expect)(Object.isFrozen(await z.promise(z.string()).readonly().parseAsync(Promise.resolve("a")))).toBe(true);
+});

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

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

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

@@ -0,0 +1,153 @@
+"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");
+const booleanRecord = z.record(z.boolean());
+const recordWithEnumKeys = z.record(z.enum(["Tuna", "Salmon"]), z.string());
+const recordWithLiteralKeys = z.record(z.union([z.literal("Tuna"), z.literal("Salmon")]), z.string());
+(0, vitest_1.test)("type inference", () => {
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+    util_js_1.util.assertEqual(true);
+});
+(0, vitest_1.test)("methods", () => {
+    booleanRecord.optional();
+    booleanRecord.nullable();
+});
+(0, vitest_1.test)("string record parse - pass", () => {
+    booleanRecord.parse({
+        k1: true,
+        k2: false,
+        1234: false,
+    });
+});
+(0, vitest_1.test)("string record parse - fail", () => {
+    const badCheck = () => booleanRecord.parse({
+        asdf: 1234,
+    });
+    (0, vitest_1.expect)(badCheck).toThrow();
+    (0, vitest_1.expect)(() => booleanRecord.parse("asdf")).toThrow();
+});
+(0, vitest_1.test)("string record parse - fail", () => {
+    const badCheck = () => booleanRecord.parse({
+        asdf: {},
+    });
+    (0, vitest_1.expect)(badCheck).toThrow();
+});
+(0, vitest_1.test)("string record parse - fail", () => {
+    const badCheck = () => booleanRecord.parse({
+        asdf: [],
+    });
+    (0, vitest_1.expect)(badCheck).toThrow();
+});
+(0, vitest_1.test)("key schema", () => {
+    const result1 = recordWithEnumKeys.parse({
+        Tuna: "asdf",
+        Salmon: "asdf",
+    });
+    (0, vitest_1.expect)(result1).toEqual({
+        Tuna: "asdf",
+        Salmon: "asdf",
+    });
+    const result2 = recordWithLiteralKeys.parse({
+        Tuna: "asdf",
+        Salmon: "asdf",
+    });
+    (0, vitest_1.expect)(result2).toEqual({
+        Tuna: "asdf",
+        Salmon: "asdf",
+    });
+    // shouldn't require us to specify all props in record
+    const result3 = recordWithEnumKeys.parse({
+        Tuna: "abcd",
+    });
+    (0, vitest_1.expect)(result3).toEqual({
+        Tuna: "abcd",
+    });
+    // shouldn't require us to specify all props in record
+    const result4 = recordWithLiteralKeys.parse({
+        Salmon: "abcd",
+    });
+    (0, vitest_1.expect)(result4).toEqual({
+        Salmon: "abcd",
+    });
+    (0, vitest_1.expect)(() => recordWithEnumKeys.parse({
+        Tuna: "asdf",
+        Salmon: "asdf",
+        Trout: "asdf",
+    })).toThrow();
+    (0, vitest_1.expect)(() => recordWithLiteralKeys.parse({
+        Tuna: "asdf",
+        Salmon: "asdf",
+        Trout: "asdf",
+    })).toThrow();
+});
+// test("record element", () => {
+//   expect(booleanRecord.element).toBeInstanceOf(z.ZodBoolean);
+// });
+(0, vitest_1.test)("key and value getters", () => {
+    const rec = z.record(z.string(), z.number());
+    rec.keySchema.parse("asdf");
+    rec.valueSchema.parse(1234);
+    rec.element.parse(1234);
+});
+(0, vitest_1.test)("is not vulnerable to prototype pollution", async () => {
+    const rec = z.record(z.object({
+        a: z.string(),
+    }));
+    const data = JSON.parse(`
+    {
+      "__proto__": {
+        "a": "evil"
+      },
+      "b": {
+        "a": "good"
+      }
+    }
+  `);
+    const obj1 = rec.parse(data);
+    (0, vitest_1.expect)(obj1.a).toBeUndefined();
+    const obj2 = rec.safeParse(data);
+    (0, vitest_1.expect)(obj2.success).toBe(true);
+    if (obj2.success) {
+        (0, vitest_1.expect)(obj2.data.a).toBeUndefined();
+    }
+    const obj3 = await rec.parseAsync(data);
+    (0, vitest_1.expect)(obj3.a).toBeUndefined();
+    const obj4 = await rec.safeParseAsync(data);
+    (0, vitest_1.expect)(obj4.success).toBe(true);
+    if (obj4.success) {
+        (0, vitest_1.expect)(obj4.data.a).toBeUndefined();
+    }
+});
+(0, vitest_1.test)("dont parse undefined values", () => {
+    const result1 = z.record(z.any()).parse({ foo: undefined });
+    (0, vitest_1.expect)(result1).toEqual({
+        foo: undefined,
+    });
+});

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

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

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

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// @ts-ignore TS6133
+const vitest_1 = require("vitest");
+const v3_1 = require("zod/v3");
+const testCategory = {
+    name: "I",
+    subcategories: [
+        {
+            name: "A",
+            subcategories: [
+                {
+                    name: "1",
+                    subcategories: [
+                        {
+                            name: "a",
+                            subcategories: [],
+                        },
+                    ],
+                },
+            ],
+        },
+    ],
+};
+(0, vitest_1.test)("recursion with z.late.object", () => {
+    const Category = v3_1.z.late.object(() => ({
+        name: v3_1.z.string(),
+        subcategories: v3_1.z.array(Category),
+    }));
+    Category.parse(testCategory);
+});
+(0, vitest_1.test)("recursion with z.lazy", () => {
+    const Category = v3_1.z.lazy(() => v3_1.z.object({
+        name: v3_1.z.string(),
+        subcategories: v3_1.z.array(Category),
+    }));
+    Category.parse(testCategory);
+});
+(0, vitest_1.test)("schema getter", () => {
+    v3_1.z.lazy(() => v3_1.z.string()).schema.parse("asdf");
+});
+const linkedListExample = {
+    value: 1,
+    next: {
+        value: 2,
+        next: {
+            value: 3,
+            next: {
+                value: 4,
+                next: null,
+            },
+        },
+    },
+};
+(0, vitest_1.test)("recursion involving union type", () => {
+    const LinkedListSchema = v3_1.z.lazy(() => v3_1.z.union([
+        v3_1.z.null(),
+        v3_1.z.object({
+            value: v3_1.z.number(),
+            next: LinkedListSchema,
+        }),
+    ]));
+    LinkedListSchema.parse(linkedListExample);
+});
+// interface A {
+//   val: number;
+//   b: B;
+// }
+// interface B {
+//   val: number;
+//   a: A;
+// }
+// const A: z.ZodType<A> = z.late.object(() => ({
+//   val: z.number(),
+//   b: B,
+// }));
+// const B: z.ZodType<B> = z.late.object(() => ({
+//   val: z.number(),
+//   a: A,
+// }));
+// const Alazy: z.ZodType<A> = z.lazy(() => z.object({
+//   val: z.number(),
+//   b: B,
+// }));
+// const Blazy: z.ZodType<B> = z.lazy(() => z.object({
+//   val: z.number(),
+//   a: A,
+// }));
+// const a: any = { val: 1 };
+// const b: any = { val: 2 };
+// a.b = b;
+// b.a = a;
+// test('valid check', () => {
+//   A.parse(a);
+//   B.parse(b);
+// });
+// test("valid check lazy", () => {
+//   A.parse({val:1, b:});
+//   B.parse(b);
+// });
+// test('masking check', () => {
+//   const FragmentOnA = z
+//     .object({
+//       val: z.number(),
+//       b: z
+//         .object({
+//           val: z.number(),
+//           a: z
+//             .object({
+//               val: z.number(),
+//             })
+//             .nonstrict(),
+//         })
+//         .nonstrict(),
+//     })
+//     .nonstrict();
+//   const fragment = FragmentOnA.parse(a);
+//   fragment;
+// });
+// test('invalid check', () => {
+//   expect(() => A.parse({} as any)).toThrow();
+// });
+// test('schema getter', () => {
+//   (A as z.ZodLazy<any>).schema;
+// });
+// test("self recursion with cyclical data", () => {
+//   interface Category {
+//     name: string;
+//     subcategories: Category[];
+//   }
+//   const Category: z.ZodType<Category> = z.late.object(() => ({
+//     name: z.string(),
+//     subcategories: z.array(Category),
+//   }));
+//   const untypedCategory: any = {
+//     name: "Category A",
+//   };
+//   // creating a cycle
+//   untypedCategory.subcategories = [untypedCategory];
+//   Category.parse(untypedCategory);
+// });
+// test("self recursion with base type", () => {
+//   const BaseCategory = z.object({
+//     name: z.string(),
+//   });
+//   type BaseCategory = z.infer<typeof BaseCategory>;
+//   type Category = BaseCategory & { subcategories: Category[] };
+//   const Category: z.ZodType<Category> = z.late
+//     .object(() => ({
+//       subcategories: z.array(Category),
+//     }))
+//     .extend({
+//       name: z.string(),
+//     });
+//   const untypedCategory: any = {
+//     name: "Category A",
+//   };
+//   // creating a cycle
+//   untypedCategory.subcategories = [untypedCategory];
+//   Category.parse(untypedCategory); // parses successfully
+// });

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

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