validation: fragment type

internal/query/query.go

@@ -36,6 +36,7 @@ type NamedFragment struct {
 
 type Fragment struct {
 	On         string
+	OnLoc      *errors.Location
 	SelSet     *SelectionSet
 	Directives map[string]common.ArgumentList
 }
@@ -124,6 +125,7 @@ func resolveSelection(doc *Document, sel Selection) (Selection, *errors.QueryErr
 		}
 		return &Fragment{
 			On:         frag.On,
+			OnLoc:      frag.OnLoc,
 			SelSet:     frag.SelSet,
 			Directives: sel.Directives,
 		}, nil
@@ -188,6 +190,7 @@ func parseFragment(l *lexer.Lexer) *NamedFragment {
 	f := &NamedFragment{}
 	f.Name = l.ConsumeIdent()
 	l.ConsumeKeyword("on")
+	f.OnLoc = l.Location()
 	f.On = l.ConsumeIdent()
 	f.SelSet = parseSelectionSet(l)
 	return f
@@ -245,6 +248,7 @@ func parseSpread(l *lexer.Lexer) Selection {
 			fs.Directives = common.ParseDirectives(l)
 			return fs
 		}
+		f.OnLoc = l.Location()
 		f.On = l.ConsumeIdent()
 	}
 	f.Directives = common.ParseDirectives(l)

internal/tests/testdata/export.js

@@ -47,6 +47,7 @@ Module._load = function(request, parent, isMain) {
 require('./src/validation/__tests__/ArgumentsOfCorrectType-test.js');
 require('./src/validation/__tests__/DefaultValuesOfCorrectType-test.js');
 require('./src/validation/__tests__/FieldsOnCorrectType-test.js');
+require('./src/validation/__tests__/FragmentsOnCompositeTypes-test.js');
 
 let output = JSON.stringify(tests, null, 2)
 output = output.replace('{stringListField: [\\"one\\", 2], requiredField: true}', '{requiredField: true, stringListField: [\\"one\\", 2]}');

internal/tests/testdata/tests.json

@@ -1053,5 +1053,90 @@
     "name": "Validate: Fields on correct type/valid field in inline fragment",
     "query": "\n      fragment objectFieldSelection on Pet {\n        ... on Dog {\n          name\n        }\n        ... {\n          name\n        }\n      }\n    ",
     "errors": []
+  },
+  {
+    "name": "Validate: Fragments on composite types/object is valid fragment type",
+    "query": "\n      fragment validFragment on Dog {\n        barks\n      }\n    ",
+    "errors": []
+  },
+  {
+    "name": "Validate: Fragments on composite types/interface is valid fragment type",
+    "query": "\n      fragment validFragment on Pet {\n        name\n      }\n    ",
+    "errors": []
+  },
+  {
+    "name": "Validate: Fragments on composite types/object is valid inline fragment type",
+    "query": "\n      fragment validFragment on Pet {\n        ... on Dog {\n          barks\n        }\n      }\n    ",
+    "errors": []
+  },
+  {
+    "name": "Validate: Fragments on composite types/inline fragment without type is valid",
+    "query": "\n      fragment validFragment on Pet {\n        ... {\n          name\n        }\n      }\n    ",
+    "errors": []
+  },
+  {
+    "name": "Validate: Fragments on composite types/union is valid fragment type",
+    "query": "\n      fragment validFragment on CatOrDog {\n        __typename\n      }\n    ",
+    "errors": []
+  },
+  {
+    "name": "Validate: Fragments on composite types/scalar is invalid fragment type",
+    "query": "\n      fragment scalarFragment on Boolean {\n        bad\n      }\n    ",
+    "errors": [
+      {
+        "message": "Fragment \"scalarFragment\" cannot condition on non composite type \"Boolean\".",
+        "locations": [
+          {
+            "line": 2,
+            "column": 34
+          }
+        ]
+      }
+    ]
+  },
+  {
+    "name": "Validate: Fragments on composite types/enum is invalid fragment type",
+    "query": "\n      fragment scalarFragment on FurColor {\n        bad\n      }\n    ",
+    "errors": [
+      {
+        "message": "Fragment \"scalarFragment\" cannot condition on non composite type \"FurColor\".",
+        "locations": [
+          {
+            "line": 2,
+            "column": 34
+          }
+        ]
+      }
+    ]
+  },
+  {
+    "name": "Validate: Fragments on composite types/input object is invalid fragment type",
+    "query": "\n      fragment inputFragment on ComplexInput {\n        stringField\n      }\n    ",
+    "errors": [
+      {
+        "message": "Fragment \"inputFragment\" cannot condition on non composite type \"ComplexInput\".",
+        "locations": [
+          {
+            "line": 2,
+            "column": 33
+          }
+        ]
+      }
+    ]
+  },
+  {
+    "name": "Validate: Fragments on composite types/scalar is invalid inline fragment type",
+    "query": "\n      fragment invalidFragment on Pet {\n        ... on String {\n          barks\n        }\n      }\n    ",
+    "errors": [
+      {
+        "message": "Fragment cannot condition on non composite type \"String\".",
+        "locations": [
+          {
+            "line": 3,
+            "column": 16
+          }
+        ]
+      }
+    ]
   }
 ]

internal/validation/validation.go

@@ -48,22 +48,26 @@ func Validate(s *schema.Schema, q *query.Document) (errs []*errors.QueryError) {
 	}
 
 	for _, frag := range q.Fragments {
+		errs = append(errs, validateDirectives(s, frag.Directives)...)
 		t, ok := s.Types[frag.On]
 		if !ok {
 			continue
 		}
+		if !canBeFragment(t) {
+			errs = append(errs, errors.ErrorfWithLoc(frag.OnLoc, "Fragment %q cannot condition on non composite type %q.", frag.Name, t))
+			continue
+		}
 		errs = append(errs, validateSelectionSet(s, frag.SelSet, t)...)
 	}
 
 	return
 }
 
-func validateSelectionSet(s *schema.Schema, selSet *query.SelectionSet, t common.Type) []*errors.QueryError {
-	var errs []*errors.QueryError
+func validateSelectionSet(s *schema.Schema, selSet *query.SelectionSet, t common.Type) (errs []*errors.QueryError) {
 	for _, sel := range selSet.Selections {
 		errs = append(errs, validateSelection(s, sel, t)...)
 	}
-	return errs
+	return
 }
 
 func validateSelection(s *schema.Schema, sel query.Selection, t common.Type) (errs []*errors.QueryError) {
@@ -100,10 +104,14 @@ func validateSelection(s *schema.Schema, sel query.Selection, t common.Type) (er
 		}
 
 	case *query.Fragment:
+		errs = append(errs, validateDirectives(s, sel.Directives)...)
 		if sel.On != "" {
 			t = s.Types[sel.On]
 		}
-		errs = append(errs, validateDirectives(s, sel.Directives)...)
+		if !canBeFragment(t) {
+			errs = append(errs, errors.ErrorfWithLoc(sel.OnLoc, "Fragment cannot condition on non composite type %q.", t))
+			return
+		}
 		errs = append(errs, validateSelectionSet(s, sel.SelSet, t)...)
 
 	default:
@@ -118,10 +126,8 @@ func fields(t common.Type) schema.FieldList {
 		return t.Fields
 	case *schema.Interface:
 		return t.Fields
-	case *schema.Union, nil:
-		return nil
 	default:
-		panic("unreachable")
+		return nil
 	}
 }
 
@@ -258,6 +264,15 @@ func validateLiteral(v *lexer.Literal, t common.Type) bool {
 	return false
 }
 
+func canBeFragment(t common.Type) bool {
+	switch t.(type) {
+	case *schema.Object, *schema.Interface, *schema.Union:
+		return true
+	default:
+		return false
+	}
+}
+
 func stringify(v interface{}) string {
 	switch v := v.(type) {
 	case *lexer.Literal: