Add path to validation errors

Author: rmosolgo

lib/graphql/language/parser.rb

@@ -6,23 +6,27 @@ class Message
       # Convenience for validators
       module MessageHelper
         # Error `message` is located at `node`
-        def message(message, node)
-          GraphQL::StaticValidation::Message.new(message, line: node.line, col: node.col)
+        def message(message, node, context: nil, path: nil)
+          path ||= context.path
+          GraphQL::StaticValidation::Message.new(message, line: node.line, col: node.col, path: path)
         end
       end
-      attr_reader :message, :line, :col
 
-      def initialize(message, line: nil, col: nil)
+      attr_reader :message, :line, :col, :path
+
+      def initialize(message, line: nil, col: nil, path: [])
         @message = message
         @line = line
         @col = col
+        @path = path
       end
 
       # A hash representation of this Message
       def to_h
         {
           "message" => message,
-          "locations" => locations
+          "locations" => locations,
+          "path" => path,
         }
       end
 

lib/graphql/static_validation/message.rb

@@ -10,7 +10,7 @@ def validate_node(parent, node, defn, context)
         if !valid
           kind_of_node = node_type(parent)
           error_arg_name = parent_name(parent, defn)
-          context.errors << message("Argument '#{node.name}' on #{kind_of_node} '#{error_arg_name}' has an invalid value", parent)
+          context.errors << message("Argument '#{node.name}' on #{kind_of_node} '#{error_arg_name}' has an invalid value", parent, context: context)
         end
       end
     end

lib/graphql/static_validation/rules/argument_literals_are_compatible.rb

@@ -6,7 +6,7 @@ def validate_node(parent, node, defn, context)
         if argument_defn.nil?
           kind_of_node = node_type(parent)
           error_arg_name = parent_name(parent, defn)
-          context.errors << message("#{kind_of_node} '#{error_arg_name}' doesn't accept argument '#{node.name}'", parent)
+          context.errors << message("#{kind_of_node} '#{error_arg_name}' doesn't accept argument '#{node.name}'", parent, context: context)
           GraphQL::Language::Visitor::SKIP
         else
           nil

lib/graphql/static_validation/rules/arguments_are_defined.rb

@@ -6,15 +6,15 @@ class DirectivesAreDefined
       def validate(context)
         directive_names = context.schema.directives.keys
         context.visitor[GraphQL::Language::Nodes::Directive] << -> (node, parent) {
-          validate_directive(node, directive_names, context.errors)
+          validate_directive(node, directive_names, context)
         }
       end
 
       private
 
-      def validate_directive(ast_directive, directive_names, errors)
+      def validate_directive(ast_directive, directive_names, context)
         if !directive_names.include?(ast_directive.name)
-          errors << message("Directive @#{ast_directive.name} is not defined", ast_directive)
+          context.errors << message("Directive @#{ast_directive.name} is not defined", ast_directive, context: context)
         end
       end
     end

lib/graphql/static_validation/rules/directives_are_defined.rb

@@ -8,7 +8,7 @@ def validate(context)
         directives = context.schema.directives
 
         context.visitor[Nodes::Directive] << -> (node, parent) {
-          validate_location(node, parent, directives, context.errors)
+          validate_location(node, parent, directives, context)
         }
       end
 
@@ -33,25 +33,25 @@ def validate(context)
 
       SIMPLE_LOCATION_NODES = SIMPLE_LOCATIONS.keys
 
-      def validate_location(ast_directive, ast_parent, directives, errors)
+      def validate_location(ast_directive, ast_parent, directives, context)
         directive_defn = directives[ast_directive.name]
         case ast_parent
         when Nodes::OperationDefinition
           required_location = GraphQL::Directive.const_get(ast_parent.operation_type.upcase)
-          assert_includes_location(directive_defn, ast_directive, required_location, errors)
+          assert_includes_location(directive_defn, ast_directive, required_location, context)
         when *SIMPLE_LOCATION_NODES
           required_location = SIMPLE_LOCATIONS[ast_parent.class]
-          assert_includes_location(directive_defn, ast_directive, required_location, errors)
+          assert_includes_location(directive_defn, ast_directive, required_location, context)
         else
-          errors << message("Directives can't be applied to #{ast_parent.class.name}s", ast_directive)
+          context.errors << message("Directives can't be applied to #{ast_parent.class.name}s", ast_directive, context: context)
         end
       end
 
-      def assert_includes_location(directive_defn, directive_ast, required_location, errors)
+      def assert_includes_location(directive_defn, directive_ast, required_location, context)
         if !directive_defn.locations.include?(required_location)
           location_name = LOCATION_MESSAGE_NAMES[required_location]
           allowed_location_names = directive_defn.locations.map { |loc| LOCATION_MESSAGE_NAMES[loc] }
-          errors << message("'@#{directive_defn.name}' can't be applied to #{location_name} (allowed: #{allowed_location_names.join(", ")})", directive_ast)
+          context.errors << message("'@#{directive_defn.name}' can't be applied to #{location_name} (allowed: #{allowed_location_names.join(", ")})", directive_ast, context: context)
         end
       end
     end

lib/graphql/static_validation/rules/directives_are_in_valid_locations.rb

@@ -9,21 +9,21 @@ def validate(context)
           return if context.skip_field?(node.name)
           parent_type = context.object_types[-2]
           parent_type = parent_type.unwrap
-          validate_field(context.errors, node, parent_type, parent)
+          validate_field(context, node, parent_type, parent)
         }
       end
 
       private
 
-      def validate_field(errors, ast_field, parent_type, parent)
+      def validate_field(context, ast_field, parent_type, parent)
         if parent_type.kind.union?
-          errors << message("Selections can't be made directly on unions (see selections on #{parent_type.name})", parent)
+          context.errors << message("Selections can't be made directly on unions (see selections on #{parent_type.name})", parent, context: context)
           return GraphQL::Language::Visitor::SKIP
         end
 
         field =  parent_type.get_field(ast_field.name)
         if field.nil?
-          errors << message("Field '#{ast_field.name}' doesn't exist on type '#{parent_type.name}'", parent)
+          context.errors << message("Field '#{ast_field.name}' doesn't exist on type '#{parent_type.name}'", parent, context: context)
           return GraphQL::Language::Visitor::SKIP
         end
       end

lib/graphql/static_validation/rules/fields_are_defined_on_type.rb

@@ -9,25 +9,25 @@ def validate(context)
         context.visitor[GraphQL::Language::Nodes::Field] << -> (node, parent)  {
           return if context.skip_field?(node.name)
           field_defn = context.field_definition
-          validate_field_selections(node, field_defn, context.errors)
+          validate_field_selections(node, field_defn, context)
         }
       end
 
       private
 
-      def validate_field_selections(ast_field, field_defn, errors)
+      def validate_field_selections(ast_field, field_defn, context)
         resolved_type = field_defn.type.unwrap
 
         if resolved_type.kind.scalar? && ast_field.selections.any?
-          error = message("Selections can't be made on scalars (field '#{ast_field.name}' returns #{resolved_type.name} but has selections [#{ast_field.selections.map(&:name).join(", ")}])", ast_field)
+          error = message("Selections can't be made on scalars (field '#{ast_field.name}' returns #{resolved_type.name} but has selections [#{ast_field.selections.map(&:name).join(", ")}])", ast_field, context: context)
         elsif resolved_type.kind.object? && ast_field.selections.none?
-          error = message("Objects must have selections (field '#{ast_field.name}' returns #{resolved_type.name} but has no selections)", ast_field)
+          error = message("Objects must have selections (field '#{ast_field.name}' returns #{resolved_type.name} but has no selections)", ast_field, context: context)
         else
           error = nil
         end
 
         if !error.nil?
-          errors << error
+          context.errors << error
           GraphQL::Language::Visitor::SKIP
         end
       end

lib/graphql/static_validation/rules/fields_have_appropriate_selections.rb

@@ -22,7 +22,7 @@ def validate(context)
 
       def find_conflicts(field_map, context)
         field_map.each do |name, ast_fields|
-          comparison = FieldDefinitionComparison.new(name, ast_fields)
+          comparison = FieldDefinitionComparison.new(name, ast_fields, context)
           context.errors.push(*comparison.errors)
 
 
@@ -63,27 +63,27 @@ class FieldDefinitionComparison
         include GraphQL::StaticValidation::Message::MessageHelper
         NAMED_VALUES = [GraphQL::Language::Nodes::Enum, GraphQL::Language::Nodes::VariableIdentifier]
         attr_reader :errors
-        def initialize(name, defs)
+        def initialize(name, defs, context)
           errors = []
 
           names = defs.map(&:name).uniq
           if names.length != 1
-            errors << message("Field '#{name}' has a field conflict: #{names.join(" or ")}?", defs.first)
+            errors << message("Field '#{name}' has a field conflict: #{names.join(" or ")}?", defs.first, context: context)
           end
 
           args = defs.map { |defn| reduce_list(defn.arguments)}.uniq
           if args.length != 1
-            errors << message("Field '#{name}' has an argument conflict: #{args.map {|a| JSON.dump(a) }.join(" or ")}?", defs.first)
+            errors << message("Field '#{name}' has an argument conflict: #{args.map {|a| JSON.dump(a) }.join(" or ")}?", defs.first, context: context)
           end
 
           directive_names = defs.map { |defn| defn.directives.map(&:name) }.uniq
           if directive_names.length != 1
-            errors << message("Field '#{name}' has a directive conflict: #{directive_names.map {|names| "[#{names.join(", ")}]"}.join(" or ")}?", defs.first)
+            errors << message("Field '#{name}' has a directive conflict: #{directive_names.map {|names| "[#{names.join(", ")}]"}.join(" or ")}?", defs.first, context: context)
           end
 
           directive_args = defs.map {|defn| defn.directives.map {|d| reduce_list(d.arguments) } }.uniq
           if directive_args.length != 1
-            errors << message("Field '#{name}' has a directive argument conflict: #{directive_args.map {|args| JSON.dump(args)}.join(" or ")}?", defs.first)
+            errors << message("Field '#{name}' has a directive argument conflict: #{directive_args.map {|args| JSON.dump(args)}.join(" or ")}?", defs.first, context: context)
           end
 
           @errors = errors

lib/graphql/static_validation/rules/fields_will_merge.rb

@@ -9,34 +9,33 @@ def validate(context)
           fragment_parent = context.object_types[-2]
           fragment_child = context.object_types.last
           if fragment_child
-            validate_fragment_in_scope(fragment_parent, fragment_child, node, context)
+            validate_fragment_in_scope(fragment_parent, fragment_child, node, context, context.path)
           end
         }
 
         spreads_to_validate = []
 
         context.visitor[GraphQL::Language::Nodes::FragmentSpread] << -> (node, parent) {
           fragment_parent = context.object_types.last
-          spreads_to_validate << [node, fragment_parent]
+          spreads_to_validate << FragmentSpread.new(node: node, parent_type: fragment_parent, path: context.path)
         }
 
-        context.visitor[GraphQL::Language::Nodes::Document].leave << -> (node, parent) {
-          spreads_to_validate.each do |spread_values|
-            node, fragment_parent = spread_values
-            fragment_child_name = context.fragments[node.name].type
+        context.visitor[GraphQL::Language::Nodes::Document].leave << -> (doc_node, parent) {
+          spreads_to_validate.each do |frag_spread|
+            fragment_child_name = context.fragments[frag_spread.node.name].type
             fragment_child = context.schema.types[fragment_child_name]
-            validate_fragment_in_scope(fragment_parent, fragment_child, node, context)
+            validate_fragment_in_scope(frag_spread.parent_type, fragment_child, frag_spread.node, context, frag_spread.path)
           end
         }
       end
 
       private
 
-      def validate_fragment_in_scope(parent_type, child_type, node, context)
+      def validate_fragment_in_scope(parent_type, child_type, node, context, path)
         intersecting_types = get_possible_types(parent_type, context.schema) & get_possible_types(child_type, context.schema)
         if intersecting_types.none?
           name = node.respond_to?(:name) ? " #{node.name}" : ""
-          context.errors << message("Fragment#{name} on #{child_type.name} can't be spread inside #{parent_type.name}", node)
+          context.errors << message("Fragment#{name} on #{child_type.name} can't be spread inside #{parent_type.name}", node, path: path)
         end
       end
 
@@ -51,6 +50,15 @@ def get_possible_types(type, schema)
           []
         end
       end
+
+      class FragmentSpread
+        attr_reader :node, :parent_type, :path
+        def initialize(node:, parent_type:, path:)
+          @node = node
+          @parent_type = parent_type
+          @path = path
+        end
+      end
     end
   end
 end