Filter interface fragment fields based on concrete type

Author: mjm

graphql_test.go

@@ -1179,6 +1179,38 @@ func TestFragments(t *testing.T) {
 				}
 			`,
 		},
+		{
+			Schema:         starwarsSchema,
+			Query:          `
+				query {
+					human(id: "1000") {
+						id
+						mass
+						...characterInfo
+					}
+				}
+
+				fragment characterInfo on Character {
+					name
+					...on Droid {
+						primaryFunction
+					}
+					...on Human {
+						height
+					}
+				}
+			`,
+			ExpectedResult: `
+				{
+					"human": {
+						"id": "1000",
+						"mass": 77,
+						"name": "Luke Skywalker",
+						"height": 1.72
+					}
+				}
+			`,
+		},
 	})
 }
 

internal/exec/resolvable/meta.go

@@ -23,19 +23,19 @@ func newMeta(s *types.Schema) *Meta {
 	b := newBuilder(s)
 
 	metaSchema := s.Types["__Schema"].(*types.ObjectTypeDefinition)
-	so, err := b.makeObjectExec(metaSchema.Name, metaSchema.Fields, nil, false, reflect.TypeOf(&introspection.Schema{}))
+	so, err := b.makeObjectExec(metaSchema.Name, metaSchema.Fields, nil, nil, false, reflect.TypeOf(&introspection.Schema{}))
 	if err != nil {
 		panic(err)
 	}
 
 	metaType := s.Types["__Type"].(*types.ObjectTypeDefinition)
-	t, err := b.makeObjectExec(metaType.Name, metaType.Fields, nil, false, reflect.TypeOf(&introspection.Type{}))
+	t, err := b.makeObjectExec(metaType.Name, metaType.Fields, nil, nil, false, reflect.TypeOf(&introspection.Type{}))
 	if err != nil {
 		panic(err)
 	}
 
 	metaService := s.Types["_Service"].(*types.ObjectTypeDefinition)
-	sv, err := b.makeObjectExec(metaService.Name, metaService.Fields, nil, false, reflect.TypeOf(&introspection.Service{}))
+	sv, err := b.makeObjectExec(metaService.Name, metaService.Fields, nil, nil, false, reflect.TypeOf(&introspection.Service{}))
 	if err != nil {
 		panic(err)
 	}

internal/exec/resolvable/resolvable.go

@@ -28,6 +28,7 @@ type Object struct {
 	Name           string
 	Fields         map[string]*Field
 	TypeAssertions map[string]*TypeAssertion
+	Interfaces     map[string]struct{}
 }
 
 type Field struct {
@@ -158,13 +159,13 @@ func (b *execBuilder) makeExec(t types.Type, resolverType reflect.Type) (Resolva
 
 	switch t := t.(type) {
 	case *types.ObjectTypeDefinition:
-		return b.makeObjectExec(t.Name, t.Fields, nil, nonNull, resolverType)
+		return b.makeObjectExec(t.Name, t.Fields, nil, t.Interfaces, nonNull, resolverType)
 
 	case *types.InterfaceTypeDefinition:
-		return b.makeObjectExec(t.Name, t.Fields, t.PossibleTypes, nonNull, resolverType)
+		return b.makeObjectExec(t.Name, t.Fields, t.PossibleTypes, nil, nonNull, resolverType)
 
 	case *types.Union:
-		return b.makeObjectExec(t.Name, nil, t.UnionMemberTypes, nonNull, resolverType)
+		return b.makeObjectExec(t.Name, nil, t.UnionMemberTypes, nil, nonNull, resolverType)
 	}
 
 	if !nonNull {
@@ -218,7 +219,7 @@ func makeScalarExec(t *types.ScalarTypeDefinition, resolverType reflect.Type) (R
 }
 
 func (b *execBuilder) makeObjectExec(typeName string, fields types.FieldsDefinition, possibleTypes []*types.ObjectTypeDefinition,
-	nonNull bool, resolverType reflect.Type) (*Object, error) {
+	interfaces []*types.InterfaceTypeDefinition, nonNull bool, resolverType reflect.Type) (*Object, error) {
 	if !nonNull {
 		if resolverType.Kind() != reflect.Ptr && resolverType.Kind() != reflect.Interface {
 			return nil, fmt.Errorf("%s is not a pointer or interface", resolverType)
@@ -297,11 +298,16 @@ func (b *execBuilder) makeObjectExec(typeName string, fields types.FieldsDefinit
 			typeAssertions[impl.Name] = a
 		}
 	}
+	ifaces := make(map[string]struct{})
+	for _, iface := range interfaces {
+		ifaces[iface.Name] = struct{}{}
+	}
 
 	return &Object{
 		Name:           typeName,
 		Fields:         Fields,
 		TypeAssertions: typeAssertions,
+		Interfaces:     ifaces,
 	}, nil
 }
 

internal/exec/selected/selected.go

@@ -185,6 +185,10 @@ func applySelectionSet(r *Request, s *resolvable.Schema, e *resolvable.Object, s
 
 func applyFragment(r *Request, s *resolvable.Schema, e *resolvable.Object, frag *types.Fragment) []Selection {
 	if frag.On.Name != e.Name {
+		if _, ok := e.Interfaces[frag.On.Name]; ok {
+			return applyInterfaceFragment(r, s, e, frag)
+		}
+
 		t := r.Schema.Resolve(frag.On.Name)
 		face, ok := t.(*types.InterfaceTypeDefinition)
 		if !ok && frag.On.Name != "" {
@@ -221,6 +225,36 @@ func applyFragment(r *Request, s *resolvable.Schema, e *resolvable.Object, frag
 	return applySelectionSet(r, s, e, frag.Selections)
 }
 
+func applyInterfaceFragment(r *Request, s *resolvable.Schema, e *resolvable.Object, frag *types.Fragment) []Selection {
+	// if the fragment is on an interface the object type implements, then filter out
+	// selections for any fragments that don't match this type.
+	var sels []types.Selection
+
+	for _, sel := range frag.Selections {
+		switch sel := sel.(type) {
+		case *types.Field:
+			sels = append(sels, sel)
+		case *types.InlineFragment:
+			if sel.On.Name != e.Name {
+				if _, ok := e.Interfaces[sel.On.Name]; !ok {
+					continue
+				}
+			}
+			sels = append(sels, sel)
+		case *types.FragmentSpread:
+			f := &r.Doc.Fragments.Get(sel.Name.Name).Fragment
+			if f.On.Name != e.Name {
+				if _, ok := e.Interfaces[f.On.Name]; !ok {
+					continue
+				}
+			}
+			sels = append(sels, sel)
+		}
+	}
+
+	return applySelectionSet(r, s, e, sels)
+}
+
 func applyField(r *Request, s *resolvable.Schema, e resolvable.Resolvable, sels []types.Selection) []Selection {
 	switch e := e.(type) {
 	case *resolvable.Object: