Node type and view interface inference from schema

[marolbrich]

Thank you for this really great library. I also like the coding style. However, I have trouble with node types. What I want to do is to pass a node to a function and that is why I need the type of it. I tried several ways including type inference, but it did not work. Here is an explicit example:

        interface SimpleObjectI {
            text: string
        }
        const SimpleObjectSchema = s.obj({
            text: s.con(''),
        })
        const model = Model.create().setSchema(SimpleObjectSchema)
        const root: SimpleObjectI = {
            text: 'foo'
        }
        model.api.root(root)
        type SimpleObjectNodeType =  ObjNode<{
            text: ConNode<string>
        }>
        function foo(_node: ObjApi<SimpleObjectNodeType>) {}
        foo(model.api.node)

The last line gives the following error:

Error: Argument of type 'ObjApi<ObjNode<{ text: ConNode<string>; }>>' is not assignable to parameter of type 'ObjApi<SimpleObjectNodeType>'.
  The types returned by 'get(...)' are incompatible between these types.
    Type 'import("/home/user/WebstormProjects/crdt-sync/node_modules/json-joy/esm/json-crdt/model/api/types").JsonNodeApi<{ text: import("/home/user/WebstormProjects/crdt-sync/node_modules/json-joy/esm/json-crdt/nodes/const/ConNode").ConNode<string>; }[K]>' is not assignable to type 'import("/home/user/WebstormProjects/crdt-sync/node_modules/json-joy/lib/json-crdt/model/api/types").JsonNodeApi<{ text: import("/home/user/WebstormProjects/crdt-sync/node_modules/json-joy/lib/json-crdt/nodes/const/ConNode").ConNode<string>; }[K]>'.
      Type 'ConApi<{ text: ConNode<string>; }[K]> | ({ text: ConNode<string>; }[K] extends RootNode<any> ? ValApi<{ text: ConNode<string>; }[K]> : { ...; }[K] extends ValNode<...> ? ValApi<...> : { ...; }[K] extends StrNode<...> ? StrApi : { ...; }[K] extends BinNode ? BinApi : { ...; }[K] extends ArrNode<...> ? ArrApi<...> : {...' is not assignable to type 'JsonNodeApi<{ text: ConNode<string>; }[K]>'.
        Type 'ConApi<{ text: ConNode<string>; }[K]>' is not assignable to type 'JsonNodeApi<{ text: ConNode<string>; }[K]>'.
          Type 'import("/home/user/WebstormProjects/crdt-sync/node_modules/json-joy/esm/json-crdt/model/api/nodes").ConApi<{ text: import("/home/user/WebstormProjects/crdt-sync/node_modules/json-joy/esm/json-crdt/nodes/const/ConNode").ConNode<string>; }[K]>' is not assignable to type 'import("/home/user/WebstormProjects/crdt-sync/node_modules/json-joy/lib/json-crdt/model/api/nodes").ConApi<{ text: import("/home/user/WebstormProjects/crdt-sync/node_modules/json-joy/lib/json-crdt/nodes/const/ConNode").ConNode<string>; }[K]>'.
            The types returned by 'proxy().toApi()' are incompatible between these types.
              Type 'import("/home/user/WebstormProjects/crdt-sync/node_modules/json-joy/esm/json-crdt/model/api/types").JsonNodeApi<{ text: import("/home/user/WebstormProjects/crdt-sync/node_modules/json-joy/esm/json-crdt/nodes/const/ConNode").ConNode<string>; }[K]>' is not assignable to type 'import("/home/user/WebstormProjects/crdt-sync/node_modules/json-joy/lib/json-crdt/model/api/types").JsonNodeApi<{ text: import("/home/user/WebstormProjects/crdt-sync/node_modules/json-joy/lib/json-crdt/nodes/const/ConNode").ConNode<string>; }[K]>'.
                Type 'ConApi<{ text: ConNode<string>; }[K]> | ({ text: ConNode<string>; }[K] extends RootNode<any> ? ValApi<RootNode<any> & { ...; }[K]> : { ...; }[K] extends ValNode<...> ? ValApi<...> : { ...; }[K] extends StrNode<...> ? StrApi : { ...; }[K] extends BinNode ? BinApi : { ...; }[K] extends ArrNode<...> ? ArrApi<...> : { ....' is not assignable to type 'JsonNodeApi<{ text: ConNode<string>; }[K]>'.
                  Type 'ConApi<{ text: ConNode<string>; }[K]>' is not assignable to type 'JsonNodeApi<{ text: ConNode<string>; }[K]>'.
                    Type '{ text: import("/home/user/WebstormProjects/crdt-sync/node_modules/json-joy/esm/json-crdt/nodes/const/ConNode").ConNode<string>; }[K] extends import("/home/user/WebstormProjects/crdt-sync/node_modules/json-joy/esm/json-crdt/nodes/root/RootNode").RootNode<any> ? import("/home/user/WebstormProjects/crdt-sync/node_modu...' is not assignable to type '{ text: import("/home/user/WebstormProjects/crdt-sync/node_modules/json-joy/lib/json-crdt/nodes/const/ConNode").ConNode<string>; }[K] extends import("/home/user/WebstormProjects/crdt-sync/node_modules/json-joy/lib/json-crdt/nodes/root/RootNode").RootNode<any> ? import("/home/user/WebstormProjects/crdt-sync/node_modu...'.
                      Type 'ValApi<RootNode<any> & { text: ConNode<string>; }[K]> | ({ text: ConNode<string>; }[K] extends ValNode<any> ? ValApi<ValNode<...> & { ...; }[K]> : { ...; }[K] extends StrNode<...> ? StrApi : { ...; }[K] extends BinNode ? BinApi : { ...; }[K] extends ArrNode<...> ? ArrApi<...> : { ...; }[K] extends ObjNode<...> ? Obj...' is not assignable to type '{ text: ConNode<string>; }[K] extends RootNode<any> ? ValApi<RootNode<any> & { text: ConNode<string>; }[K]> : { text: ConNode<string>; }[K] extends ValNode<...> ? ValApi<...> : { ...; }[K] extends StrNode<...> ? StrApi : { ...; }[K] extends BinNode ? BinApi : { ...; }[K] extends ArrNode<...> ? ArrApi<...> : { ...; }...'.
                        Type 'ValApi<RootNode<any> & { text: ConNode<string>; }[K]>' is not assignable to type '{ text: ConNode<string>; }[K] extends RootNode<any> ? ValApi<RootNode<any> & { text: ConNode<string>; }[K]> : { text: ConNode<string>; }[K] extends ValNode<...> ? ValApi<...> : { ...; }[K] extends StrNode<...> ? StrApi : { ...; }[K] extends BinNode ? BinApi : { ...; }[K] extends ArrNode<...> ? ArrApi<...> : { ...; }...'. 
        function foo(_node: ObjApi<SimpleObjectNodeType>) {}
        foo(model.api.node)
    })

What am I doing wrong? Or in other words: What ist the correct type of the node?
Thanks.

[marolbrich]

This might to be a false positive from eslint. The code seems to works. So I am not sure if this is really a problem of json-joy.

[streamich]

What ist the correct type of the node?

1. The schema is stored in SimpleObjectSchema, you can extract the node type and view interface from it.
2. The schema also sets the default value, so you don't need to do .api.root(), the schema does it for you.

Basically, what you want to write is:

const SimpleObjectSchema = s.obj({
  text: s.con<string>('foo'),
});

const model = Model.create(SimpleObjectSchema);

type SimpleObjectNodeType = SchemaToJsonNode<typeof SimpleObjectSchema>;
type SimpleObjectI = JsonNodeView<SimpleObjectNodeType>;

console.log(model + '');

The SchemaToJsonNode and JsonNodeView types you can import from the library.

[streamich]

To infer the model view interface there is also an option to do this:

type SimpleObjectI = ReturnType<(typeof model)['view']>;

[streamich]

Another option is: if the type safety results into too much wrestling with the TypeScript compiler, then just don't make it type safe. Cast the model to Model<any> and cast the view when you use it model.view() as SimpleObjectI.

[marolbrich]

Thank you very much for these helpful hints!
I would like to share what works best for me. All further type problems are solved completely for my usecase by deriving types from objects or using the provided type casting generics: (Refactored a little:)

const simpleObjectSchema = s.obj({
    text: s.con<string>('foo'),
})
// Model type:
const simpleObjectModel = Model.create(simpleObjectSchema)
type SimpleObjectModel = typeof simpleObjectModel
// Node type:
const simpleObjectNode = simpleObjectModel.api.obj([])
type SimpleObjectNode = typeof simpleObjectNode
// Simple type:
type SimpleObject = JsonNodeView<SchemaToJsonNode<typeof simpleObjectSchema>>