graphql 1.8.7 → 1.9.0

data/spec/graphql/static_validation/rules/argument_literals_are_compatible_spec.rb

@@ -3,13 +3,14 @@ require "spec_helper"
 
 describe GraphQL::StaticValidation::ArgumentLiteralsAreCompatible do
   include StaticValidationHelpers
+  include ErrorBubblingHelpers
 
   let(:query_string) {%|
     query getCheese {
       stringCheese: cheese(id: "aasdlkfj") { ...cheeseFields }
       cheese(id: 1) { source @skip(if: "whatever") }
       yakSource: searchDairy(product: [{source: COW, fatContent: 1.1}]) { __typename }
-      badSource: searchDairy(product: [{source: 1.1}]) { __typename }
+      badSource: searchDairy(product: {source: 1.1}) { __typename }
       missingSource: searchDairy(product: [{fatContent: 1.1}]) { __typename }
       listCoerce: cheese(id: 1) { similarCheese(source: YAK) { __typename } }
       missingInputField: searchDairy(product: [{source: YAK, wacky: 1}]) { __typename }
@@ -20,65 +21,119 @@ describe GraphQL::StaticValidation::ArgumentLiteralsAreCompatible do
     }
   |}
 
-  it "finds undefined or missing-required arguments to fields and directives" do
-    # `wacky` above is handled by ArgumentsAreDefined, so only 6 are tested below
-    assert_equal(8, errors.length)
+  describe "with error bubbling disabled" do
+    it "finds undefined or missing-required arguments to fields and directives" do
+      without_error_bubbling(schema) do
+        # `wacky` above is handled by ArgumentsAreDefined, missingSource is handled by RequiredInputObjectAttributesArePresent
+        # so only 4 are tested below
+        assert_equal(6, errors.length)
+
+        query_root_error = {
+          "message"=>"Argument 'id' on Field 'stringCheese' has an invalid value. Expected type 'Int!'.",
+          "locations"=>[{"line"=>3, "column"=>7}],
+          "path"=>["query getCheese", "stringCheese", "id"],
+          "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"Field", "argumentName"=>"id"},
+        }
+        assert_includes(errors, query_root_error)
 
-    query_root_error = {
-      "message"=>"Argument 'id' on Field 'stringCheese' has an invalid value. Expected type 'Int!'.",
-      "locations"=>[{"line"=>3, "column"=>7}],
-      "fields"=>["query getCheese", "stringCheese", "id"],
-    }
-    assert_includes(errors, query_root_error)
+        directive_error = {
+          "message"=>"Argument 'if' on Directive 'skip' has an invalid value. Expected type 'Boolean!'.",
+          "locations"=>[{"line"=>4, "column"=>30}],
+          "path"=>["query getCheese", "cheese", "source", "if"],
+          "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"Directive", "argumentName"=>"if"},
+        }
+        assert_includes(errors, directive_error)
 
-    directive_error = {
-      "message"=>"Argument 'if' on Directive 'skip' has an invalid value. Expected type 'Boolean!'.",
-      "locations"=>[{"line"=>4, "column"=>30}],
-      "fields"=>["query getCheese", "cheese", "source", "if"],
-    }
-    assert_includes(errors, directive_error)
+        input_object_field_error = {
+          "message"=>"Argument 'source' on InputObject 'DairyProductInput' has an invalid value. Expected type 'DairyAnimal!'.",
+          "locations"=>[{"line"=>6, "column"=>39}],
+          "path"=>["query getCheese", "badSource", "product", "source"],
+          "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"InputObject", "argumentName"=>"source"},
+        }
+        assert_includes(errors, input_object_field_error)
 
-    input_object_error = {
-      "message"=>"Argument 'product' on Field 'badSource' has an invalid value. Expected type '[DairyProductInput]'.",
-      "locations"=>[{"line"=>6, "column"=>7}],
-      "fields"=>["query getCheese", "badSource", "product"],
-    }
-    assert_includes(errors, input_object_error)
+        fragment_error = {
+          "message"=>"Argument 'source' on Field 'similarCheese' has an invalid value. Expected type '[DairyAnimal!]!'.",
+          "locations"=>[{"line"=>13, "column"=>7}],
+          "path"=>["fragment cheeseFields", "similarCheese", "source"],
+          "extensions"=> {"code"=>"argumentLiteralsIncompatible", "typeName"=>"Field", "argumentName"=>"source"}
+        }
+        assert_includes(errors, fragment_error)
+      end
+    end
+    it 'works with error bubbling enabled' do
+      with_error_bubbling(schema) do
+        assert_equal(9, errors.length)
+
+        query_root_error = {
+          "message"=>"Argument 'id' on Field 'stringCheese' has an invalid value. Expected type 'Int!'.",
+          "locations"=>[{"line"=>3, "column"=>7}],
+          "path"=>["query getCheese", "stringCheese", "id"],
+          "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"Field", "argumentName"=>"id"},
+        }
+        assert_includes(errors, query_root_error)
 
-    input_object_field_error = {
-      "message"=>"Argument 'source' on InputObject 'DairyProductInput' has an invalid value. Expected type 'DairyAnimal!'.",
-      "locations"=>[{"line"=>6, "column"=>40}],
-      "fields"=>["query getCheese", "badSource", "product", "source"],
-    }
-    assert_includes(errors, input_object_field_error)
+        directive_error = {
+          "message"=>"Argument 'if' on Directive 'skip' has an invalid value. Expected type 'Boolean!'.",
+          "locations"=>[{"line"=>4, "column"=>30}],
+          "path"=>["query getCheese", "cheese", "source", "if"],
+          "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"Directive", "argumentName"=>"if"},
+        }
+        assert_includes(errors, directive_error)
 
-    missing_required_field_error = {
-      "message"=>"Argument 'product' on Field 'missingSource' has an invalid value. Expected type '[DairyProductInput]'.",
-      "locations"=>[{"line"=>7, "column"=>7}],
-      "fields"=>["query getCheese", "missingSource", "product"],
-    }
-    assert_includes(errors, missing_required_field_error)
+        input_object_error = {
+          "message"=>"Argument 'product' on Field 'badSource' has an invalid value. Expected type '[DairyProductInput]'.",
+          "locations"=>[{"line"=>6, "column"=>7}],
+          "path"=>["query getCheese", "badSource", "product"],
+          "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"Field", "argumentName"=>"product"},
+        }
+        assert_includes(errors, input_object_error)
 
-    fragment_error = {
-      "message"=>"Argument 'source' on Field 'similarCheese' has an invalid value. Expected type '[DairyAnimal!]!'.",
-      "locations"=>[{"line"=>13, "column"=>7}],
-      "fields"=>["fragment cheeseFields", "similarCheese", "source"],
-    }
-    assert_includes(errors, fragment_error)
+        input_object_field_error = {
+          "message"=>"Argument 'source' on InputObject 'DairyProductInput' has an invalid value. Expected type 'DairyAnimal!'.",
+          "locations"=>[{"line"=>6, "column"=>39}],
+          "path"=>["query getCheese", "badSource", "product", "source"],
+          "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"InputObject", "argumentName"=>"source"},
+        }
+        assert_includes(errors, input_object_field_error)
+
+        missing_required_field_error = {
+          "message"=>"Argument 'product' on Field 'missingSource' has an invalid value. Expected type '[DairyProductInput]'.",
+          "locations"=>[{"line"=>7, "column"=>7}],
+          "path"=>["query getCheese", "missingSource", "product"],
+          "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"Field", "argumentName"=>"product"}
+        }
+        assert_includes(errors, missing_required_field_error)
+
+        fragment_error = {
+          "message"=>"Argument 'source' on Field 'similarCheese' has an invalid value. Expected type '[DairyAnimal!]!'.",
+          "locations"=>[{"line"=>13, "column"=>7}],
+          "path"=>["fragment cheeseFields", "similarCheese", "source"],
+          "extensions"=> {"code"=>"argumentLiteralsIncompatible", "typeName"=>"Field", "argumentName"=>"source"}
+        }
+        assert_includes(errors, fragment_error)
+      end
+    end
   end
 
-  describe "using input objects for enums" do
+  describe "using input objects for enums it adds an error" do
     let(:query_string) { <<-GRAPHQL
       {
         yakSource: searchDairy(product: [{source: {a: 1, b: 2}, fatContent: 1.1}]) { __typename }
       }
     GRAPHQL
     }
-
-    it "adds an error" do
-      # TODO:
-      # It's annoying that this error cascades up, there should only be one:
-      assert_equal 2, errors.length
+    it "works with error bubbling disabled" do
+      without_error_bubbling(schema) do
+        assert_equal 1, errors.length
+      end
+    end
+    it "works with error bubbling enabled" do
+      with_error_bubbling(schema) do
+        # TODO:
+        # It's annoying that this error cascades up, there should only be one:
+        assert_equal 2, errors.length
+      end
     end
   end
 
@@ -120,7 +175,8 @@ describe GraphQL::StaticValidation::ArgumentLiteralsAreCompatible do
         assert_equal [{
           "message"=>"Argument 'arg' on Field 'field' has an invalid value. Expected type 'Int!'.",
           "locations"=>[{"line"=>3, "column"=>11}],
-          "fields"=>["query", "field", "arg"],
+          "path"=>["query", "field", "arg"],
+          "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"Field", "argumentName"=>"arg"}
         }], errors
       end
     end
@@ -143,7 +199,8 @@ describe GraphQL::StaticValidation::ArgumentLiteralsAreCompatible do
         assert_equal [{
           "message"=>"Argument 'arg' on Field 'field' has an invalid value. Expected type '[Int!]'.",
           "locations"=>[{"line"=>3, "column"=>11}],
-          "fields"=>["query", "field", "arg"],
+          "path"=>["query", "field", "arg"],
+          "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"Field", "argumentName"=>"arg"}
         }], errors
       end
     end
@@ -186,20 +243,42 @@ describe GraphQL::StaticValidation::ArgumentLiteralsAreCompatible do
         }
       |}
 
-      it "finds errors" do
-        assert_equal 2, errors.length
-
-        assert_includes errors, {
-          "message"=> "Argument 'arg' on Field 'field' has an invalid value. Expected type 'Input'.",
-          "locations"=>[{"line"=>3, "column"=>11}],
-          "fields"=>["query", "field", "arg"]
-        }
-
-        assert_includes errors, {
-          "message"=>"Argument 'b' on InputObject 'Input' has an invalid value. Expected type 'Int!'.",
-          "locations"=>[{"line"=>3, "column"=>22}],
-          "fields"=>["query", "field", "arg", "b"]
-        }
+      describe "it finds errors" do
+        it "works with error bubbling disabled" do
+          without_error_bubbling(schema) do
+            assert_equal 1, errors.length
+            refute_includes errors, {
+              "message"=>"Argument 'arg' on Field 'field' has an invalid value. Expected type 'Input'.",
+              "locations"=>[{"line"=>3, "column"=>11}],
+              "path"=>["query", "field", "arg"],
+              "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"Field", "argumentName"=>"arg"}
+            }
+            assert_includes errors, {
+              "message"=>"Argument 'b' on InputObject 'Input' has an invalid value. Expected type 'Int!'.",
+              "locations"=>[{"line"=>3, "column"=>22}],
+              "path"=>["query", "field", "arg", "b"],
+              "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"InputObject", "argumentName"=>"b"}
+            }
+          end
+        end
+        it "works with error bubbling enabled" do
+          with_error_bubbling(schema) do
+            assert_equal 2, errors.length
+            assert_includes errors, {
+              "message"=>"Argument 'arg' on Field 'field' has an invalid value. Expected type 'Input'.",
+              "locations"=>[{"line"=>3, "column"=>11}],
+              "path"=>["query", "field", "arg"],
+              "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"Field", "argumentName"=>"arg"}
+            }
+
+            assert_includes errors, {
+              "message"=>"Argument 'b' on InputObject 'Input' has an invalid value. Expected type 'Int!'.",
+              "locations"=>[{"line"=>3, "column"=>22}],
+              "path"=>["query", "field", "arg", "b"],
+              "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"InputObject", "argumentName"=>"b"}
+            }
+          end
+        end
       end
     end
   end
@@ -215,15 +294,15 @@ describe GraphQL::StaticValidation::ArgumentLiteralsAreCompatible do
       assert_includes(errors, {
         "message"=>"Argument 'name' on Field '__type' has an invalid value. Expected type 'String!'.",
         "locations"=>[{"line"=>3, "column"=>9}],
-        "fields"=>["query", "__type", "name"],
+        "path"=>["query", "__type", "name"],
+        "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"Field", "argumentName"=>"name"}
       })
     end
   end
 
   describe "custom error messages" do
     let(:schema) {
-
-      CoerceTestTimeType = GraphQL::ScalarType.define do
+      CoerceTestTimeType ||= GraphQL::ScalarType.define do
         name "Time"
         description "Time since epoch in seconds"
 
@@ -238,17 +317,26 @@ describe GraphQL::StaticValidation::ArgumentLiteralsAreCompatible do
         coerce_result ->(value, ctx) { value.to_f }
       end
 
-      CoerceTestQueryType = GraphQL::ObjectType.define do
+      CoerceTestDeepTimeType ||= GraphQL::InputObjectType.define do
+        name "range"
+        description "Time range"
+        argument :from, !CoerceTestTimeType
+        argument :to, !CoerceTestTimeType
+      end
+
+      CoerceTestQueryType ||= GraphQL::ObjectType.define do
         name "Query"
         description "The query root of this schema"
 
         field :time do
           type CoerceTestTimeType
-          argument :value, !CoerceTestTimeType
+          argument :value, CoerceTestTimeType
+          argument :range, CoerceTestDeepTimeType
           resolve ->(obj, args, ctx) { args[:value] }
         end
       end
 
+
       GraphQL::Schema.define do
         query CoerceTestQueryType
       end
@@ -260,14 +348,66 @@ describe GraphQL::StaticValidation::ArgumentLiteralsAreCompatible do
       }
     |}
 
-    it "sets error message from a CoercionError if raised" do
-      assert_equal 1, errors.length
+    describe "with a shallow coercion" do
+      it "sets error message from a CoercionError if raised" do
+        assert_equal 1, errors.length
 
-      assert_includes errors, {
-        "message"=> "cannot coerce to Float",
-        "locations"=>[{"line"=>3, "column"=>9}],
-        "fields"=>["query", "time", "value"]
+        assert_includes errors, {
+          "message"=> "cannot coerce to Float",
+          "locations"=>[{"line"=>3, "column"=>9}],
+          "path"=>["query", "time", "value"],
+          "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"CoercionError"}
+        }
+      end
+    end
+
+    describe "with a deep coercion" do
+      let(:query_string) {%|
+        query {
+          time(range: { from: "a", to: "b" })
+        }
+      |}
+
+      from_error = {
+        "message"=>"cannot coerce to Float",
+        "locations"=>[{"line"=>3, "column"=>23}],
+        "path"=>["query", "time", "range", "from"],
+        "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"CoercionError"},
+      }
+
+      to_error = {
+        "message"=>"cannot coerce to Float",
+        "locations"=>[{"line"=>3, "column"=>23}],
+        "path"=>["query", "time", "range", "to"],
+        "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"CoercionError"},
+      }
+
+      bubbling_error = {
+        "message"=>"cannot coerce to Float",
+        "locations"=>[{"line"=>3, "column"=>11}],
+        "path"=>["query", "time", "range"],
+        "extensions"=>{"code"=>"argumentLiteralsIncompatible", "typeName"=>"CoercionError"},
       }
+
+      describe "sets deep error message from a CoercionError if raised" do
+        it "works with error bubbling enabled" do
+          with_error_bubbling(schema) do
+            assert_equal 3, errors.length
+            assert_includes(errors, from_error)
+            assert_includes(errors, to_error)
+            assert_includes(errors, bubbling_error)
+          end
+        end
+
+        it "works without error bubbling enabled" do
+          without_error_bubbling(schema) do
+            assert_equal 2, errors.length
+            assert_includes(errors, from_error)
+            assert_includes(errors, to_error)
+            refute_includes(errors, bubbling_error)
+          end
+        end
+      end
     end
   end
 end

data/spec/graphql/static_validation/rules/argument_names_are_unique_spec.rb

@@ -19,7 +19,7 @@ describe GraphQL::StaticValidation::ArgumentNamesAreUnique do
       error = errors.first
       assert_equal 'There can be only one argument named "id"', error["message"]
       assert_equal [{ "line" => 2, "column" => 18}, { "line" => 2, "column" => 25 }], error["locations"]
-      assert_equal ["query GetStuff", "c1"], error["fields"]
+      assert_equal ["query GetStuff", "c1"], error["path"]
     end
   end
 
@@ -38,7 +38,7 @@ describe GraphQL::StaticValidation::ArgumentNamesAreUnique do
       error = errors.first
       assert_equal 'There can be only one argument named "if"', error["message"]
       assert_equal [{ "line" => 2, "column" => 34}, { "line" => 2, "column" => 44 }], error["locations"]
-      assert_equal ["query GetStuff", "c1"], error["fields"]
+      assert_equal ["query GetStuff", "c1"], error["path"]
     end
   end
 end

data/spec/graphql/static_validation/rules/arguments_are_defined_spec.rb

@@ -3,6 +3,7 @@ require "spec_helper"
 
 describe GraphQL::StaticValidation::ArgumentsAreDefined do
   include StaticValidationHelpers
+  include ErrorBubblingHelpers
 
   let(:query_string) {"
     query getCheese {
@@ -17,38 +18,79 @@ describe GraphQL::StaticValidation::ArgumentsAreDefined do
     }
   "}
 
-  it "finds undefined arguments to fields and directives" do
-    # There's an extra error here, the unexpected argument on "DairyProductInput"
-    # triggers _another_ error that the field expected a different type
-    assert_equal(5, errors.length)
+  describe "finds undefined arguments to fields and directives" do
+    it "works with error bubbling" do
+      with_error_bubbling(Dummy::Schema) do
+        # There's an extra error here, the unexpected argument on "DairyProductInput"
+        # triggers _another_ error that the field expected a different type
+        assert_equal(6, errors.length)
 
-    query_root_error = {
-      "message"=>"Field 'cheese' doesn't accept argument 'silly'",
-      "locations"=>[{"line"=>4, "column"=>14}],
-      "fields"=>["query getCheese", "cheese", "silly"],
-    }
-    assert_includes(errors, query_root_error)
+        query_root_error = {
+          "message"=>"Field 'cheese' doesn't accept argument 'silly'",
+          "locations"=>[{"line"=>4, "column"=>14}],
+          "path"=>["query getCheese", "cheese", "silly"],
+          "extensions"=>{
+            "code"=>"argumentNotAccepted",
+            "name"=>"cheese",
+            "typeName"=>"Field",
+            "argumentName"=>"silly"
+          },
+        }
+        assert_includes(errors, query_root_error)
 
-    input_obj_record = {
-      "message"=>"InputObject 'DairyProductInput' doesn't accept argument 'wacky'",
-      "locations"=>[{"line"=>5, "column"=>30}],
-      "fields"=>["query getCheese", "searchDairy", "product", "wacky"],
-    }
-    assert_includes(errors, input_obj_record)
+        input_obj_record = {
+          "message"=>"InputObject 'DairyProductInput' doesn't accept argument 'wacky'",
+          "locations"=>[{"line"=>5, "column"=>30}],
+          "path"=>["query getCheese", "searchDairy", "product", "wacky"],
+          "extensions"=>{
+            "code"=>"argumentNotAccepted",
+            "name"=>"DairyProductInput",
+            "typeName"=>"InputObject",
+            "argumentName"=>"wacky"
+          },
+        }
+        assert_includes(errors, input_obj_record)
 
-    fragment_error = {
-      "message"=>"Field 'similarCheese' doesn't accept argument 'nonsense'",
-      "locations"=>[{"line"=>9, "column"=>36}],
-      "fields"=>["fragment cheeseFields", "similarCheese", "nonsense"],
-    }
-    assert_includes(errors, fragment_error)
+        fragment_error = {
+          "message"=>"Field 'similarCheese' doesn't accept argument 'nonsense'",
+          "locations"=>[{"line"=>9, "column"=>36}],
+          "path"=>["fragment cheeseFields", "similarCheese", "nonsense"],
+          "extensions"=>{
+            "code"=>"argumentNotAccepted",
+            "name"=>"similarCheese",
+            "typeName"=>"Field",
+            "argumentName"=>"nonsense",
+          },
+        }
+        assert_includes(errors, fragment_error)
 
-    directive_error = {
-      "message"=>"Directive 'skip' doesn't accept argument 'something'",
-      "locations"=>[{"line"=>10, "column"=>16}],
-      "fields"=>["fragment cheeseFields", "id", "something"],
-    }
-    assert_includes(errors, directive_error)
+        directive_error = {
+          "message"=>"Directive 'skip' doesn't accept argument 'something'",
+          "locations"=>[{"line"=>10, "column"=>16}],
+          "path"=>["fragment cheeseFields", "id", "something"],
+          "extensions"=>{
+            "code"=>"argumentNotAccepted",
+            "name"=>"skip",
+            "typeName"=>"Directive",
+            "argumentName"=>"something",
+          },
+        }
+        assert_includes(errors, directive_error)
+      end
+    end
+
+    it "works without error bubbling" do
+      without_error_bubbling(Dummy::Schema) do
+        assert_equal(5, errors.length)
+
+        extra_error = {
+          "message"=>"Argument 'product' on Field 'searchDairy' has an invalid value. Expected type '[DairyProductInput]'.",
+          "locations"=>[{"line"=>5, "column"=>7}],
+          "path"=>["query getCheese", "searchDairy", "product"]
+        }
+        refute_includes(errors, extra_error)
+      end
+    end
   end
 
   describe "dynamic fields" do
@@ -62,7 +104,8 @@ describe GraphQL::StaticValidation::ArgumentsAreDefined do
       assert_includes(errors, {
         "message"=>"Field '__type' doesn't accept argument 'somethingInvalid'",
         "locations"=>[{"line"=>3, "column"=>16}],
-        "fields"=>["query", "__type", "somethingInvalid"],
+        "path"=>["query", "__type", "somethingInvalid"],
+        "extensions"=>{"code"=>"argumentNotAccepted", "name"=>"__type", "typeName"=>"Field", "argumentName"=>"somethingInvalid"}
       })
     end
   end

data/spec/graphql/static_validation/rules/directives_are_defined_spec.rb

@@ -20,11 +20,13 @@ describe GraphQL::StaticValidation::DirectivesAreDefined do
         {
           "message"=>"Directive @nonsense is not defined",
           "locations"=>[{"line"=>5, "column"=>16}],
-          "fields"=>["query getCheese", "okCheese", "source"],
+          "path"=>["query getCheese", "okCheese", "source"],
+          "extensions"=>{"code"=>"undefinedDirective", "directiveName"=>"nonsense"}
         }, {
           "message"=>"Directive @moreNonsense is not defined",
           "locations"=>[{"line"=>7, "column"=>18}],
-          "fields"=>["query getCheese", "okCheese", "... on Cheese", "flavor"],
+          "path"=>["query getCheese", "okCheese", "... on Cheese", "flavor"],
+          "extensions"=>{"code"=>"undefinedDirective", "directiveName"=>"moreNonsense"}
         }
       ]
       assert_equal(expected, errors)

data/spec/graphql/static_validation/rules/directives_are_in_valid_locations_spec.rb

@@ -26,12 +26,14 @@ describe GraphQL::StaticValidation::DirectivesAreInValidLocations do
         {
           "message"=> "'@skip' can't be applied to queries (allowed: fields, fragment spreads, inline fragments)",
           "locations"=>[{"line"=>2, "column"=>21}],
-          "fields"=>["query getCheese"],
+          "path"=>["query getCheese"],
+          "extensions"=>{"code"=>"directiveCannotBeApplied", "targetName"=>"queries", "name"=>"skip"}
         },
         {
           "message"=>"'@skip' can't be applied to fragment definitions (allowed: fields, fragment spreads, inline fragments)",
           "locations"=>[{"line"=>13, "column"=>33}],
-           "fields"=>["fragment whatever"],
+           "path"=>["fragment whatever"],
+           "extensions"=>{"code"=>"directiveCannotBeApplied", "targetName"=>"fragment definitions", "name"=>"skip"}
         },
       ]
       assert_equal(expected, errors)

data/spec/graphql/static_validation/rules/fields_are_defined_on_type_spec.rb

@@ -31,7 +31,8 @@ describe GraphQL::StaticValidation::FieldsAreDefinedOnType do
         {
           "message"=>"Field 'notDefinedField' doesn't exist on type 'Query'",
           "locations"=>[{"line"=>1, "column"=>18}],
-          "fields"=>["query getStuff", "notDefinedField"],
+          "path"=>["query getStuff", "notDefinedField"],
+          "extensions"=>{"code"=>"undefinedField", "typeName"=>"Query", "fieldName"=>"notDefinedField"}
         }
       ]
       assert_equal(expected_errors, errors)
@@ -46,7 +47,8 @@ describe GraphQL::StaticValidation::FieldsAreDefinedOnType do
         {
           "message"=>"Field 'amountThatILikeIt' doesn't exist on type 'Edible'",
           "locations"=>[{"line"=>1, "column"=>35}],
-          "fields"=>["query getStuff", "favoriteEdible", "amountThatILikeIt"],
+          "path"=>["query getStuff", "favoriteEdible", "amountThatILikeIt"],
+          "extensions"=>{"code"=>"undefinedField", "typeName"=>"Edible", "fieldName"=>"amountThatILikeIt"}
         }
       ]
       assert_equal(expected_errors, errors)
@@ -67,7 +69,8 @@ describe GraphQL::StaticValidation::FieldsAreDefinedOnType do
           "locations"=>[
             {"line"=>3, "column"=>7}
           ],
-          "fields"=>["fragment dpFields", "source"],
+          "path"=>["fragment dpFields", "source"],
+          "extensions"=>{"code"=>"selectionMismatch", "nodeName"=>"DairyProduct"}
         }
       ]
       assert_equal(expected_errors, errors)
@@ -120,7 +123,8 @@ describe GraphQL::StaticValidation::FieldsAreDefinedOnType do
             "locations"=>[
               {"line"=>2, "column"=>33}
             ],
-            "fields"=>["query", "cheese", "__schema"],
+            "path"=>["query", "cheese", "__schema"],
+            "extensions"=>{"code"=>"undefinedField", "typeName"=>"Cheese", "fieldName"=>"__schema"}
           }
         ]
         assert_equal(expected_errors, errors)
@@ -151,7 +155,8 @@ describe GraphQL::StaticValidation::FieldsAreDefinedOnType do
             "locations"=>[
               {"line"=>2, "column"=>33}
             ],
-            "fields"=>["query", "cheese", "__type"],
+            "path"=>["query", "cheese", "__type"],
+            "extensions"=>{"code"=>"undefinedField", "typeName"=>"Cheese", "fieldName"=>"__type"}
           }
         ]
         assert_equal(expected_errors, errors)