Property 'base' in type 'PersonResolver' is not assignable to the same property in base type 'ResolverInterface<Person>'.

[kaykhancheckpoint]

I have a custom Person Type which returns a base field of the original PersonDB Type.

However my base field resolver returns the following error

Diagnostics:
1. Property 'base' in type 'PersonResolver' is not assignable to the same property in base type 'ResolverInterface<Person>'.
     Type '(person: Person) => Person' is not assignable to type '(root: Person, ...args: any[]) => PersonDB | Promise<PersonDB>'.
       Type 'Person' is not assignable to type 'PersonDB | Promise<PersonDB>'.
         Type 'Person' is missing the following properties from type 'Promise<PersonDB>': then, catch, finally, [Symbol.toStringTag]

• If i remove ResolverInterface<Person> it works.
  OR
• if i add extends PersonDB to the Person type it works but it allows users to select properties from PersonDB in the root which i don't want to allow.

import { Field, ObjectType } from "type-graphql";
import PersonDB from "../../types/PersonDB";

@ObjectType()
export default class Person {
    @Field()
    base: PersonDB;
}

PersonResolver.ts

import { PrismaClient } from "@prisma/client";
import { Arg, Ctx, FieldResolver, Query, Resolver, ResolverInterface, Root } from "type-graphql";
import Person from "../types/person.type";

@Resolver(Person)
export class PersonResolver implements ResolverInterface<Person> {
    @Query(() => Person)
    async person(@Arg("id") id: string, @Ctx() ctx) {
        const db: PrismaClient = ctx.prisma;
        return db.person.findUnique({ where: { id: id } });
    }

    @FieldResolver()
    base(@Root() person: Person) {
        return person;
    }
}

[MichalLytek]

Just don't use ResolverInterface, it's an optional helper that doesn't fit your needs.

[jbmikk]

I wrote a custom ResolverInterface to solve this problem. It uses mapped types to associate the inner type to the Apollo type so you can map a different class to your apollo type and get the types right in your resolver:

export const MappedType = Symbol("MappedType");

export type Mapped<T> = T extends { [MappedType]: infer M }
  ? M
  : T extends Array<{ [MappedType]: infer N }>
  ? N[]
  : T;

export type ResolverInterface<T extends object> = {
  [P in keyof T]?: (root: Mapped<T>, ...args: any[]) => Mapped<T[P]> | Promise<Mapped<T[P]>>;
};

Then you can type an object like this:

      @ObjectType()
      class SampleChildObject {
        [MappedType]: SurrogateObject;

        @Field()
        normalField: string;
      }

And your resolver gets typed like this:

      @Resolver(of => SampleChildObject)
      class SampleChildResolver implements ResolverInterface<SampleChildObject> {
        @FieldResolver()
        normalField(@Root() root: SurrogateObject) {
          return root.hiddenField;
        }
      }

We have been using this in our system and it works great.
I opened a PR for this, as it is backwards compatible: #1120