Support for nested/recursive types?

Hi there,

this library looks amazing and seems like what i am currently missing in native typescript. But there is one thing, i hadn’t success to achieve with this library: nested recursive types. I need to define the structure types for an object literal like:

type item = {
  Prop1: string,
  Prop2: number
}

type group = {
  Prop3: string,
  Items: Array<item | group>
}

const JSON: group = {
  Prop3: "Root",
  Items: [
    {
      Prop1: "Item 1",
      Prop2: 123
    },
    {
      Prop3: "Nested Group 1",
      Items: [
        /*
          ... and so on
        */
      ]
    }
  ]
}

If i try to achieve this with runtypes the following way:

const item = Record({
  Prop1: String,
  Prop2: Number
});

const group = Record({
  Prop3: String,
  Items: Array(Union(item, group))
});

it gives a compiler error “block-scoped variable ‘group’ is used before its declaration”. If i replace const group with var group the compiler error disappears but typescript recognizes group only as type any…

Is there any way to describe the desired structure? Thanks for any hint on this…

[pelotom]

Unfortunately type inference is not possible when using Lazy to make recursive types. You need to help out the compiler a little:

const item = Record({
  Prop1: String,
  Prop2: Number
});

type Group = { Prop3: string, Items: (Static<typeof item> | Group)[] }
const group: Runtype<Group> = Lazy(() => Record({
  Prop3: String,
  Items: Array(Union(item, group))
}));

But as long as you have noImplicitAny enabled (which you always should 😃), it will be a static type error if you fail to do this, or if you do it incorrectly. For instance, if you fail to provide the annotation:

const group = Lazy(() => Record({
//    ^^^^^
// 'group' implicitly has type 'any' because it does not have a type annotation and is referenced directly or indirectly in its own initializer

And if you get the annotation wrong:

type Group = { Propp3: string, Items: (Static<typeof item> | Group)[] }
const group: Runtype<Group> = Lazy(() => Record({
//    ^^^^^
// Type 'Record<{ Prop3: String; Items: Arr<Union2<Record<{ Prop1: String; Prop2: Number; }>, Runtype<Grou...' is not assignable to type 'Runtype<Group>'.
//  Types of property 'check' are incompatible.
//    Type '(x: any) => { Prop3: string; Items: (any | Group)[]; }' is not assignable to type '(x: any) => Group'.
//      Type '{ Prop3: string; Items: (any | Group)[]; }' is not assignable to type 'Group'.
//        Property 'Propp3' is missing in type '{ Prop3: string; Items: (any | Group)[]; }'.

So type checking still works fine, just not type inference.

[pelotom]

Hi, glad this library is useful to you! In order to implement a recursive type you need to use the Lazy combinator, like so:

const item = Record({
  Prop1: String,
  Prop2: Number
});

const group = Lazy(() => Record({
  Prop3: String,
  Items: Array(Union(item, group))
}));

This defers evaluation of the type definition until its first use, at which point the group variable will be in scope and the knot can be tied. Hope that helps!