ResolverTypeWrapper on mapper types is redundant?

[warrenfalk]

I think maybe this is a bug, but I'm not sure.

If I define a mapper type

{
  config: {
    mappers: {
      Thing: 'mymodel#ModelThing' 
    }
  }
}

This results in a change from this:

export type ResolverTypes = {
  Thing: Thing;
}

...to the following:

export type ResolverTypes = {
  Thing: ResolverTypeWrapper<ModelThing>;
}

ResolverTypeWrapper is defined as type ResolverTypeWrapper<T> = Promise<T> | T which is easy to understand, but ResolverFn is already defined with the return type Promise<T> | T.

I don't understand this. The generated Thing type is not of the shape Promise<T> | T so why does ModelThing need to be of the shape Promise<T> | T? Wrapping it like that results in resolvers having the return type Promise<Promise<T> | T> | Promise<T> | T. Although this doesn't cause any problems because await is recursive such that Awaited<Promise<Promise<T> | T> | Promise<T> | T> == T, it does result in types that are more difficult to understand (and also makes it difficult to write conditional types with infer that are based on these).

From what I can tell, wrapping these in ResolverTypeWrapper doesn't do anything but complicate the types. I am not sure there's a reason to even have ResolverTypeWrapper.

So is this a bug?