Extract a string array of union type from Type.Object keys

[dephiros]

Hi,

I am trying to use TypeBox to consolidate some existing API definitions:

interface APInterface {
  title: string;
  count: number;
}

const apiAttributes = ['title', 'count'] as const;

My attempt:

const schema = Type.Object({
  title: Type.String();
  count: Type.Number;
});

type APInterface = Static<typeof schema>; // this works great
const apiAttributes = Object.keys(schema.properties); // the type is now `string[]` instead of a union

Would there be some Typescript magic(beside casting as keyof APInterface) or utility that can help make the type of apiAttributes a union type?
Took a look at #370 but not sure if applicable. Sorry if I missed another existing question
🙏

[sinclairzx81]

@dephiros Hi,

TypeBox supports TypeScript's keyof operator with Type.KeyOf(). You can use this to extract property keys from the object as well as construct a schema type that matches those keys.

TypeScript Link Here

import { Type, Static } from '@sinclair/typebox'

type T = Static<typeof T>      // type T = { title: string, count: number }

const T = Type.Object({        // const T = {
  title: Type.String(),        //   type: 'object',
  count: Type.Number()         //   properties: {
})                             //     title: { type: 'string', [Symbol(TypeBox.Kind)]: 'String' },
                               //     count: { type: 'number', [Symbol(TypeBox.Kind)]: 'Number' }
                               //   },
                               //   required: [ 'title', 'count' ],
                               //   [Symbol(TypeBox.Kind)]: 'Object'
                               // }


type K = Static<typeof K>      // type K = 'title' | 'count'

const K = Type.KeyOf(T)        // const K = {
                               //   anyOf: [
                               //     { const: 'title', type: 'string', [Symbol(TypeBox.Kind)]: 'Literal' }, 
                               //     { const: 'count', type: 'string', [Symbol(TypeBox.Kind)]: 'Literal' }
                               //   ],
                               //   [Symbol(TypeBox.Kind)]: 'Union'
                               // }

If you only need the keys as a type (with no schema), you can use the following which avoids the need to prop dive through T.properties.

type K = keyof Static<typeof T> // just the static type

Hope this helps!
S

[dephiros]

Hi @sinclairzx81 ,

Thank you for the answer and it pointed me to the right direction. What I wanted is an actual array of properties key but with the union type.

This is a bit clunky but produces the right result:

const apiAttributes  = Type.KeyOf(schema).anyOf.map((x) => x.const)

Though for some reasons, when I tried to extract to a helper method, Typescript is not quite happy:

function keyOf<P extends TProperties = {}>(schema: TObject<P>) {
  // x cannot be infer so it becomes `any`
  return Type.KeyOf(schema).anyOf.map((x) => x.const)
}

[sinclairzx81]

@dephiros Hi, you can try the following.

TypeScript Link Here

import { Type, Static, TSchema, UnionToTuple, TypeGuard } from '@sinclair/typebox'

// -------------------------------------------------------------------
// ObjectKeys
// -------------------------------------------------------------------
export type TStringKeys<T extends TSchema> = UnionToTuple<keyof Static<T>>

export function StringKeys<T extends TSchema>(schema: T): TStringKeys<T> {
  const keyOf: TSchema = Type.KeyOf(schema)
  const keys = TypeGuard.TUnion(keyOf)   ? keyOf.anyOf.map(literal => literal.const) :
               TypeGuard.TLiteral(keyOf) ? [keyOf.const] : []
  return keys as TStringKeys<T>
}

// -------------------------------------------------------------------
// Usage
// -------------------------------------------------------------------
const A = Type.Object({ x: Type.Number(), y: Type.Number() })
const B = Type.Object({ z: Type.Number() })
const I = Type.Intersect([A, B])

const K1 = StringKeys(I) // ['x', 'y', 'z']
const K2 = StringKeys(A) // ['x', 'y']
const K3 = StringKeys(B) // ['z']

[dephiros]

That works great! Thank you 🙏

[sinclairzx81]

@dephiros Hey, no problem. I've actually made a quick update to this example to support generalized types of TSchema. I'd recommend this implementation over the previous TObject one as it generalizes to TUnion and TIntersect.