graphql 1.8.7 → 1.9.0

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

@@ -1,24 +1,21 @@
 # frozen_string_literal: true
 module GraphQL
   module StaticValidation
-    class DirectivesAreDefined
-      include GraphQL::StaticValidation::Message::MessageHelper
-
-      def validate(context)
-        directive_names = context.schema.directives.keys
-        context.visitor[GraphQL::Language::Nodes::Directive] << ->(node, parent) {
-          validate_directive(node, directive_names, context)
-        }
+    module DirectivesAreDefined
+      def initialize(*)
+        super
+        @directive_names = context.schema.directives.keys
       end
 
-      private
-
-      def validate_directive(ast_directive, directive_names, context)
-        if !directive_names.include?(ast_directive.name)
-          context.errors << message("Directive @#{ast_directive.name} is not defined", ast_directive, context: context)
-          GraphQL::Language::Visitor::SKIP
+      def on_directive(node, parent)
+        if !@directive_names.include?(node.name)
+          add_error(GraphQL::StaticValidation::DirectivesAreDefinedError.new(
+            "Directive @#{node.name} is not defined",
+            nodes: node,
+            directive: node.name
+          ))
         else
-          nil
+          super
         end
       end
     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

@@ -1,16 +1,12 @@
 # frozen_string_literal: true
 module GraphQL
   module StaticValidation
-    class DirectivesAreInValidLocations
-      include GraphQL::StaticValidation::Message::MessageHelper
+    module DirectivesAreInValidLocations
       include GraphQL::Language
 
-      def validate(context)
-        directives = context.schema.directives
-
-        context.visitor[Nodes::Directive] << ->(node, parent) {
-          validate_location(node, parent, directives, context)
-        }
+      def on_directive(node, parent)
+        validate_location(node, parent, context.schema.directives)
+        super
       end
 
       private
@@ -34,25 +30,34 @@ module GraphQL
 
       SIMPLE_LOCATION_NODES = SIMPLE_LOCATIONS.keys
 
-      def validate_location(ast_directive, ast_parent, directives, context)
+      def validate_location(ast_directive, ast_parent, directives)
         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, context)
+          assert_includes_location(directive_defn, ast_directive, required_location)
         when *SIMPLE_LOCATION_NODES
           required_location = SIMPLE_LOCATIONS[ast_parent.class]
-          assert_includes_location(directive_defn, ast_directive, required_location, context)
+          assert_includes_location(directive_defn, ast_directive, required_location)
         else
-          context.errors << message("Directives can't be applied to #{ast_parent.class.name}s", ast_directive, context: context)
+          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
 
-      def assert_includes_location(directive_defn, directive_ast, required_location, context)
+      def assert_includes_location(directive_defn, directive_ast, required_location)
         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] }
-          context.errors << message("'@#{directive_defn.name}' can't be applied to #{location_name} (allowed: #{allowed_location_names.join(", ")})", directive_ast, context: context)
+          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

@@ -1,30 +1,28 @@
 # frozen_string_literal: true
 module GraphQL
   module StaticValidation
-    class FieldsAreDefinedOnType
-      include GraphQL::StaticValidation::Message::MessageHelper
-
-      def validate(context)
-        visitor = context.visitor
-        visitor[GraphQL::Language::Nodes::Field] << ->(node, parent) {
-          parent_type = context.object_types[-2]
-          parent_type = parent_type.unwrap
-          validate_field(context, node, parent_type, parent)
-        }
-      end
-
-      private
-
-      def validate_field(context, ast_field, parent_type, parent)
-        field = context.warden.get_field(parent_type, ast_field.name)
+    module FieldsAreDefinedOnType
+      def on_field(node, parent)
+        parent_type = @object_types[-2]
+        field = context.warden.get_field(parent_type, node.name)
 
         if field.nil?
           if parent_type.kind.union?
-            context.errors << message("Selections can't be made directly on unions (see selections on #{parent_type.name})", parent, context: context)
+            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
-            context.errors << message("Field '#{ast_field.name}' doesn't exist on type '#{parent_type.name}'", ast_field, context: context)
+            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
-          return GraphQL::Language::Visitor::SKIP
+        else
+          super
         end
       end
     end

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

@@ -3,24 +3,26 @@ module GraphQL
   module StaticValidation
     # Scalars _can't_ have selections
     # Objects _must_ have selections
-    class FieldsHaveAppropriateSelections
-      include GraphQL::StaticValidation::Message::MessageHelper
+    module FieldsHaveAppropriateSelections
+      include GraphQL::StaticValidation::Error::ErrorHelper
 
-      def validate(context)
-        context.visitor[GraphQL::Language::Nodes::Field] << ->(node, parent)  {
-          field_defn = context.field_definition
-          validate_field_selections(node, field_defn.type.unwrap, context)
-        }
+      def on_field(node, parent)
+        field_defn = field_definition
+        if validate_field_selections(node, field_defn.type.unwrap)
+          super
+        end
+      end
 
-        context.visitor[GraphQL::Language::Nodes::OperationDefinition] << ->(node, parent)  {
-          validate_field_selections(node, context.type_definition, context)
-        }
+      def on_operation_definition(node, _parent)
+        if validate_field_selections(node, type_definition)
+          super
+        end
       end
 
       private
 
 
-      def validate_field_selections(ast_node, resolved_type, context)
+      def validate_field_selections(ast_node, resolved_type)
         msg = if resolved_type.nil?
           nil
         elsif resolved_type.kind.scalar? && ast_node.selections.any?
@@ -29,7 +31,7 @@ module GraphQL
           else
             "Selections can't be made on scalars (%{node_name} returns #{resolved_type.name} but has selections [#{ast_node.selections.map(&:name).join(", ")}])"
           end
-        elsif resolved_type.kind.fields? && ast_node.selections.none?
+        elsif resolved_type.kind.fields? && ast_node.selections.empty?
           "Field must have selections (%{node_name} returns #{resolved_type.name} but has no selections. Did you mean '#{ast_node.name} { ... }'?)"
         else
           nil
@@ -48,8 +50,22 @@ module GraphQL
           else
             raise("Unexpected node #{ast_node}")
           end
-          context.errors << message(msg % { node_name: node_name }, ast_node, context: context)
-          GraphQL::Language::Visitor::SKIP
+          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
         end
       end
     end

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