How to implement field-level resolver with TypeScript?

[enheit]

Hello, I faced with an issue which I couldn't resolve on my own. I have a simple graph of objects

type Service {
  ...
  serviceGroups: [ServiceGroup!]!
  createdBy: User
}

type ServiceGroup {
  ...
  services: [Service!]!
}

type User {
  ...
}

I tried to represent this graph by using the type-graphql. At some point I stacked with field level resolvers and their interfaces. Check the following code and comments within resolvers.

@InterfaceType()
export class Node {
  @Field(type => ID)
  id: string
}

@ObjectType({ implements: Node })
export class Service extends Node {
  @Field()
  name: string

  @Field()
  description: string

  @Field()
  createdAt: Date

  @Field(type => User)
  createdBy: User

  @Field(type => ServiceGroup)
  serviceGroup: ServiceGroup
}

@ObjectType({ implements: Node })
export class ServiceGroup extends Node {
  @Field()
  name: string

  @Field(type => [Service])
  services: Service[]
}

@ObjectType({ implements: Node })
export class User extends Node {
  @Field()
  name: string

  @Field()
  email: string
}

@Injectable()
@Resolver(of => Service)
export class ServiceResolver implements ResolverInterface<Service> {
  @Query(type => Service)
  async service (): Promise<Service> {
   // Problem: The `ResolverInterface` forces me to return a `Service` (object-type) which has `serviceGroup` and `createdBy` fields. 
   // How can I return these properties if they should be resolver inside field-level resolver?
   // I expect to call a service here which will return a `serviceGroupId` and `creatorId` props which will be accessible via `@Root() service: Service` in field-level resolvers. But. The return type of this query forces me to put already populated objects like `serviceGroups: ServiceGroups` and `createdBy: User`, instead of `creatorId: string`, `serviceGroupId: string`
  }

  @FieldResolver(type => ServiceGroup)
  async serviceGroup (@Root() service: Service): Promise<ServiceGroup> {
     // There is no `serviceGroupId` prop in the `service` argument because of interface rules. It expect the `Service` value objects 
  }

  @FieldResolver(type => User)
  async createdBy (@Root() service: Service): Promise<User> {
     // There is no `creatorId` prop in the `service` argument because of interface rules. It expect the `Service` value objects   
  }
}

How to make it work in TypeScript world?

[MichalLytek]

1. Just don't use ResolverInterface
2. Define the fields "dynamically" - read the docs about that. You can define only field resolvers, it will automatically add fields to proper graphql types. Then your Service class signature gonna contain only ids not the relations arrays.

[MichalLytek]

Could you elaborate a little bit on that?

Where have you searched in docs and haven't found that chapter?

You proposed to define a field-level resolvers for each prop of the type?

Only for the complex ones, like serviceGroup and createdBy. You have them already, just remove those properties from the object type classes.

[enheit]

Only for the complex ones, like serviceGroup and createdBy. You have them already, just remove those properties from the object type classes.

I didn't know that properties like serviceGroup and createdBy can be avoided in a ObjectType and declared right inside a resolver. It is not clear from the documentation (maybe only for me). Thanks.

Where have you searched in docs and haven't found that chapter?

"Define the fields "dynamically" - that was the sentence that confused me. I thought that there was a special term "dynamic fields" in type-graphql that I missed in the doc. But as far I understand you meant just to exclude this props from the object types and declare them right in the resolvers.

[MichalLytek]

https://typegraphql.com/docs/types-and-fields.html

Note that if a field of an object type is purely calculable (e.g. averageRating from ratings array) and we don't want to pollute the class signature, we can omit it and just implement the field resolver (described in resolvers doc).

[MichalLytek]

https://typegraphql.com/docs/resolvers.html#field-resolvers

Note that if a field name of a field resolver doesn't exist in the resolver object type, it will create a field in the schema with this name. This feature is useful when the field is purely calculable (eg. averageRating from ratings array) and to avoid polluting the class signature.

[enheit]

Thanks a lot. I'll try to read the documentation more carefully next time.

I'll mark this conversation as answered.