Discriminated unions - error reporting and validation efficiency

[thes01]

Hi!

In our codebase we make heavy use of discriminated unions. We came across some inconveniences when modelling them via TypeBox:

Error reporting

Let's define the following union:

import Type from "typebox";

const Numeric = Type.Object({
    type: Type.Literal("numeric"),
    number_value: Type.Number(),
});

const Text = Type.Object({
    type: Type.Literal("text"),
    text_value: Type.String(),
});

const Boolish = Type.Object({
    type: Type.Literal("boolish"),
    bool_value: Type.Boolean(),
});

const MyType = Type.Union([Numeric, Text, Boolish]);

Now, if I run this:

const errors = Value.Errors(MyType, { type: 'boolish', bool_value: 42 }); // `bool_value` is incorrect
console.log(errors);

I get a bunch of errors as TypeBox is trying to match the object against (all?) the union possibilities. This is not too helpful, especially if the union grows larger (we have around 40 variants in one use case). I even spotted that the actual reason might be missing from the error list completely, probably there's some limit when the union is too big?

TypeScript error reporting is working very nicely in this case:

type MyType = Static<typeof MyType>;
const obj: MyType = {
    type: 'boolish',
    bool_value: 1234, // ERROR: Type "number" is not assignable to type "boolean".
}

Validation performance

The compiled validator for the above schema is:

const check_031a0609ff728b67 = (value) =>
	(typeof value === 'object' &&
		value !== null &&
		!Array.isArray(value) &&
		'type' in value &&
		'number_value' in value &&
		typeof value.type === 'string' &&
		value.type === 'numeric' &&
		Number.isFinite(value.number_value)) ||
	(typeof value === 'object' &&
		value !== null &&
		!Array.isArray(value) &&
		'type' in value &&
		'text_value' in value &&
		typeof value.type === 'string' &&
		value.type === 'text' &&
		typeof value.text_value === 'string') ||
	(typeof value === 'object' &&
		value !== null &&
		!Array.isArray(value) &&
		'type' in value &&
		'bool_value' in value &&
		typeof value.type === 'string' &&
		value.type === 'boolish' &&
		typeof value.bool_value === 'boolean');

As a union grows bigger (both in variants and in extra properties), the performance isn't optimal.

---

There doesn't seem to be an option to specify the "discriminator property" or some automatic discovery as, e.g. in ArkType's unions. I have stumbled upon some earlier discussions about this in typebox, but that was pre-v1 AFAICT.

Are there any plans to optimize this use case?

Is this comment still valid? #1017 (comment)