使用一个 function 的推断通用参数类型来键入其他函数

Question

I'm building an API to render a schema graph.

Here's what it looks like (ultra-simplified)

interface Node {
  name: string;
}

type NodeNames<T extends Node[]> = T[number]["name"]; // All node names as union of string literal

type Scalars = 'Int' | 'Boolean' | 'String'

type AllTypes<T extends Node[]> = NodeNames<T> | Scalars

interface Schema<T extends Node[]> {
  createNode(name: String, fields: Record<string, AllTypes<T>>): Node;

  render(types: T[]): string;
}

const s: Schema = { // generic not captured => "TypeError: Generic type 'Schema<T>' requires 1 type"

  render(types) {
    // print types
    return ''
  },
  createNode(name, fields) {
    return { name, fields };
  }
};

const Blog = s.createNode("Blog", { users: "User" });
const User = s.createNode("User", { posts: "Post" });
const Post = s.createNode("Post", { title: "String", comments: 'Comment' }); // <== Expected type error because 'Comment' node doesn't exist

s.render([Blog, User, Post]);

I would like to make sure that one cannot reference a type that wasn't registered in the Schema.render from the Schema.createNode function.

In the example above, fields should basically be of type: Record<string, Scalars | 'User' | 'Post' | 'Blog' Record<string, Scalars | 'User' | 'Post' | 'Blog' Record<string, Scalars | 'User' | 'Post' | 'Blog' , where User | Post | Blog User | Post | Blog User | Post | Blog is inferred from the nodes passed to s.render

To do that, I'd like to infer the names of the nodes passed to the render function, in order to type the values of the param fields of Schema.createNode .

Unfortunately, generics are only captured by function parameters if declared on a function level, and not if declared on an interface level (which makes sense).

How can I reuse the inferred generic of s.render<T extends Node[]>(nodes: T) to type the function createNode(name: string, fields: AllTypes<T>) where T is the same inferred type shared between the two functions?

Is there a way to make this work? (even with a slightly different API)

Thanks

Answer 1

I don't think you can get this to work with multiple calls. The solution that woks best would be to create a class that takes the schema definitions as an argument and check the whole object as a whole:

interface Node<T extends string = string> {
    name: T;
}


type Scalars = 'Int' | 'Boolean' | 'String'

type AllTypes<T extends Record<keyof T, any>> = keyof T | Scalars
type Values<T> = T[keyof T]

type SchemNodes<T extends Record<keyof T, Record<string, AllTypes<T>>>> =
    { [P in Extract<keyof T, string>]: Node<P> }

class Schema<T extends Record<keyof T, Record<string, AllTypes<T>>>> {
    constructor(types: T) { }
    getNodes(): SchemNodes<T> {
        return null!;
    }
    renderTypes(types: Array<Values<SchemNodes<T>>>) { }
}

const s = new Schema({
    "User": { posts: "Post" },
    "Blog": { users: "User" },
    // "Comment": {},
    "Post": { title: "String", comments: 'Comment' }
})

const { Blog, Post, User } = s.getNodes();

Play