graphql 1.8.7 → 1.9.0

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

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

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

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    module RequiredInputObjectAttributesArePresent
+      def on_input_object(node, parent)
+        if parent.is_a? GraphQL::Language::Nodes::Argument
+          validate_input_object(node, context, parent)
+        end
+        super
+      end
+
+      private
+
+      def get_parent_type(context, parent)
+        defn = context.field_definition
+        parent_type = context.warden.arguments(defn)
+          .find{|f| f.name == parent_name(parent, defn) }
+        parent_type ? parent_type.type.unwrap : nil
+      end
+
+      def validate_input_object(ast_node, context, parent)
+        parent_type = get_parent_type(context, parent)
+        return unless parent_type && parent_type.kind.input_object?
+
+        required_fields = parent_type.arguments
+          .select{|k,v| v.type.kind.non_null?}
+          .keys
+
+        present_fields = ast_node.arguments.map(&:name)
+        missing_fields = required_fields - present_fields
+
+        missing_fields.each do |missing_field|
+          path = [*context.path, missing_field]
+          missing_field_type = parent_type.arguments[missing_field].type
+          add_error(RequiredInputObjectAttributesArePresentError.new(
+            "Argument '#{missing_field}' on InputObject '#{parent_type}' is required. Expected type #{missing_field_type}",
+            argument_name: missing_field,
+            argument_type: missing_field_type.to_s,
+            input_object_type: parent_type.to_s,
+            path: path,
+            nodes: ast_node,
+          ))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class RequiredInputObjectAttributesArePresentError < StaticValidation::Error
+      attr_reader :argument_type
+      attr_reader :argument_name
+      attr_reader :input_object_type
+
+      def initialize(message, path:, nodes:, argument_type:, argument_name:, input_object_type:)
+        super(message, path: path, nodes: nodes)
+        @argument_type = argument_type
+        @argument_name = argument_name
+        @input_object_type = input_object_type
+      end
+
+      # A hash representation of this Message
+      def to_h
+        extensions = {
+          "code" => code,
+          "argumentName" => argument_name,
+          "argumentType" => argument_type,
+          "inputObjectType" => input_object_type,
+        }
+
+        super.merge({
+          "extensions" => extensions
+        })
+      end
+
+      def code
+        "missingRequiredInputObjectAttribute"
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class SubscriptionRootExistsError < 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
+        "missingSubscriptionConfiguration"
+      end
+    end
+  end
+end

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

@@ -1,34 +1,45 @@
 # frozen_string_literal: true
 module GraphQL
   module StaticValidation
-    class UniqueDirectivesPerLocation
-      include GraphQL::StaticValidation::Message::MessageHelper
+    module UniqueDirectivesPerLocation
+      DIRECTIVE_NODE_HOOKS = [
+        :on_fragment_definition,
+        :on_fragment_spread,
+        :on_inline_fragment,
+        :on_operation_definition,
+        :on_scalar_type_definition,
+        :on_object_type_definition,
+        :on_input_value_definition,
+        :on_field_definition,
+        :on_interface_type_definition,
+        :on_union_type_definition,
+        :on_enum_type_definition,
+        :on_enum_value_definition,
+        :on_input_object_type_definition,
+        :on_field,
+      ]
 
-      NODES_WITH_DIRECTIVES = GraphQL::Language::Nodes.constants
-        .map{|c| GraphQL::Language::Nodes.const_get(c)}
-        .select{|c| c.is_a?(Class) && c.instance_methods.include?(:directives)}
-
-      def validate(context)
-        NODES_WITH_DIRECTIVES.each do |node_class|
-          context.visitor[node_class] << ->(node, _) {
-            validate_directives(node, context) unless node.directives.empty?
-          }
+      DIRECTIVE_NODE_HOOKS.each do |method_name|
+        define_method(method_name) do |node, parent|
+          if node.directives.any?
+            validate_directive_location(node)
+          end
+          super(node, parent)
         end
       end
 
       private
 
-      def validate_directives(node, context)
+      def validate_directive_location(node)
         used_directives = {}
-
         node.directives.each do |ast_directive|
           directive_name = ast_directive.name
           if used_directives[directive_name]
-            context.errors << message(
+            add_error(GraphQL::StaticValidation::UniqueDirectivesPerLocationError.new(
               "The directive \"#{directive_name}\" can only be used once at this location.",
-              [used_directives[directive_name], ast_directive],
-              context: context
-            )
+              nodes: [used_directives[directive_name], ast_directive],
+              directive: directive_name,
+            ))
           else
             used_directives[directive_name] = ast_directive
           end

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

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

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

@@ -1,38 +1,46 @@
 # frozen_string_literal: true
 module GraphQL
   module StaticValidation
-    class VariableDefaultValuesAreCorrectlyTyped
-      include GraphQL::StaticValidation::Message::MessageHelper
-
-      def validate(context)
-        context.visitor[GraphQL::Language::Nodes::VariableDefinition] << ->(node, parent) {
-          if !node.default_value.nil?
-            validate_default_value(node, context)
-          end
-        }
-      end
-
-      def validate_default_value(node, context)
-        value = node.default_value
-        if node.type.is_a?(GraphQL::Language::Nodes::NonNullType)
-          context.errors << message("Non-null variable $#{node.name} can't have a default value", node, context: context)
-        else
-          type = context.schema.type_from_ast(node.type)
-          if type.nil?
-            # This is handled by another validator
+    module VariableDefaultValuesAreCorrectlyTyped
+      def on_variable_definition(node, parent)
+        if !node.default_value.nil?
+          value = node.default_value
+          if node.type.is_a?(GraphQL::Language::Nodes::NonNullType)
+            add_error(GraphQL::StaticValidation::VariableDefaultValuesAreCorrectlyTypedError.new(
+              "Non-null variable $#{node.name} can't have a default value",
+              nodes: node,
+              name: node.name,
+              error_type: VariableDefaultValuesAreCorrectlyTypedError::VIOLATIONS[:INVALID_ON_NON_NULL]
+            ))
           else
-            begin
-              valid = context.valid_literal?(value, type)
-            rescue GraphQL::CoercionError => err
-              error_message = err.message
-            end
+            type = context.schema.type_from_ast(node.type)
+            if type.nil?
+              # This is handled by another validator
+            else
+              begin
+                valid = context.valid_literal?(value, type)
+              rescue GraphQL::CoercionError => err
+                error_message = err.message
+              rescue GraphQL::LiteralValidationError
+                # noop, we just want to stop any LiteralValidationError from propagating
+              end
 
-            if !valid
-              error_message ||= "Default value for $#{node.name} doesn't match type #{type}"
-              context.errors << message(error_message, node, context: context)
+              if !valid
+                error_message ||= "Default value for $#{node.name} doesn't match type #{type}"
+                VariableDefaultValuesAreCorrectlyTypedError
+                add_error(GraphQL::StaticValidation::VariableDefaultValuesAreCorrectlyTypedError.new(
+                  error_message,
+                  nodes: node,
+                  name: node.name,
+                  type: type.to_s,
+                  error_type: VariableDefaultValuesAreCorrectlyTypedError::VIOLATIONS[:INVALID_TYPE]
+                ))
+              end
             end
           end
         end
+
+        super
       end
     end
   end

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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class VariableDefaultValuesAreCorrectlyTypedError < StaticValidation::Error
+      attr_reader :variable_name
+      attr_reader :type_name
+      attr_reader :violation
+
+      VIOLATIONS = {
+        :INVALID_TYPE         => "defaultValueInvalidType",
+        :INVALID_ON_NON_NULL  => "defaultValueInvalidOnNonNullVariable",
+      }
+
+      def initialize(message, path: nil, nodes: [], name:, type: nil, error_type:)
+        super(message, path: path, nodes: nodes)
+        @variable_name = name
+        @type_name = type
+        raise("Unexpected error type: #{error_type}") if !VIOLATIONS.values.include?(error_type)
+        @violation = error_type
+      end
+
+      # A hash representation of this Message
+      def to_h
+        extensions = {
+          "code" => code,
+          "variableName" => variable_name
+        }.tap { |h| h["typeName"] = type_name unless type_name.nil? }
+
+        super.merge({
+          "extensions" => extensions
+        })
+      end
+
+      def code
+        @violation
+      end
+    end
+  end
+end

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

@@ -1,22 +1,23 @@
 # frozen_string_literal: true
 module GraphQL
   module StaticValidation
-    class VariableNamesAreUnique
-      include GraphQL::StaticValidation::Message::MessageHelper
-
-      def validate(context)
-        context.visitor[GraphQL::Language::Nodes::OperationDefinition] << ->(node, parent) {
-          var_defns = node.variables
-          if var_defns.any?
-            vars_by_name = Hash.new { |h, k| h[k] = [] }
-            var_defns.each { |v| vars_by_name[v.name] << v }
-            vars_by_name.each do |name, defns|
-              if defns.size > 1
-                context.errors << message("There can only be one variable named \"#{name}\"", defns, context: context)
-              end
+    module VariableNamesAreUnique
+      def on_operation_definition(node, parent)
+        var_defns = node.variables
+        if var_defns.any?
+          vars_by_name = Hash.new { |h, k| h[k] = [] }
+          var_defns.each { |v| vars_by_name[v.name] << v }
+          vars_by_name.each do |name, defns|
+            if defns.size > 1
+              add_error(GraphQL::StaticValidation::VariableNamesAreUniqueError.new(
+                "There can only be one variable named \"#{name}\"",
+                nodes: defns,
+                name: name
+              ))
             end
           end
-        }
+        end
+        super
       end
     end
   end

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

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

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

@@ -1,53 +1,57 @@
 # frozen_string_literal: true
 module GraphQL
   module StaticValidation
-    class VariableUsagesAreAllowed
-      include GraphQL::StaticValidation::Message::MessageHelper
-
-      def validate(context)
+    module VariableUsagesAreAllowed
+      def initialize(*)
+        super
         # holds { name => ast_node } pairs
-        declared_variables = {}
-        context.visitor[GraphQL::Language::Nodes::OperationDefinition] << ->(node, parent) {
-          declared_variables = node.variables.each_with_object({}) { |var, memo| memo[var.name] = var }
-        }
-
-        context.visitor[GraphQL::Language::Nodes::Argument] << ->(node, parent) {
-          node_values = if node.value.is_a?(Array)
-            node.value
-          else
-            [node.value]
-          end
-          node_values = node_values.select { |value| value.is_a? GraphQL::Language::Nodes::VariableIdentifier }
+        @declared_variables = {}
+      end
 
-          return if node_values.none?
+      def on_operation_definition(node, parent)
+        @declared_variables = node.variables.each_with_object({}) { |var, memo| memo[var.name] = var }
+        super
+      end
 
-          arguments = nil
-          case parent
+      def on_argument(node, parent)
+        node_values = if node.value.is_a?(Array)
+          node.value
+        else
+          [node.value]
+        end
+        node_values = node_values.select { |value| value.is_a? GraphQL::Language::Nodes::VariableIdentifier }
+
+        if node_values.any?
+          arguments = case parent
           when GraphQL::Language::Nodes::Field
-            arguments = context.field_definition.arguments
+            context.field_definition.arguments
           when GraphQL::Language::Nodes::Directive
-            arguments = context.directive_definition.arguments
+            context.directive_definition.arguments
           when GraphQL::Language::Nodes::InputObject
             arg_type = context.argument_definition.type.unwrap
             if arg_type.is_a?(GraphQL::InputObjectType)
               arguments = arg_type.input_fields
+            else
+              # This is some kind of error
+              nil
             end
           else
             raise("Unexpected argument parent: #{parent}")
           end
 
           node_values.each do |node_value|
-            var_defn_ast = declared_variables[node_value.name]
+            var_defn_ast = @declared_variables[node_value.name]
             # Might be undefined :(
             # VariablesAreUsedAndDefined can't finalize its search until the end of the document.
-            var_defn_ast && arguments && validate_usage(arguments, node, var_defn_ast, context)
+            var_defn_ast && arguments && validate_usage(arguments, node, var_defn_ast)
           end
-        }
+        end
+        super
       end
 
       private
 
-      def validate_usage(arguments, arg_node, ast_var, context)
+      def validate_usage(arguments, arg_node, ast_var)
         var_type = context.schema.type_from_ast(ast_var.type)
         if var_type.nil?
           return
@@ -71,16 +75,23 @@ module GraphQL
         var_type = wrap_var_type_with_depth_of_arg(var_type, arg_node)
 
         if var_inner_type != arg_inner_type
-          context.errors << create_error("Type mismatch", var_type, ast_var, arg_defn, arg_node, context)
+          create_error("Type mismatch", var_type, ast_var, arg_defn, arg_node)
         elsif list_dimension(var_type) != list_dimension(arg_defn_type)
-          context.errors << create_error("List dimension mismatch", var_type, ast_var, arg_defn, arg_node, context)
+          create_error("List dimension mismatch", var_type, ast_var, arg_defn, arg_node)
         elsif !non_null_levels_match(arg_defn_type, var_type)
-          context.errors << create_error("Nullability mismatch", var_type, ast_var, arg_defn, arg_node, context)
+          create_error("Nullability mismatch", var_type, ast_var, arg_defn, arg_node)
         end
       end
 
-      def create_error(error_message, var_type, ast_var, arg_defn, arg_node, context)
-        message("#{error_message} on variable $#{ast_var.name} and argument #{arg_node.name} (#{var_type.to_s} / #{arg_defn.type.to_s})", arg_node, context: context)
+      def create_error(error_message, var_type, ast_var, arg_defn, arg_node)
+        add_error(GraphQL::StaticValidation::VariableUsagesAreAllowedError.new(
+          "#{error_message} on variable $#{ast_var.name} and argument #{arg_node.name} (#{var_type.to_s} / #{arg_defn.type.to_s})",
+          nodes: arg_node,
+          name: ast_var.name,
+          type: var_type.to_s,
+          argument: arg_node.name,
+          error: error_message
+        ))
       end
 
       def wrap_var_type_with_depth_of_arg(var_type, arg_node)

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

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

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

@@ -1,28 +1,32 @@
 # frozen_string_literal: true
 module GraphQL
   module StaticValidation
-    class VariablesAreInputTypes
-      include GraphQL::StaticValidation::Message::MessageHelper
-
-      def validate(context)
-        context.visitor[GraphQL::Language::Nodes::VariableDefinition] << ->(node, parent) {
-          validate_is_input_type(node, context)
-        }
-      end
-
-      private
-
-      def validate_is_input_type(node, context)
+    module VariablesAreInputTypes
+      def on_variable_definition(node, parent)
         type_name = get_type_name(node.type)
         type = context.warden.get_type(type_name)
 
         if type.nil?
-          context.errors << message("#{type_name} isn't a defined input type (on $#{node.name})", node, context: context)
+          add_error(GraphQL::StaticValidation::VariablesAreInputTypesError.new(
+            "#{type_name} isn't a defined input type (on $#{node.name})",
+            nodes: node,
+            name: node.name,
+            type: type_name
+          ))
         elsif !type.kind.input?
-          context.errors << message("#{type.name} isn't a valid input type (on $#{node.name})", node, context: context)
+          add_error(GraphQL::StaticValidation::VariablesAreInputTypesError.new(
+            "#{type.name} isn't a valid input type (on $#{node.name})",
+            nodes: node,
+            name: node.name,
+            type: type_name
+          ))
         end
+
+        super
       end
 
+      private
+
       def get_type_name(ast_type)
         if ast_type.respond_to?(:of_type)
           get_type_name(ast_type.of_type)