[Feature Request] Allow field resolvers on interface types

[jszwedko]

Expected Behaviour

I'd like to be able to specify that a field resolver should be generated on a GraphQL interface type.

The purpose of this is to reduce duplication of code for resolved fields that are resolved in the same way for all types implementing the interface.

If possible, it could look for a field resolver on the concrete type, and, if it finds none, fall back to the resolver on the interface type to allow overriding it in the cases where you might want to. For my particular use case, I have no need to override the field resolver on the interface type as they are all resolved in the same way for all implementations of the interface.

Actual Behavior

Right now, I have to specify that a resolver should be generated on the fields of each GraphQL type implementing the interface. This results in some duplication as, in my case, the shared fields are all resolved in the same fashion.

Minimal graphql.schema and models to reproduce

This is a simplified use case of ours (we have types modeling data sources that all share some configuration).

schema.graphql

interface Shape {
  id: ID!
  name: String!
}

type Rectangle implements Shape {
  id: ID!
  name: String!

  square: Boolean!
}

type Circle implements Shape {
  id: ID!
  name: String!
}

type Query {
  shapes: [Shape]
}

gqlgen.yml

# .gqlgen.yml example
#
# Refer to https://gqlgen.com/config/
# for detailed .gqlgen.yml documentation.

schema:
- schema.graphql
exec:
  filename: generated.go
model:
  filename: models_gen.go
resolver:
  filename: resolver.go
  type: Resolver

models:
  Shape:
    fields:
      id:
        resolver: true
      name:
        resolver: true

resolver.go generated

package test_gqlgen

import (
	"context"
) // THIS CODE IS A STARTING POINT ONLY. IT WILL NOT BE UPDATED WITH SCHEMA CHANGES.

type Resolver struct{}

func (r *Resolver) Query() QueryResolver {
	return &queryResolver{r}
}

type queryResolver struct{ *Resolver }

func (r *queryResolver) Shapes(ctx context.Context) ([]Shape, error) {
	panic("not implemented")
}

You'll note that no ShapeResolver type is generated.

[stale[bot]]

This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.

[jszwedko]

I would still very much like to see this :) Would save us some boilerplate.

[stale[bot]]

This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.

[jszwedko]

This is still an issue

[keyneston]

I'm also very interested in this feature. Right now I work around it by having an intermediate "type" with the fields in question. Then have a resolver on this. It is messy because your queries now end up as:

foo {
    intermediateManager {
        field1,
        field2,
    }
}

Rather than having the fields directly on foo.

[stale[bot]]

This issue has been automatically marked as stale because it has not had recent activity. It will be closed if no further activity occurs. Thank you for your contributions.

[jszwedko]

This is still an issue

[joaoinc]

I just ran into this one. @jszwedko did you find out any way to work around it short of duplicating code?

[jufemaiz]

follow

[noomz]

any update?

[duckbrain]

@joaoinc: This is a niche workaround, but in one case I had a model struct that implemented the interface, and the other models that implement the interface embedded the struct. The interface included a method to get a pointer of the embedded type. This captures all of the generated resolver fields. Then for the fields that need manual resolvers, I call the generic's resolver method to avoid duplication.

Schema

interface Foo { field: String! }
type GenericFoo implements Foo { ... }
type SpecialFoo implements Foo { ... }

Models

type Foo interface {
	Base() *GenericFoo
}

// GenericFoo implements Foo
type GenericFoo struct {}

type SpecialFoo struct { *GenericFoo }

Resolvers

func (r *specialFooResolver) Field(ctx context.Context, obj *models.SpecialFoo) (string, error) {
	gr := &genericFooResolver{Resolver: r.Resolver}
	return gr.Field(ctx, obj.GenericFoo)
}

func (r *genericFooResolver) Field(ctx context.Context, obj *models.GenericFoo) (string, error) {
    panic("not implemented")
}

I came here looking for a solution for types where the type that is embedded isn't the interface, since they almost always have the same resolver in my project. I'm thinking I'll define the generic resolver methods elsewhere and call them in each instance.