graphql 1.8.7 → 1.9.0

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

@@ -1,29 +1,37 @@
 # frozen_string_literal: true
 module GraphQL
   module StaticValidation
-    class FragmentTypesExist
-      include GraphQL::StaticValidation::Message::MessageHelper
-
-      FRAGMENTS_ON_TYPES = [
-        GraphQL::Language::Nodes::FragmentDefinition,
-        GraphQL::Language::Nodes::InlineFragment,
-      ]
+    module FragmentTypesExist
+      def on_fragment_definition(node, _parent)
+        if validate_type_exists(node)
+          super
+        end
+      end
 
-      def validate(context)
-        FRAGMENTS_ON_TYPES.each do |node_class|
-          context.visitor[node_class] << ->(node, parent) { validate_type_exists(node, context) }
+      def on_inline_fragment(node, _parent)
+        if validate_type_exists(node)
+          super
         end
       end
 
       private
 
-      def validate_type_exists(node, context)
-        return unless node.type
-        type_name = node.type.name
-        type = context.warden.get_type(type_name)
-        if type.nil?
-          context.errors << message("No such type #{type_name}, so it can't be a fragment condition", node, context: context)
-          GraphQL::Language::Visitor::SKIP
+      def validate_type_exists(fragment_node)
+        if !fragment_node.type
+          true
+        else
+          type_name = fragment_node.type.name
+          type = context.warden.get_type(type_name)
+          if type.nil?
+            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
+          end
         end
       end
     end

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

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

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

@@ -1,16 +1,18 @@
 # frozen_string_literal: true
 module GraphQL
   module StaticValidation
-    class FragmentsAreFinite
-      include GraphQL::StaticValidation::Message::MessageHelper
-
-      def validate(context)
-        context.visitor[GraphQL::Language::Nodes::Document].leave << ->(_n, _p) do
-          dependency_map = context.dependencies
-          dependency_map.cyclical_definitions.each do |defn|
-            if defn.node.is_a?(GraphQL::Language::Nodes::FragmentDefinition)
-              context.errors << message("Fragment #{defn.name} contains an infinite loop", defn.node, path: defn.path)
-            end
+    module FragmentsAreFinite
+      def on_document(_n, _p)
+        super
+        dependency_map = context.dependencies
+        dependency_map.cyclical_definitions.each do |defn|
+          if defn.node.is_a?(GraphQL::Language::Nodes::FragmentDefinition)
+            context.errors << GraphQL::StaticValidation::FragmentsAreFiniteError.new(
+              "Fragment #{defn.name} contains an infinite loop",
+              nodes: defn.node,
+              path: defn.path,
+              name: defn.name
+            )
           end
         end
       end

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

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class FragmentsAreFiniteError < 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
+        "infiniteLoop"
+      end
+    end
+  end
+end

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

@@ -1,19 +1,15 @@
 # frozen_string_literal: true
 module GraphQL
   module StaticValidation
-    class FragmentsAreNamed
-      include GraphQL::StaticValidation::Message::MessageHelper
-
-      def validate(context)
-        context.visitor[GraphQL::Language::Nodes::FragmentDefinition] << ->(node, parent) { validate_name_exists(node, context) }
-      end
-
-      private
-
-      def validate_name_exists(node, context)
+    module FragmentsAreNamed
+      def on_fragment_definition(node, _parent)
         if node.name.nil?
-          context.errors << message("Fragment definition has no name", node, context: context)
+          add_error(GraphQL::StaticValidation::FragmentsAreNamedError.new(
+            "Fragment definition has no name",
+            nodes: node
+          ))
         end
+        super
       end
     end
   end

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

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

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

@@ -1,34 +1,34 @@
 # frozen_string_literal: true
 module GraphQL
   module StaticValidation
-    class FragmentsAreOnCompositeTypes
-      include GraphQL::StaticValidation::Message::MessageHelper
-
-      HAS_TYPE_CONDITION = [
-        GraphQL::Language::Nodes::FragmentDefinition,
-        GraphQL::Language::Nodes::InlineFragment,
-      ]
+    module FragmentsAreOnCompositeTypes
+      def on_fragment_definition(node, parent)
+        validate_type_is_composite(node) && super
+      end
 
-      def validate(context)
-        HAS_TYPE_CONDITION.each do |node_class|
-          context.visitor[node_class] << ->(node, parent) {
-            validate_type_is_composite(node, context)
-          }
-        end
+      def on_inline_fragment(node, parent)
+        validate_type_is_composite(node) && super
       end
 
       private
 
-      def validate_type_is_composite(node, context)
+      def validate_type_is_composite(node)
         node_type = node.type
         if node_type.nil?
           # Inline fragment on the same type
+          true
         else
           type_name = node_type.to_query_string
           type_def = context.warden.get_type(type_name)
           if type_def.nil? || !type_def.kind.composite?
-            context.errors <<  message("Invalid fragment on type #{type_name} (must be Union, Interface or Object)", node, context: context)
-            GraphQL::Language::Visitor::SKIP
+            add_error(GraphQL::StaticValidation::FragmentsAreOnCompositeTypesError.new(
+              "Invalid fragment on type #{type_name} (must be Union, Interface or Object)",
+              nodes: node,
+              type: type_name
+            ))
+            false
+          else
+            true
           end
         end
       end

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

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

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

@@ -1,22 +1,29 @@
 # frozen_string_literal: true
 module GraphQL
   module StaticValidation
-    class FragmentsAreUsed
-      include GraphQL::StaticValidation::Message::MessageHelper
-
-      def validate(context)
-        context.visitor[GraphQL::Language::Nodes::Document].leave << ->(_n, _p) do
-          dependency_map = context.dependencies
-          dependency_map.unmet_dependencies.each do |op_defn, spreads|
-            spreads.each do |fragment_spread|
-              context.errors << message("Fragment #{fragment_spread.name} was used, but not defined", fragment_spread.node, path: fragment_spread.path)
-            end
+    module FragmentsAreUsed
+      def on_document(node, parent)
+        super
+        dependency_map = context.dependencies
+        dependency_map.unmet_dependencies.each do |op_defn, spreads|
+          spreads.each do |fragment_spread|
+            add_error(GraphQL::StaticValidation::FragmentsAreUsedError.new(
+              "Fragment #{fragment_spread.name} was used, but not defined",
+              nodes: fragment_spread.node,
+              path: fragment_spread.path,
+              fragment: fragment_spread.name
+            ))
           end
+        end
 
-          dependency_map.unused_dependencies.each do |fragment|
-            if !fragment.name.nil?
-              context.errors << message("Fragment #{fragment.name} was defined, but not used", fragment.node, path: fragment.path)
-            end
+        dependency_map.unused_dependencies.each do |fragment|
+          if fragment && !fragment.name.nil?
+            add_error(GraphQL::StaticValidation::FragmentsAreUsedError.new(
+              "Fragment #{fragment.name} was defined, but not used",
+              nodes: fragment.node,
+              path: fragment.path,
+              fragment: fragment.name
+            ))
           end
         end
       end

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

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

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

@@ -1,20 +1,16 @@
 # frozen_string_literal: true
 module GraphQL
   module StaticValidation
-    class MutationRootExists
-      include GraphQL::StaticValidation::Message::MessageHelper
-
-      def validate(context)
-        return if context.warden.root_type_for_operation("mutation")
-
-        visitor = context.visitor
-
-        visitor[GraphQL::Language::Nodes::OperationDefinition].enter << ->(ast_node, prev_ast_node) {
-          if ast_node.operation_type == 'mutation'
-            context.errors << message('Schema is not configured for mutations', ast_node, context: context)
-            return GraphQL::Language::Visitor::SKIP
-          end
-        }
+    module MutationRootExists
+      def on_operation_definition(node, _parent)
+        if node.operation_type == 'mutation' && context.warden.root_type_for_operation("mutation").nil?
+          add_error(GraphQL::StaticValidation::MutationRootExistsError.new(
+            'Schema is not configured for mutations',
+            nodes: node
+          ))
+        else
+          super
+        end
       end
     end
   end

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

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

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

@@ -1,40 +1,40 @@
 # frozen_string_literal: true
 module GraphQL
   module StaticValidation
-    class NoDefinitionsArePresent
-      include GraphQL::StaticValidation::Message::MessageHelper
+    module NoDefinitionsArePresent
+      include GraphQL::StaticValidation::Error::ErrorHelper
 
-      def validate(context)
-        schema_definition_nodes = []
-        register_node = ->(node, _p) {
-          schema_definition_nodes << node
-          GraphQL::Language::Visitor::SKIP
-        }
-
-        visitor = context.visitor
+      def initialize(*)
+        super
+        @schema_definition_nodes = []
+      end
 
-        visitor[GraphQL::Language::Nodes::DirectiveDefinition] << register_node
-        visitor[GraphQL::Language::Nodes::SchemaDefinition] << register_node
-        visitor[GraphQL::Language::Nodes::ScalarTypeDefinition] << register_node
-        visitor[GraphQL::Language::Nodes::ObjectTypeDefinition] << register_node
-        visitor[GraphQL::Language::Nodes::InputObjectTypeDefinition] << register_node
-        visitor[GraphQL::Language::Nodes::InterfaceTypeDefinition] << register_node
-        visitor[GraphQL::Language::Nodes::UnionTypeDefinition] << register_node
-        visitor[GraphQL::Language::Nodes::EnumTypeDefinition] << register_node
+      def on_invalid_node(node, parent)
+        @schema_definition_nodes << node
+        nil
+      end
 
-        visitor[GraphQL::Language::Nodes::SchemaExtension] << register_node
-        visitor[GraphQL::Language::Nodes::ScalarTypeExtension] << register_node
-        visitor[GraphQL::Language::Nodes::ObjectTypeExtension] << register_node
-        visitor[GraphQL::Language::Nodes::InputObjectTypeExtension] << register_node
-        visitor[GraphQL::Language::Nodes::InterfaceTypeExtension] << register_node
-        visitor[GraphQL::Language::Nodes::UnionTypeExtension] << register_node
-        visitor[GraphQL::Language::Nodes::EnumTypeExtension] << register_node
+      alias :on_directive_definition :on_invalid_node
+      alias :on_schema_definition :on_invalid_node
+      alias :on_scalar_type_definition :on_invalid_node
+      alias :on_object_type_definition :on_invalid_node
+      alias :on_input_object_type_definition :on_invalid_node
+      alias :on_interface_type_definition :on_invalid_node
+      alias :on_union_type_definition :on_invalid_node
+      alias :on_enum_type_definition :on_invalid_node
+      alias :on_schema_extension :on_invalid_node
+      alias :on_scalar_type_extension :on_invalid_node
+      alias :on_object_type_extension :on_invalid_node
+      alias :on_input_object_type_extension :on_invalid_node
+      alias :on_interface_type_extension :on_invalid_node
+      alias :on_union_type_extension :on_invalid_node
+      alias :on_enum_type_extension :on_invalid_node
 
-        visitor[GraphQL::Language::Nodes::Document].leave << ->(node, _p) {
-          if schema_definition_nodes.any?
-            context.errors << message(%|Query cannot contain schema definitions|, schema_definition_nodes, context: context)
-          end
-        }
+      def on_document(node, parent)
+        super
+        if @schema_definition_nodes.any?
+          add_error(GraphQL::StaticValidation::NoDefinitionsArePresentError.new(%|Query cannot contain schema definitions|, nodes: @schema_definition_nodes))
+        end
       end
     end
   end

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

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

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

@@ -1,27 +1,35 @@
 # frozen_string_literal: true
 module GraphQL
   module StaticValidation
-    class OperationNamesAreValid
-      include GraphQL::StaticValidation::Message::MessageHelper
-
-      def validate(context)
-        op_names = Hash.new { |h, k| h[k] = [] }
+    module OperationNamesAreValid
+      def initialize(*)
+        super
+        @operation_names = Hash.new { |h, k| h[k] = [] }
+      end
 
-        context.visitor[GraphQL::Language::Nodes::OperationDefinition].enter << ->(node, _parent) {
-          op_names[node.name] << node
-        }
+      def on_operation_definition(node, parent)
+        @operation_names[node.name] << node
+        super
+      end
 
-        context.visitor[GraphQL::Language::Nodes::Document].leave << ->(node, _parent) {
-          op_count = op_names.values.inject(0) { |m, v| m + v.size }
+      def on_document(node, parent)
+        super
+        op_count = @operation_names.values.inject(0) { |m, v| m + v.size }
 
-          op_names.each do |name, nodes|
-            if name.nil? && op_count > 1
-              context.errors << message(%|Operation name is required when multiple operations are present|, nodes, context: context)
-            elsif nodes.length > 1
-              context.errors << message(%|Operation name "#{name}" must be unique|, nodes, context: context)
-            end
+        @operation_names.each do |name, nodes|
+          if name.nil? && op_count > 1
+            add_error(GraphQL::StaticValidation::OperationNamesAreValidError.new(
+              %|Operation name is required when multiple operations are present|,
+              nodes: nodes
+            ))
+          elsif nodes.length > 1
+            add_error(GraphQL::StaticValidation::OperationNamesAreValidError.new(
+              %|Operation name "#{name}" must be unique|,
+              nodes: nodes,
+              name: name
+            ))
           end
-        }
+        end
       end
     end
   end

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

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

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

@@ -1,28 +1,21 @@
 # frozen_string_literal: true
 module GraphQL
   module StaticValidation
-    class RequiredArgumentsArePresent
-      include GraphQL::StaticValidation::Message::MessageHelper
-
-      def validate(context)
-        v = context.visitor
-        v[GraphQL::Language::Nodes::Field] << ->(node, parent) { validate_field(node, context) }
-        v[GraphQL::Language::Nodes::Directive] << ->(node, parent) { validate_directive(node, context) }
+    module RequiredArgumentsArePresent
+      def on_field(node, _parent)
+        assert_required_args(node, field_definition)
+        super
       end
 
-      private
-
-      def validate_directive(ast_directive, context)
-        directive_defn = context.schema.directives[ast_directive.name]
-        assert_required_args(ast_directive, directive_defn, context)
+      def on_directive(node, _parent)
+        directive_defn = context.schema.directives[node.name]
+        assert_required_args(node, directive_defn)
+        super
       end
 
-      def validate_field(ast_field, context)
-        defn = context.field_definition
-        assert_required_args(ast_field, defn, context)
-      end
+      private
 
-      def assert_required_args(ast_node, defn, context)
+      def assert_required_args(ast_node, defn)
         present_argument_names = ast_node.arguments.map(&:name)
         required_argument_names = defn.arguments.values
           .select { |a| a.type.kind.non_null? }
@@ -30,7 +23,13 @@ module GraphQL
 
         missing_names = required_argument_names - present_argument_names
         if missing_names.any?
-          context.errors << message("#{ast_node.class.name.split("::").last} '#{ast_node.name}' is missing required arguments: #{missing_names.join(", ")}", ast_node, context: context)
+          add_error(GraphQL::StaticValidation::RequiredArgumentsArePresentError.new(
+            "#{ast_node.class.name.split("::").last} '#{ast_node.name}' is missing required arguments: #{missing_names.join(", ")}",
+            nodes: ast_node,
+            class_name: ast_node.class.name.split("::").last,
+            name: ast_node.name,
+            arguments: "#{missing_names.join(", ")}"
+          ))
         end
       end
     end