zod 4.3.0-canary.20251222T205904 → 4.3.0-canary.20251223T023855

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zod",
-  "version": "4.3.0-canary.20251222T205904",
+  "version": "4.3.0-canary.20251223T023855",
   "type": "module",
   "license": "MIT",
   "author": "Colin McDonnell <zod@colinhacks.com>",

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

@@ -435,6 +435,20 @@ test("extend() should have power to override existing key", () => {
   expectTypeOf<PersonWithNumberAsLastName>().toEqualTypeOf<{ firstName: string; lastName: number }>();
 });
 
+test("safeExtend() should have power to override existing key", () => {
+  const PersonWithMinLastName = personToExtend.safeExtend({
+    lastName: z.string().min(3),
+  });
+  type PersonWithMinLastName = z.infer<typeof PersonWithMinLastName>;
+
+  const expected = { firstName: "f", lastName: "abc" };
+  const actual = PersonWithMinLastName.parse(expected);
+
+  expect(actual).toEqual(expected);
+  expect(() => PersonWithMinLastName.parse({ firstName: "f", lastName: "ab" })).toThrow();
+  expectTypeOf<PersonWithMinLastName>().toEqualTypeOf<{ firstName: string; lastName: string }>();
+});
+
 test("safeExtend() maintains refinements", () => {
   const schema = z.object({ name: z.string().min(1) });
   const extended = schema.safeExtend({ name: z.string().min(2) });

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

@@ -338,3 +338,90 @@ test("optional with check", () => {
     }
   `);
 });
+
+test("partial - throws error on schema with refinements", () => {
+  const baseSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    items: z.string().array(),
+  });
+
+  const refinedSchema = baseSchema.superRefine((val, ctx) => {
+    if (val.items.length === 0) {
+      ctx.addIssue({
+        message: "Must have at least one item",
+        code: "custom",
+        path: ["items"],
+      });
+    }
+  });
+
+  expect(() => refinedSchema.partial()).toThrow(".partial() cannot be used on object schemas containing refinements");
+});
+
+test("partial - throws error on schema with refine", () => {
+  const baseSchema = z.object({
+    password: z.string(),
+    confirmPassword: z.string(),
+  });
+
+  const refinedSchema = baseSchema.refine((data) => data.password === data.confirmPassword, {
+    message: "Passwords must match",
+  });
+
+  expect(() => refinedSchema.partial()).toThrow(".partial() cannot be used on object schemas containing refinements");
+});
+
+test("required - preserves refinements", () => {
+  const baseSchema = z.object({
+    name: z.string().optional(),
+    age: z.number().optional(),
+  });
+
+  const refinedSchema = baseSchema.superRefine((val, ctx) => {
+    if (val.name === "admin") {
+      ctx.addIssue({
+        message: "Name cannot be admin",
+        code: "custom",
+        path: ["name"],
+      });
+    }
+  });
+
+  const requiredSchema = refinedSchema.required();
+
+  // The refinement should still be applied
+  const result = requiredSchema.safeParse({ name: "admin", age: 25 });
+  expect(result.success).toBe(false);
+  if (!result.success) {
+    expect(result.error.issues[0].message).toBe("Name cannot be admin");
+  }
+
+  // Valid data should pass
+  const validResult = requiredSchema.safeParse({ name: "user", age: 25 });
+  expect(validResult.success).toBe(true);
+});
+
+test("required - refinement is executed on required schema", () => {
+  const baseSchema = z.object({
+    password: z.string().optional(),
+    confirmPassword: z.string().optional(),
+  });
+
+  const refinedSchema = baseSchema.refine((data) => data.password === data.confirmPassword, {
+    message: "Passwords must match",
+  });
+
+  const requiredSchema = refinedSchema.required();
+
+  // Mismatched passwords should fail refinement
+  const result = requiredSchema.safeParse({ password: "abc", confirmPassword: "xyz" });
+  expect(result.success).toBe(false);
+  if (!result.success) {
+    expect(result.error.issues[0].message).toBe("Passwords must match");
+  }
+
+  // Matching passwords should pass
+  const validResult = requiredSchema.safeParse({ password: "abc", confirmPassword: "abc" });
+  expect(validResult.success).toBe(true);
+});

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

@@ -125,3 +125,78 @@ test("pick/omit/required/partial - do not allow unknown keys", () => {
   // @ts-expect-error
   expect(() => schema.partial({ $unknown: true }).safeParse({})).toThrow();
 });
+
+test("pick - throws error on schema with refinements", () => {
+  const baseSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    items: z.string().array(),
+  });
+
+  const refinedSchema = baseSchema.superRefine((val, ctx) => {
+    if (val.items.length === 0) {
+      ctx.addIssue({
+        message: "Must have at least one item",
+        code: "custom",
+        path: ["items"],
+      });
+    }
+  });
+
+  expect(() => refinedSchema.pick({ name: true })).toThrow(
+    ".pick() cannot be used on object schemas containing refinements"
+  );
+});
+
+test("omit - throws error on schema with refinements", () => {
+  const baseSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    items: z.string().array(),
+  });
+
+  const refinedSchema = baseSchema.superRefine((val, ctx) => {
+    if (val.items.length === 0) {
+      ctx.addIssue({
+        message: "Must have at least one item",
+        code: "custom",
+        path: ["items"],
+      });
+    }
+  });
+
+  expect(() => refinedSchema.omit({ id: true })).toThrow(
+    ".omit() cannot be used on object schemas containing refinements"
+  );
+});
+
+test("pick - throws error on schema with refine", () => {
+  const baseSchema = z.object({
+    password: z.string(),
+    confirmPassword: z.string(),
+  });
+
+  const refinedSchema = baseSchema.refine((data) => data.password === data.confirmPassword, {
+    message: "Passwords must match",
+  });
+
+  expect(() => refinedSchema.pick({ password: true })).toThrow(
+    ".pick() cannot be used on object schemas containing refinements"
+  );
+});
+
+test("omit - throws error on schema with refine", () => {
+  const baseSchema = z.object({
+    password: z.string(),
+    confirmPassword: z.string(),
+    email: z.string(),
+  });
+
+  const refinedSchema = baseSchema.refine((data) => data.password === data.confirmPassword, {
+    message: "Passwords must match",
+  });
+
+  expect(() => refinedSchema.omit({ email: true })).toThrow(
+    ".omit() cannot be used on object schemas containing refinements"
+  );
+});

package/src/v4/classic/tests/recursive-types.test.ts

@@ -308,7 +308,7 @@ test("object utilities with recursive types", () => {
     },
   });
 
-  // Test extend
+  // Test extend with new keys (extend throws when overwriting existing keys)
   const NodeOne = NodeBase.extend({
     name: z.literal("nodeOne"),
     get children() {

package/src/v4/core/tests/extend.test.ts

@@ -1,16 +1,16 @@
 import { expect, test } from "vitest";
 import * as z from "zod/v4";
 
-test("extend chaining preserves and overrides properties", () => {
+test("safeExtend chaining preserves and overrides properties", () => {
   const schema1 = z.object({
     email: z.string(),
   });
 
-  const schema2 = schema1.extend({
+  const schema2 = schema1.safeExtend({
     email: schema1.shape.email.check(z.email()),
   });
 
-  const schema3 = schema2.extend({
+  const schema3 = schema2.safeExtend({
     email: schema2.shape.email.or(z.literal("")),
   });
 

package/src/v4/core/util.ts

@@ -593,6 +593,12 @@ export const BIGINT_FORMAT_RANGES: Record<checks.$ZodBigIntFormats, [bigint, big
 export function pick(schema: schemas.$ZodObject, mask: Record<string, unknown>): any {
   const currDef = schema._zod.def;
 
+  const checks = currDef.checks;
+  const hasChecks = checks && checks.length > 0;
+  if (hasChecks) {
+    throw new Error(".pick() cannot be used on object schemas containing refinements");
+  }
+
   const def = mergeDefs(schema._zod.def, {
     get shape() {
       const newShape: Writeable<schemas.$ZodShape> = {};
@@ -616,6 +622,12 @@ export function pick(schema: schemas.$ZodObject, mask: Record<string, unknown>):
 export function omit(schema: schemas.$ZodObject, mask: object): any {
   const currDef = schema._zod.def;
 
+  const checks = currDef.checks;
+  const hasChecks = checks && checks.length > 0;
+  if (hasChecks) {
+    throw new Error(".omit() cannot be used on object schemas containing refinements");
+  }
+
   const def = mergeDefs(schema._zod.def, {
     get shape() {
       const newShape: Writeable<schemas.$ZodShape> = { ...schema._zod.def.shape };
@@ -662,15 +674,13 @@ export function safeExtend(schema: schemas.$ZodObject, shape: schemas.$ZodShape)
   if (!isPlainObject(shape)) {
     throw new Error("Invalid input to safeExtend: expected a plain object");
   }
-  const def = {
-    ...schema._zod.def,
+  const def = mergeDefs(schema._zod.def, {
     get shape() {
       const _shape = { ...schema._zod.def.shape, ...shape };
       assignProp(this, "shape", _shape); // self-caching
       return _shape;
     },
-    checks: schema._zod.def.checks,
-  } as any;
+  });
   return clone(schema, def) as any;
 }
 
@@ -695,6 +705,13 @@ export function partial(
   schema: schemas.$ZodObject,
   mask: object | undefined
 ): any {
+  const currDef = schema._zod.def;
+  const checks = currDef.checks;
+  const hasChecks = checks && checks.length > 0;
+  if (hasChecks) {
+    throw new Error(".partial() cannot be used on object schemas containing refinements");
+  }
+
   const def = mergeDefs(schema._zod.def, {
     get shape() {
       const oldShape = schema._zod.def.shape;
@@ -770,7 +787,6 @@ export function required(
       assignProp(this, "shape", shape); // self-caching
       return shape;
     },
-    checks: [],
   });
 
   return clone(schema, def) as any;

package/v4/core/util.cjs

@@ -384,6 +384,11 @@ exports.BIGINT_FORMAT_RANGES = {
 };
 function pick(schema, mask) {
     const currDef = schema._zod.def;
+    const checks = currDef.checks;
+    const hasChecks = checks && checks.length > 0;
+    if (hasChecks) {
+        throw new Error(".pick() cannot be used on object schemas containing refinements");
+    }
     const def = mergeDefs(schema._zod.def, {
         get shape() {
             const newShape = {};
@@ -404,6 +409,11 @@ function pick(schema, mask) {
 }
 function omit(schema, mask) {
     const currDef = schema._zod.def;
+    const checks = currDef.checks;
+    const hasChecks = checks && checks.length > 0;
+    if (hasChecks) {
+        throw new Error(".omit() cannot be used on object schemas containing refinements");
+    }
     const def = mergeDefs(schema._zod.def, {
         get shape() {
             const newShape = { ...schema._zod.def.shape };
@@ -445,15 +455,13 @@ function safeExtend(schema, shape) {
     if (!isPlainObject(shape)) {
         throw new Error("Invalid input to safeExtend: expected a plain object");
     }
-    const def = {
-        ...schema._zod.def,
+    const def = mergeDefs(schema._zod.def, {
         get shape() {
             const _shape = { ...schema._zod.def.shape, ...shape };
             assignProp(this, "shape", _shape); // self-caching
             return _shape;
         },
-        checks: schema._zod.def.checks,
-    };
+    });
     return clone(schema, def);
 }
 function merge(a, b) {
@@ -471,6 +479,12 @@ function merge(a, b) {
     return clone(a, def);
 }
 function partial(Class, schema, mask) {
+    const currDef = schema._zod.def;
+    const checks = currDef.checks;
+    const hasChecks = checks && checks.length > 0;
+    if (hasChecks) {
+        throw new Error(".partial() cannot be used on object schemas containing refinements");
+    }
     const def = mergeDefs(schema._zod.def, {
         get shape() {
             const oldShape = schema._zod.def.shape;
@@ -540,7 +554,6 @@ function required(Class, schema, mask) {
             assignProp(this, "shape", shape); // self-caching
             return shape;
         },
-        checks: [],
     });
     return clone(schema, def);
 }

package/v4/core/util.js

@@ -327,6 +327,11 @@ export const BIGINT_FORMAT_RANGES = {
 };
 export function pick(schema, mask) {
     const currDef = schema._zod.def;
+    const checks = currDef.checks;
+    const hasChecks = checks && checks.length > 0;
+    if (hasChecks) {
+        throw new Error(".pick() cannot be used on object schemas containing refinements");
+    }
     const def = mergeDefs(schema._zod.def, {
         get shape() {
             const newShape = {};
@@ -347,6 +352,11 @@ export function pick(schema, mask) {
 }
 export function omit(schema, mask) {
     const currDef = schema._zod.def;
+    const checks = currDef.checks;
+    const hasChecks = checks && checks.length > 0;
+    if (hasChecks) {
+        throw new Error(".omit() cannot be used on object schemas containing refinements");
+    }
     const def = mergeDefs(schema._zod.def, {
         get shape() {
             const newShape = { ...schema._zod.def.shape };
@@ -388,15 +398,13 @@ export function safeExtend(schema, shape) {
     if (!isPlainObject(shape)) {
         throw new Error("Invalid input to safeExtend: expected a plain object");
     }
-    const def = {
-        ...schema._zod.def,
+    const def = mergeDefs(schema._zod.def, {
         get shape() {
             const _shape = { ...schema._zod.def.shape, ...shape };
             assignProp(this, "shape", _shape); // self-caching
             return _shape;
         },
-        checks: schema._zod.def.checks,
-    };
+    });
     return clone(schema, def);
 }
 export function merge(a, b) {
@@ -414,6 +422,12 @@ export function merge(a, b) {
     return clone(a, def);
 }
 export function partial(Class, schema, mask) {
+    const currDef = schema._zod.def;
+    const checks = currDef.checks;
+    const hasChecks = checks && checks.length > 0;
+    if (hasChecks) {
+        throw new Error(".partial() cannot be used on object schemas containing refinements");
+    }
     const def = mergeDefs(schema._zod.def, {
         get shape() {
             const oldShape = schema._zod.def.shape;
@@ -483,7 +497,6 @@ export function required(Class, schema, mask) {
             assignProp(this, "shape", shape); // self-caching
             return shape;
         },
-        checks: [],
     });
     return clone(schema, def);
 }