Union with all literals from specific type

[Perdolique]

I want to create a schema to validate union type, e.g.: type TestType = 'woof' | 'bark'. Currently, I'm using:

type TestType = 'woof' | 'bark

const schema = v.union([
  v.literal<TestType>('woof'),
  v.literal<TestType>('bark')
])

The problem is, this check will not handle cases when a new value is added to TestType and it's possible to use the same value more than once in the v.union().

Ideally, I'd like to have an exclusive array of unions that I can use to build the argument for v.union(). I'm going to use const typesObject : Record<TestType, null> = { ... } and then iterate over the keys of the typesObject. It should guarantee that each value of the TestType is used. But maybe I'm missing something and it can be done natively in Valibot, for example, pass an argument to generic like v.union<TestType >([ ... ]) or so.

[dosubot[bot]]

Hi @Perdolique! I'm Dosu and I’m helping the valibot team.

Valibot doesn't support passing a TypeScript union type directly to v.union or auto-generating a union schema from a type, due to TypeScript's type erasure at runtime. The recommended DRY approach is to use a single runtime array (as const) or an enum/object as your source of truth, and derive both your TypeScript type and your schema from it. This keeps everything in sync and avoids duplication or omissions.

For example, using a const array and picklist:

const testTypes = ['woof', 'bark'] as const;
type TestType = typeof testTypes[number];

const schema = v.picklist(testTypes);

Or, if you prefer enums:

const TestEnum = { Woof: 'woof', Bark: 'bark' } as const;
type TestType = (typeof TestEnum)[keyof typeof TestEnum];

const schema = v.enum(TestEnum);

This way, adding or removing values only requires changing the array or enum, and both your type and schema will always match. This also prevents duplicates and ensures all values are covered, since the runtime array or enum is the single source of truth. More details and examples are in the Valibot picklist and enum docs.

If you need dynamic validation (e.g., the allowed values change at runtime), you can recreate the schema when the source changes, or use a custom/check validator as described here.

To reply, just mention @dosu.

---

^{How did I do? Good | Irrelevant | Incorrect | Verbose | Hallucination | Report 🐛 | Other}   

[fabian-hiller]

This works too but it is a bit more complicated. Feel free to try it out in our playground.

import * as v from 'valibot';

/**
 * Converts union to intersection type.
 */
type UnionToIntersect<TUnion> =
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
  (TUnion extends any ? (arg: TUnion) => void : never) extends (
    arg: infer Intersect
  ) => void
    ? Intersect
    : never;

/**
 * Converts union to tuple type using an accumulator.
 *
 * For more information: {@link https://www.typescriptlang.org/docs/handbook/release-notes/typescript-4-5.html#tail-recursion-elimination-on-conditional-types}
 */
type UnionToTupleHelper<TUnion, TResult extends unknown[]> =
  UnionToIntersect<
    TUnion extends never ? never : () => TUnion
  > extends () => infer TLast
    ? UnionToTupleHelper<Exclude<TUnion, TLast>, [TLast, ...TResult]>
    : TResult;

/**
 * Converts union to tuple type.
 */
type UnionToTuple<TUnion> = UnionToTupleHelper<TUnion, []>;

type Foo = 'A' | 'B' | 'C';

const FooSchema = v.picklist<UnionToTuple<Foo>>(['A', 'B', 'C']);

[Perdolique]

Thanks. It works.

I also found UnionToTuple from type-fest package and it also works. It seems like realisation is similar to what is suggested. But the suggested one seems to check duplicates in the initial union when UnionToTuple is not.