graphql 1.9.0.pre1 → 1.9.0.pre2

data/lib/graphql/static_validation/rules/arguments_are_defined_error.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class ArgumentsAreDefinedError < StaticValidation::Error
+      attr_reader :name
+      attr_reader :type_name
+      attr_reader :argument_name
+
+      def initialize(message, path: nil, nodes: [], name:, type:, argument:)
+        super(message, path: path, nodes: nodes)
+        @name = name
+        @type_name = type
+        @argument_name = argument
+      end
+
+      # A hash representation of this Message
+      def to_h
+        extensions = {
+          "code" => code,
+          "name" => name,
+          "typeName" => type_name,
+          "argumentName" => argument_name
+        }
+
+        super.merge({
+          "extensions" => extensions
+        })
+      end
+
+      def code
+        "argumentNotAccepted"
+      end
+    end
+  end
+end

data/lib/graphql/static_validation/rules/directives_are_defined.rb

@@ -9,7 +9,11 @@ module GraphQL
 
       def on_directive(node, parent)
         if !@directive_names.include?(node.name)
-          add_error("Directive @#{node.name} is not defined", node)
+          add_error(GraphQL::StaticValidation::DirectivesAreDefinedError.new(
+            "Directive @#{node.name} is not defined",
+            nodes: node,
+            directive: node.name
+          ))
         else
           super
         end

data/lib/graphql/static_validation/rules/directives_are_defined_error.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class DirectivesAreDefinedError < StaticValidation::Error
+      attr_reader :directive_name
+
+      def initialize(message, path: nil, nodes: [], directive:)
+        super(message, path: path, nodes: nodes)
+        @directive_name = directive
+      end
+
+      # A hash representation of this Message
+      def to_h
+        extensions = {
+          "code" => code,
+          "directiveName" => directive_name
+        }
+
+        super.merge({
+          "extensions" => extensions
+        })
+      end
+
+      def code
+        "undefinedDirective"
+      end
+    end
+  end
+end

data/lib/graphql/static_validation/rules/directives_are_in_valid_locations.rb

@@ -40,7 +40,11 @@ module GraphQL
           required_location = SIMPLE_LOCATIONS[ast_parent.class]
           assert_includes_location(directive_defn, ast_directive, required_location)
         else
-          add_error("Directives can't be applied to #{ast_parent.class.name}s", ast_directive)
+          add_error(GraphQL::StaticValidation::DirectivesAreInValidLocationsError.new(
+            "Directives can't be applied to #{ast_parent.class.name}s",
+            nodes: ast_directive,
+            target: ast_parent.class.name
+          ))
         end
       end
 
@@ -48,7 +52,12 @@ module GraphQL
         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] }
-          add_error("'@#{directive_defn.name}' can't be applied to #{location_name} (allowed: #{allowed_location_names.join(", ")})", directive_ast)
+          add_error(GraphQL::StaticValidation::DirectivesAreInValidLocationsError.new(
+            "'@#{directive_defn.graphql_name}' can't be applied to #{location_name} (allowed: #{allowed_location_names.join(", ")})",
+            nodes: directive_ast,
+            target: location_name,
+            name: directive_defn.name
+          ))
         end
       end
     end

data/lib/graphql/static_validation/rules/directives_are_in_valid_locations_error.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class DirectivesAreInValidLocationsError < StaticValidation::Error
+      attr_reader :target_name
+      attr_reader :name
+
+      def initialize(message, path: nil, nodes: [], target:, name: nil)
+        super(message, path: path, nodes: nodes)
+        @target_name = target
+        @name = name
+      end
+
+      # A hash representation of this Message
+      def to_h
+        extensions = {
+          "code" => code,
+          "targetName" => target_name
+        }.tap { |h| h["name"] = name unless name.nil? }
+
+        super.merge({
+          "extensions" => extensions
+        })
+      end
+
+      def code
+        "directiveCannotBeApplied"
+      end
+    end
+  end
+end

data/lib/graphql/static_validation/rules/fields_are_defined_on_type.rb

@@ -8,9 +8,18 @@ module GraphQL
 
         if field.nil?
           if parent_type.kind.union?
-            add_error("Selections can't be made directly on unions (see selections on #{parent_type.name})", parent)
+            add_error(GraphQL::StaticValidation::FieldsHaveAppropriateSelectionsError.new(
+              "Selections can't be made directly on unions (see selections on #{parent_type.name})",
+              nodes: parent,
+              node_name: parent_type.name
+            ))
           else
-            add_error("Field '#{node.name}' doesn't exist on type '#{parent_type.name}'", node)
+            add_error(GraphQL::StaticValidation::FieldsAreDefinedOnTypeError.new(
+              "Field '#{node.name}' doesn't exist on type '#{parent_type.name}'",
+              nodes: node,
+              field: node.name,
+              type: parent_type.name
+            ))
           end
         else
           super

data/lib/graphql/static_validation/rules/fields_are_defined_on_type_error.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class FieldsAreDefinedOnTypeError < StaticValidation::Error
+      attr_reader :type_name
+      attr_reader :field_name
+
+      def initialize(message, path: nil, nodes: [], type:, field:)
+        super(message, path: path, nodes: nodes)
+        @type_name = type
+        @field_name = field
+      end
+
+      # A hash representation of this Message
+      def to_h
+        extensions = {
+          "code" => code,
+          "typeName" => type_name,
+          "fieldName" => field_name
+        }
+
+        super.merge({
+          "extensions" => extensions
+        })
+      end
+
+      def code
+        "undefinedField"
+      end
+    end
+  end
+end

data/lib/graphql/static_validation/rules/fields_have_appropriate_selections.rb

@@ -4,7 +4,7 @@ module GraphQL
     # Scalars _can't_ have selections
     # Objects _must_ have selections
     module FieldsHaveAppropriateSelections
-      include GraphQL::StaticValidation::Message::MessageHelper
+      include GraphQL::StaticValidation::Error::ErrorHelper
 
       def on_field(node, parent)
         field_defn = field_definition
@@ -50,7 +50,19 @@ module GraphQL
           else
             raise("Unexpected node #{ast_node}")
           end
-          add_error(msg % { node_name: node_name }, ast_node)
+          extensions = {
+            "rule": "StaticValidation::FieldsHaveAppropriateSelections",
+            "name": node_name.to_s
+          }
+          unless resolved_type.nil?
+            extensions["type"] = resolved_type.to_s
+          end
+          add_error(GraphQL::StaticValidation::FieldsHaveAppropriateSelectionsError.new(
+            msg % { node_name: node_name },
+            nodes: ast_node,
+            node_name: node_name.to_s,
+            type: resolved_type.nil? ? nil : resolved_type.to_s
+          ))
           false
         else
           true

data/lib/graphql/static_validation/rules/fields_have_appropriate_selections_error.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class FieldsHaveAppropriateSelectionsError < StaticValidation::Error
+      attr_reader :type_name
+      attr_reader :node_name
+
+      def initialize(message, path: nil, nodes: [], node_name:, type: nil)
+        super(message, path: path, nodes: nodes)
+        @node_name = node_name
+        @type_name = type
+      end
+
+      # A hash representation of this Message
+      def to_h
+        extensions = {
+          "code" => code,
+          "nodeName" => node_name
+        }.tap { |h| h["typeName"] = type_name unless type_name.nil? }
+
+        super.merge({
+          "extensions" => extensions
+        })
+      end
+
+      def code
+        "selectionMismatch"
+      end
+    end
+  end
+end

data/lib/graphql/static_validation/rules/fields_will_merge.rb

@@ -193,13 +193,25 @@ module GraphQL
           if node1.name != node2.name
             errored_nodes = [node1.name, node2.name].sort.join(" or ")
             msg = "Field '#{response_key}' has a field conflict: #{errored_nodes}?"
-            context.errors << GraphQL::StaticValidation::Message.new(msg, nodes: [node1, node2])
+            context.errors << GraphQL::StaticValidation::FieldsWillMergeError.new(
+              msg,
+              nodes: [node1, node2],
+              path: [],
+              field_name: response_key,
+              conflicts: errored_nodes
+            )
           end
 
           args = possible_arguments(node1, node2)
           if args.size > 1
             msg = "Field '#{response_key}' has an argument conflict: #{args.map { |arg| GraphQL::Language.serialize(arg) }.join(" or ")}?"
-            context.errors << GraphQL::StaticValidation::Message.new(msg, nodes: [node1, node2])
+            context.errors << GraphQL::StaticValidation::FieldsWillMergeError.new(
+              msg,
+              nodes: [node1, node2],
+              path: [],
+              field_name: response_key,
+              conflicts: args.map { |arg| GraphQL::Language.serialize(arg) }.join(" or ")
+            )
           end
         end
 
@@ -285,13 +297,19 @@ module GraphQL
         end
       end
 
+      NO_SELECTIONS = [{}.freeze, [].freeze].freeze
+
       def fields_and_fragments_from_selection(node, owner_type:, parents:)
-        fields, fragment_spreads = find_fields_and_fragments(node.selections, owner_type: owner_type, parents: parents)
-        response_keys = fields.group_by { |f| f.node.alias || f.node.name }
-        [response_keys, fragment_spreads]
+        if node.selections.none?
+          NO_SELECTIONS
+        else
+          fields, fragment_spreads = find_fields_and_fragments(node.selections, owner_type: owner_type, parents: parents, fields: [], fragment_spreads: [])
+          response_keys = fields.group_by { |f| f.node.alias || f.node.name }
+          [response_keys, fragment_spreads]
+        end
       end
 
-      def find_fields_and_fragments(selections, owner_type:, parents:, fields: [], fragment_spreads: [])
+      def find_fields_and_fragments(selections, owner_type:, parents:, fields:, fragment_spreads:)
         selections.each do |node|
           case node
           when GraphQL::Language::Nodes::Field

data/lib/graphql/static_validation/rules/fields_will_merge_error.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class FieldsWillMergeError < StaticValidation::Error
+      attr_reader :field_name
+      attr_reader :conflicts
+
+      def initialize(message, path: nil, nodes: [], field_name:, conflicts:)
+        super(message, path: path, nodes: nodes)
+        @field_name = field_name
+        @conflicts = conflicts
+      end
+
+      # A hash representation of this Message
+      def to_h
+        extensions = {
+          "code" => code,
+          "fieldName" => field_name,
+          "conflicts" => conflicts
+        }
+
+        super.merge({
+          "extensions" => extensions
+        })
+      end
+
+      def code
+        "fieldConflict"
+      end
+    end
+  end
+end

data/lib/graphql/static_validation/rules/fragment_names_are_unique.rb

@@ -17,7 +17,11 @@ module GraphQL
         super
         @fragments_by_name.each do |name, fragments|
           if fragments.length > 1
-            add_error(%|Fragment name "#{name}" must be unique|, fragments)
+            add_error(GraphQL::StaticValidation::FragmentNamesAreUniqueError.new(
+              %|Fragment name "#{name}" must be unique|,
+              nodes: fragments,
+              name: name
+            ))
           end
         end
       end

data/lib/graphql/static_validation/rules/fragment_names_are_unique_error.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class FragmentNamesAreUniqueError < StaticValidation::Error
+      attr_reader :fragment_name
+
+      def initialize(message, path: nil, nodes: [], name:)
+        super(message, path: path, nodes: nodes)
+        @fragment_name = name
+      end
+
+      # A hash representation of this Message
+      def to_h
+        extensions = {
+          "code" => code,
+          "fragmentName" => fragment_name
+        }
+
+        super.merge({
+          "extensions" => extensions
+        })
+      end
+
+      def code
+        "fragmentNotUnique"
+      end
+    end
+  end
+end

data/lib/graphql/static_validation/rules/fragment_spreads_are_possible.rb

@@ -49,7 +49,14 @@ module GraphQL
 
         if child_types.none? { |c| parent_types.include?(c) }
           name = node.respond_to?(:name) ? " #{node.name}" : ""
-          add_error("Fragment#{name} on #{child_type.name} can't be spread inside #{parent_type.name}", node, path: path)
+          add_error(GraphQL::StaticValidation::FragmentSpreadsArePossibleError.new(
+            "Fragment#{name} on #{child_type.name} can't be spread inside #{parent_type.name}",
+            nodes: node,
+            path: path,
+            fragment_name: name.empty? ? "unknown" : name,
+            type: child_type.name,
+            parent: parent_type.name
+          ))
         end
       end
 

data/lib/graphql/static_validation/rules/fragment_spreads_are_possible_error.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class FragmentSpreadsArePossibleError < StaticValidation::Error
+      attr_reader :type_name
+      attr_reader :fragment_name
+      attr_reader :parent_name
+
+      def initialize(message, path: nil, nodes: [], type:, fragment_name:, parent:)
+        super(message, path: path, nodes: nodes)
+        @type_name = type
+        @fragment_name = fragment_name
+        @parent_name = parent
+      end
+
+      # A hash representation of this Message
+      def to_h
+        extensions = {
+          "code" => code,
+          "typeName" => type_name,
+          "fragmentName" => fragment_name,
+          "parentName" => parent_name
+        }
+
+        super.merge({
+          "extensions" => extensions
+        })
+      end
+
+      def code
+        "cannotSpreadFragment"
+      end
+    end
+  end
+end

data/lib/graphql/static_validation/rules/fragment_types_exist.rb

@@ -23,7 +23,11 @@ module GraphQL
           type_name = fragment_node.type.name
           type = context.warden.get_type(type_name)
           if type.nil?
-            add_error("No such type #{type_name}, so it can't be a fragment condition", fragment_node)
+            add_error(GraphQL::StaticValidation::FragmentTypesExistError.new(
+              "No such type #{type_name}, so it can't be a fragment condition",
+              nodes: fragment_node,
+              type: type_name
+            ))
             false
           else
             true