operations to check subset and identity of types

[faassen]

I find myself with the use case to check whether a Zod type is a subset of another Zod type, and also, to help implement it, whether a Zod type is identical to another Zod type. I saw in the code earlier versions of Zod had an .is operation that has been removed.

So given:

const main = z.object({foo: z.string(), bar: z.string()});
const a = z.object({foo: z.string()});
const b = z.object({foo: z.number()});
const c = z.object({other: z.string()});

Then:

a.isSubset(main) // true, as foo is in main and the same type
b.isSubset(main) // false, as foo is not the same
c.isSubset(main) // false, as other is not present in main

This might get hairy with intersection types, though I'm not particularly concerned with this right now. Is anyone working on anything like this or is there a solution already?

[scotttrinh]

That's a fun one! I could see something like an extends method that works like a conditional type. Nothing built in that I'm aware of, but would be happy to help point you in the right direction or review a PR to add it.

[scotttrinh]

I think extends would be the "other way" compared to isSubset, so it'd look more like:

// Runtime equivalent of `Main extends A`
main.extends(a) // true
main.extends(b) // false
main.extends(c) // false

[faassen]

There's already an extend so extends might be a bit confusing. Perhaps isSuperset would be a good name for the inverse operation.

[scotttrinh]

There's already an extend so extends might be a bit confusing.

That's fair, but also true of TypeScript itself, and has some nice symmetry. I definitely get that the symmetry is also potentially confusing. Maybe doesExtend to make it clear that it's a predicate? It'd be nice to stick to something close to the compile-time language since we attempt to do that elsewhere.

My only small qualm with using superset/subset in this context, is that it's a potentially confusing term when not dealing with Set or a mathematical set. "Is this schema compatible with another schema?" (for some definition of "compatible") seems like the question we're answering. Maybe if you squint you can say "Is the set of schemas in this definition, a superset or subset of this other set of schemas in another definition?" That seems valid, but maybe a bit non-intuitive?

[faassen]

Maybe doesExtend to make it clear that it's a predicate? It'd be nice to stick to something close to the compile-time language since we attempt to do that elsewhere.

Agreed! I started digging through the code to see how hard basic type equality is. For most non collection types it's fairly simple, but both z.string and z.number offer a bunch of checkers that need some work to make them comparable. I haven't looked too deeply into the rest yet.

…

[scotttrinh]

but both z.string and z.number offer a bunch of checkers that need some work to make them comparable.

Oh, that's a good point: if we want it to return false if the schema type has additional refinements, we might have some trouble knowing that for sure. ZodEffect is a bit opaque and might just make this only useful if you have no additional transforms or refinements, which limits the usefulness of this method, IMHO. Definitely still open to helping explore this!

[stale]

This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.