@FieldResolver not working on extended classes

[victorstein]

Describe the bug
When requesting data from a @FieldResolver from an extended class the field resolver gets triggered in the current class instead of the extended class.

To Reproduce
Given the base class below:

  @Resolver(() => returnType, { isAbstract: true })
  abstract class CRUDBaseResolver {

    @Query(() => returnType, { name: `${prefix}ById` })
    @Authorized(findById)
    async findById(
      @Args() { id }: byIdInterface,
      @Ctx() { permissions, user }: any
    ): Promise<T[]> {
       // ...search logic
    }

    @Query(() => paginationOutput, { name: `${prefix}s`, nullable: true })
    @Authorized(readAll)
    readAll (
      @Args() { perPage, page, filters = [], sort = [] }: paginationInterface,
      @Ctx() { permissions, user }: any
    ): paginationOutput {
       // ... pagination logic
    }

    @Mutation(() => Boolean, { name: `delete${capitalize(prefix)}ById` })
    @Authorized(deleteById)
    async deleteById (
      @Args() { id }: byIdInterface
    ): Promise<boolean> {
      //  ... deletion logic
    }

    @FieldResolver(() => User, { name: 'createdBy' })
    async createdBy (
      @Root() root: any
    ) {
      if (validator.isMongoId(root.createdBy)) {
        return userModel.findById(root.createdBy)
      }
      return root.createdBy
    }

  }

And the following extended class

@Resolver()
export default class ProjectResolvers extends CRUDProject {
  @Mutation(() => Project)
  @Authorized(['create_projects'])
  async createProject (
    @Args() {
      // ...some args
    }: createProjectInterface
  ): Promise<Project> {
    // ... creation logic
  }
}

Whenever I run a query or a mutation from the base class (e.g. findById) the @FieldResolver decorator responds as expected, thus resolving the database call; however, when running the createProject mutation from the extended class the @FieldResolver doesn't fire on the base class, it fires on the extended class.

Expected behavior
The @FieldResolver from the base class should handle the calls for that specific field.

Logs
N/A

Enviorment (please complete the following information):

• OS: Windows 10
• Node: 12.9.0
• Package version: ^0.17.6
• TypeScript version: ^3.7.4

[MichalLytek]

In mapSuperResolverHandlers it always moves the handlers (query, mutation, subscription and field resolver) from base class to a child class:

type-graphql/src/metadata/utils.ts

Lines 14 to 28 in 801a453

	export function mapSuperResolverHandlers<T extends BaseResolverMetadata>(
	definitions: T[],
	superResolver: Function,
	resolverMetadata: ResolverClassMetadata,
	): T[] {
	return definitions.map(metadata => {
	return metadata.target === superResolver
	? {
	...metadata,
	target: resolverMetadata.target,
	resolverClassMetadata: resolverMetadata,
	}
	: metadata;
	});
	}

As that's the dirty way to support inheritance without reimplementing whole schema generation pipeline.

And the reason why it's called on extended class is because of calling it with child class instance:

type-graphql/src/resolvers/create.ts

Line 81 in 801a453

return handlerOrGetterValue.apply(targetInstance, params);

As I'm not sure what is your real issue, please add in PR a failing tests for the extended resolver class with field resolver in this file:

type-graphql/tests/functional/resolvers.ts

Line 1899 in 801a453

describe("Inheritance", () => {

[victorstein]

Hey @MichalLytek, thanks for your prompt response.

I apologize if I wasn't clear enough. Maybe a little more code will help clarify things.

I have these models:

@ObjectType()
class base {
  @Field()
  createdBy: 'string'
}

@ObjectType()
class user extends base {
  @Field()
  name: 'string'
}

And the following resolvers:

@Resolver()
class userResolver extends baseResolver {
  @Mutation()
  createUser(
    @Args() { arguments }
  ) {
    return userModel.create(...arguments)
  }
}

@Resolver()
class baseResolver {
  @Query(() => user)
  findById (
    @Args() { id }
  ) {
    return userModel.findById(id)
  }

  @FieldResolver()
  createdBy(
    @Root() { id }
  ) {
    return userModel.findById(id)
  }
}

When Firing the following query:

query {
  findById (
    id: "validMongoId"
  ) {
    name
    createdBy {
      name
    }
  }
}

The createdBy field resolver works beautifully; however, when firing this mutation:

mutation {
  createUser (
    ...validArguments
  ) {
    name
    createdBy {
      name
    }
  }
}

The createdBy field returns undefined. I noticed that adding a @FieldResolver to the User class does fix the issue; however, I don't think that the @FieldResolvers should be fired from the class that inherited that field (user class).

P.D.
I read your suggestion regarding the PR on the tests. but I'm not that good making tests and would probably end up confusing things more than the currently are.

[MichalLytek]

All your examples are incorrect TypeGraphQL code that I'm unable to run.
The second one is missing type annotations, the first one is missing the returnType value as you extend CRUDProject not the CRUDBaseResolver example resolver.

So I can only guess that the problem is that base resolver has different object type provided in @Resolver(of => Type1) that the inherited mutation resolver @Resolver(of => Type2) or the mutation returns different @Mutation(returns => Type2) than the field resolver is attached to via @Resolver(of => Type1).

Please create a repository with a minimal reproducible code example. Otherwise I have to close this issue as not enough info is provided and cannot reproduce the bug.

[victorstein]

JESUS F**NG CHRIST!!

While making the minimal reproducible code example I found out what the error was. A simple validation on the resolver factory was screwing everything up. I appreciate your time.