Recommendation for nested recursive object value

[rijkvanzanten]

Hi there!

I'm trying to achieve an object schema where there's a handful of known (required) properties of a given value, but then allow any additional properties to be added that adhere to the same value. In TypeScript, I would define that as:

type Value = string | number;

interface Rules {
	foo: Value;

	bar: {
		baz: Value;
	}
}

interface CustomRules {
	[key: string]: Value | CustomRules;
}

type Schema = Rules & CustomRules;

I've unsuccessfully tried achieving this through TypeBox as:

const Value = Type.Union([Type.String(), Type.Integer()]);

const Rules = Type.Object({
  foo: Value,
  bar: Type.Object({
    baz: Value
  })
});

const CustomRules = Type.Recursive((This) => Type.Record(Type.String(), Type.Union([Value, This])), { $id: 'CustomRules' });

const Schema = Type.Intersect([Rules, CustomRules]);

but that unfortunately results in a Type instantiation is excessively deep and possibly infinite. error from TypeScript.

Are the types I'm trying to achieve possible through TypeBox? And if so, do you have any recommendations on how to achieve this goal? Thanks in advance!

[sinclairzx81]

@rijkvanzanten Heya,

TypeBox only supports recursive types that are "not" infinitely expansive. The issue here that the string key is infinitely expansive.

const Key = Type.String()

const Rules = Type.Recursive(This => Type.Record(Key, This))

type Rules = Static<typeof Rules> // Type instantiation is excessively deep and possibly infinite.
                                  // Reason: [key: string] is infinitely expansive (potentially infinite properties)

However, if you constrain the keys to a finite set, this type becomes possible.

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

const Rules = Type.Recursive(This => Type.Record(Key, This))

type Rules = Static<typeof Rules> // fine

This rule pops up in various places, for example, recursive arrays.

const Rules = Type.Recursive(This => Type.Array(This))

type Rules = Static<typeof Rules> // Type instantiation is excessively deep and possibly infinite.
                                  // Reasons: This types generic argument is infinitely described by itself (Array<infinity>)
                                  //          This type evaluates [][][][][][][].... (into infinity)

Generally you want to avoid creating infinitely expansive types when using TypeBox as it's not possible to infer without infinitely expanding generic arguments, but if you need them, you can express them via Type.Unsafe which lets you describe the type using TypeScript interfaces and the schema.

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

type Value = string | number
interface Rules {
  foo: Value
  bar: {
    baz: Value
  }
}

interface CustomRules {
  [key: string]: Value | CustomRules
}

const Schema = Type.Unsafe<Rules & CustomRules>({ /* ... Define JSON Schema here  */ })

type Schema = Static<typeof Schema>

Documentation on Type.Unsafe can be found https://github.com/sinclairzx81/typebox#types-unsafe.
Hope this helps
S

[rijkvanzanten]

Thanks! That helps a lot. The strategy with Type.Unsafe would work perfectly for my use case. I can drop the strictness of the JSON Schema a hair, but still get the TypeScript typing I'm looking for. Thanks!