No unknown keys

This feature causes yup to throw an error on validation if there’s a property on the object that doesn’t match the schema. Similar to yup.object().noUnknown()

Split off from #14.

[colinhacks]

@christophemarois I’ve been thinking about this a fair bit.

I think I’ll introduce a .mask() method on object schemas that lets you pass in a properly typed instance and get back a new object with some subset of the properties. Like so:

const Dog = z.object({
  name: z.string(),
  age: z.number()
})

const justName = Dog.mask({ name: true }, { name: "Fido", age: 20 });
// => { name: string }

In your situation I’d recommend creating a proper recursive type for the sake of representational accuracy:

interface A {
  val: number;
  b: B;
}

interface B {
  val: number;
  a: A;
}

const A: z.ZodType<A> = z.lazy(() =>
  z.object({
    val: z.number(),
    b: B,
  }),
);

const B: 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;

const parsedA = A.parse(a);
const maskedA = A.mask({ val: true, b: { val: true, a: { val: true } } }, parsedA);

.mask isn’t actually implemented yet, I was just toying with the idea. Would this work for your use cases? I’ll leave this issue open in the meantime.

[christophemarois]

I don’t know if you’d consider also adding yup’s stripUnknown option, which is related to the noUnknown() behavior, but is not treated as an error.

This would be a really useful feature for my particular use-case: I have React components that take as a prop an object with circular dependencies (think ActiveRecord). I currently use yup with to do both prob validation and “picking” properties, so I end up with an object that is serializable, that I can send over HTTP, and that only contains the property I need.

I have a working workflow with yup, but the lack of optional types and correct type inference is problematic.

Extremely dumb yup example to illustrate my point:

import { object, number } from 'yup'

let a = { val: 1 }
let b = { val: 2 }
a.b = b
b.a = a

const schema = object({
  val: number(),
  b: object({
    val: number(),
    a: object({
      val: number()
    })
  }),
})

schema.validateSync(schema, { stripUnknown: true })
// => { val: 1, b: { val: 2, a: { val: 1 } } }