Enum/Union to JS array value

[m4rvr]

Hey!

I'm currently trying to write a schema which I can use as a source for input validation (API query string) and as a source for the possible values (as array).

I want to define the possible values and if the input is one of those, it's valid. But it should be also possible to get a random value of that collection, so the schema is a single source of truth with all possible values.

This is the schema I've tried to feed into Value.Create (to get the JS values):

// Works for randomizing; doesn't work for query string validation because it wants the whole array
const Colors = Type.Tuple([
  Type.Literal('red'),
  Type.Literal('blue')
])

// Works for validation; doesn't work for randomizing because the created JS code is not an array like ['red', 'blue']
const Colors = Type.Union([
  Type.Literal('red'),
  Type.Literal('blue')
])

Is this even possible, or do I still need to define the values manually? (Sorry for being lost, lol)
I'm open for any feedback, so please say if this is a bad idea.
I just want to avoid always having to define the array with values (so I can pick a random item from it) and the possible values for validation that TypeBox automatically can validate by providing the input from the query string.

[sinclairzx81]

@m4rvr Hi,

Type.Union would be the correct way to define a set of possible color options.

const Color = Type.Union([      // this will validate a string for the value 'red', 'green' or 'blue'
  Type.Literal('red'),
  Type.Literal('green'),
  Type.Literal('blue')
])

For getting all possible colors, you can remap the literal types inside the Color union type.

const colors = Color.anyOf.map(color => color.const)     // ['red', 'green', 'blue']

const random = colors[(Math.random() * colors.length)|0] // 'red' or 'green' or 'blue'

Or optionally, remap a Union to Tuple if the tuple representation is required.

const ColorTuple = Type.Tuple(Color.anyOf) // ['red', 'green', 'blue']

Hope this helps!

[m4rvr]

@sinclairzx81 Wow, big thanks for your superfast response, this helps me a lot!
Appreciate your time and detailed examples you always give for various questions. 🙏

[m4rvr]

@sinclairzx81 Is it possible to also get an array/tuple when the union just has one item like this?

const Color = Type.Union([
  Type.Literal('red')
])

Using Color.anyOf fails because Color is now of type TLiteral and not TUnion. Can this be fixed?
It actually makes sense because type Color = 'red' is also just '1' but I'm not sure if Type.Union is the right choice for me then.

[sinclairzx81]

@m4rvr Ah, right.

TB 0.26.0 will unwrap for unions with single sub types, and return never for zero sub types.

The following supports all cases, but you will need to use a TypeGuard

import { TypeGuard } from '@sinclair/typebox'

export type ColorType = TUnion<TLiteral[]> | TLiteral | TNever

export function GetColors<T extends ColorType>(value: T): string[] {
  return (
    TypeGuard.TUnion(value)   ? value.anyOf.map(literal => literal.const) :
    TypeGuard.TLiteral(value) ? [value.const] :
    TypeGuard.TNever(value)   ? [] : []
  ) as string[]
}

If you want to retain union literal const type information, the following updates string[] to the conditional mapped type TGetColors.

export type ColorType = TUnion<TLiteral[]> | TLiteral | TNever 

// same logic as the function
export type TGetColors<T extends ColorType> = 
  T extends TUnion<infer C>   ? { [K in keyof C]: C[K]['const'] } :
  T extends TLiteral<infer C> ? [C] :
  T extends TNever            ? [] : []

export function GetColors<T extends ColorType>(value: T): TGetColors<T> {
  return (
    TypeGuard.TUnion(value)   ? value.anyOf.map(literal => literal.const) :
    TypeGuard.TLiteral(value) ? [value.const] :
    TypeGuard.TNever(value)   ? [] : []
  ) as TGetColors<T>
}

const A = Type.Union([Type.Literal('red'), Type.Literal('blue')])
const B = Type.Union([Type.Literal('red')])
const C = Type.Union([])

const A_ = GetColors(A) // ['red', 'blue']
const B_ = GetColors(B) // ['red']
const C_ = GetColors(C) // []

Hope this helps!