泛型类型的递归推断

Question

The setup:

export type SchemaOne<T> =
  | Entity<T>
  | SchemaObjectOne<T>;
export interface SchemaObjectOne<T> {
  [key: string]: SchemaOne<T>;
}
export type SchemaOf<T> = T extends SchemaOne<infer R> ? R : never;

const sch: Entity<ArticleResource> = ArticleResource.getEntitySchema();
const a = { a: sch  };
const aa: SchemaOne<ArticleResource> = a;
// works!
type Z = SchemaOf<typeof a>;
// Z is ArticleResource as expected

const b = { a: { b: sch }  };
type ZZ = SchemaOf<typeof b>;
// ZZ is unknown - SADBEAR

So I have my recursive definition matching correctly (methodology stolen from https://github.com/Microsoft/TypeScript/issues/3496#issuecomment-128553540 ). (hence the works after aa definition). However, now I want to be able to infer the type even without making it more general. (getting bb's type).

So for some reason this works only one level deep. Is this a limitation of typescript? Is there some sort of recursion with infer I can use to actually find the generic type?

Answer 1

I don't know how the compiler actually goes about inferring conditional types. I'm not surprised that there would be a limit to how many type instantiations it does before it gives up with unknown (or any ). Since infer R by itself doesn't do it for you, I'd suggest coming up with your own way of inspecting a type to determine what, if any, R should be returned for a given type.

First of all I'm defining these so that it compiles... your own types are likely different, but they're not in the question statement (so I get to pick them, right? ... right?)

// Making these up

interface Entity<T> {
  e: T;
}

class ArticleResource {
  static getEntitySchema<T>(): Entity<T> {
    return null!;
  }
  ar = "ArticleResource";
}

Here's one possible implementation of SchemaOf<T> :

type _SchemaOf<T> = T extends Entity<infer R>
  ? R
  : T extends object ? { [K in keyof T]: _SchemaOf<T[K]> }[keyof T] : never;

(I'm naming it _SchemaOf because I will use it to build my final SchemaOf ). Here, if T is just Entity<R> for some R , then return R . That's should work well. Otherwise, check if T is an object . If not, then just return never . (This allows us to short-circuit to never if we're checking against a primitive type). Otherwise, calculate the union of _SchemaOf<T[K]> for every key K of T . (Possible warning: This type doesn't seem to count as a circular conditional type, and does not result in a compiler error, but I'm not sure if it's exactly legal. See this GitHub issue for a discussion of circular conditional types.)

So, _SchemaOf<Entity<A>> should just be A , and _SchemaOf<{a: X, b: Y, c: Z}> should be equivalent to _SchemaOf<X> | _SchemaOf<Y> | _SchemaOf<Z> _SchemaOf<X> | _SchemaOf<Y> | _SchemaOf<Z> _SchemaOf<X> | _SchemaOf<Y> | _SchemaOf<Z> . That will end up recursing down through the object types and pulling out all Entity types and getting a union of them.

That's nearly what you want, but it does return some weird answers when you pass in something that's not a SchemaOne<T> for any T , like _SchemaOf<{a: Entity<A>, b: string}> . That will give you just A , even though {a: Entity<A>, b: string} is not a SchemaOne<A> .

So we do a sanity check like this:

type SchemaOf<T> = T extends SchemaOne<_SchemaOf<T>> ? _SchemaOf<T> : never;

We check the result of _SchemaOf<T> to make sure that SchemaOne<_SchemaOf<T>> matches T . If so, great. If not, we get never .

Let's test it out:

type Z = SchemaOf<typeof a>;
// Z is ArticleResource as expected

const b = { a: { b: sch } };
type ZZ = SchemaOf<typeof b>;
// ZZ is ArticleResource too

That works for you. And then:

const c = { a: { b: sch, c: "string" } };
type _C = _SchemaOf<typeof c>; // ArticleResource
type C = SchemaOf<typeof c>; // never

This rejects c , as I think you'd want. And, to see the union stuff:

const d = { a: sch, b: null! as Entity<string> };
type D = SchemaOf<typeof d>; // string | ArticleResource
const dd: SchemaOne<D> = d; // okay

Okay, hope that helps you proceed. Good luck!

Link to code