graphql 1.10.4 → 1.10.5

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

@@ -2,108 +2,63 @@
 module GraphQL
   module StaticValidation
     module ArgumentLiteralsAreCompatible
-      # TODO dedup with ArgumentsAreDefined
       def on_argument(node, parent)
-        parent_defn = case parent
-        when GraphQL::Language::Nodes::InputObject
-          arg_defn = context.argument_definition
-          if arg_defn.nil?
-            nil
-          else
-            arg_ret_type = arg_defn.type.unwrap
-            if !arg_ret_type.kind.input_object?
-              nil
-            else
-              arg_ret_type
-            end
-          end
-        when GraphQL::Language::Nodes::Directive
-          context.schema.directives[parent.name]
-        when GraphQL::Language::Nodes::Field
-          context.field_definition
-        else
-          raise "Unexpected argument parent: #{parent.class} (##{parent})"
+        # Check the child arguments first;
+        # don't add a new error if one of them reports an error
+        super
+
+        # Don't validate variables here
+        if node.value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
+          return
         end
 
-        if parent_defn && !node.value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
-          arg_defn = parent_defn.arguments[node.name]
-          if arg_defn
-            begin
-              valid = context.valid_literal?(node.value, arg_defn.type)
-            rescue GraphQL::CoercionError => err
-              context.schema.error_bubbling
-              if !context.schema.error_bubbling && !arg_defn.type.unwrap.kind.scalar?
-                # if error bubbling is disabled and the arg that caused this error isn't a scalar then
-                # short-circuit here so we avoid bubbling this up to whatever input_object / array contains us
-                return super
-              end
-              error = GraphQL::StaticValidation::ArgumentLiteralsAreCompatibleError.new(err.message, nodes: parent, type: "CoercionError", extensions: err.extensions)
-            rescue GraphQL::LiteralValidationError => err
-              # check to see if the ast node that caused the error to be raised is
-              # the same as the node we were checking here.
-              arg_type = arg_defn.type
-              if arg_type.kind.non_null?
-                arg_type = arg_type.of_type
-              end
+        if @context.schema.error_bubbling || context.errors.none? { |err| err.path.take(@path.size) == @path }
+          parent_defn = parent_definition(parent)
 
-              matched = if arg_type.kind.list?
-                # for a list we claim an error if the node is contained in our list
-                Array(node.value).include?(err.ast_value)
-              elsif arg_type.kind.input_object? && node.value.is_a?(GraphQL::Language::Nodes::InputObject)
-                # for an input object we check the arguments
-                node.value.arguments.include?(err.ast_value)
+          if parent_defn && (arg_defn = parent_defn.arguments[node.name])
+            validation_result = context.validate_literal(node.value, arg_defn.type)
+            if !validation_result.valid?
+              kind_of_node = node_type(parent)
+              error_arg_name = parent_name(parent, parent_defn)
+              string_value = if node.value == Float::INFINITY
+                ""
               else
-                # otherwise we just check equality
-                node.value == err.ast_value
+                " (#{GraphQL::Language::Printer.new.print(node.value)})"
               end
-              if !matched
-                # This node isn't the node that caused the error,
-                # So halt this visit but continue visiting the rest of the tree
-                return super
-              end
-            end
 
-            if !valid
-              error ||= begin
-                kind_of_node = node_type(parent)
-                error_arg_name = parent_name(parent, parent_defn)
-                string_value = if node.value == Float::INFINITY
-                  ""
-                else
-                  " (#{GraphQL::Language::Printer.new.print(node.value)})"
+              problems = validation_result.problems
+              first_problem = problems && problems.first
+              if first_problem
+                message = first_problem["message"]
+                # This is some legacy stuff from when `CoercionError` was raised thru the stack
+                if message
+                  coerce_extensions = first_problem["extensions"] || {
+                    "code" => "argumentLiteralsIncompatible"
+                  }
                 end
-
-                GraphQL::StaticValidation::ArgumentLiteralsAreCompatibleError.new(
-                  "Argument '#{node.name}' on #{kind_of_node} '#{error_arg_name}' has an invalid value#{string_value}. Expected type '#{arg_defn.type.to_type_signature}'.",
-                  nodes: parent,
-                  type: kind_of_node,
-                  argument: node.name
-                )
               end
-              add_error(error)
-            end
-          end
-        end
 
-        super
-      end
+              error_options = {
+                nodes: parent,
+                type: kind_of_node,
+                argument: node.name
+              }
+              if coerce_extensions
+                error_options[:coerce_extensions] = coerce_extensions
+              end
 
+              message ||= "Argument '#{node.name}' on #{kind_of_node} '#{error_arg_name}' has an invalid value#{string_value}. Expected type '#{arg_defn.type.to_type_signature}'."
 
-      private
+              error = GraphQL::StaticValidation::ArgumentLiteralsAreCompatibleError.new(
+                message,
+                **error_options
+              )
 
-      def parent_name(parent, type_defn)
-        if parent.is_a?(GraphQL::Language::Nodes::Field)
-          parent.alias || parent.name
-        elsif parent.is_a?(GraphQL::Language::Nodes::InputObject)
-          type_defn.name
-        else
-          parent.graphql_name
+              add_error(error)
+            end
+          end
         end
       end
-
-      def node_type(parent)
-        parent.class.name.split("::").last
-      end
     end
   end
 end

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

@@ -5,19 +5,31 @@ module GraphQL
       attr_reader :type_name
       attr_reader :argument_name
 
-      def initialize(message, path: nil, nodes: [], type:, argument: nil, extensions: nil)
+      def initialize(message, path: nil, nodes: [], type:, argument: nil, extensions: nil, coerce_extensions: nil)
         super(message, path: path, nodes: nodes)
         @type_name = type
         @argument_name = argument
         @extensions = extensions
+        @coerce_extensions = coerce_extensions
       end
 
       # A hash representation of this Message
       def to_h
-        extensions = {
-          "code" => code,
-          "typeName" => type_name
-        }.tap { |h| h["argumentName"] = argument_name unless argument_name.nil? }
+        if @coerce_extensions
+          extensions = @coerce_extensions
+          # This is for legacy compat -- but this key is supposed to be a GraphQL type name :confounded:
+          extensions["typeName"] = "CoercionError"
+        else
+          extensions = {
+            "code" => code,
+            "typeName" => type_name
+          }
+
+          if argument_name
+            extensions["argumentName"] = argument_name
+          end
+        end
+
         extensions.merge!(@extensions) unless @extensions.nil?
         super.merge({
           "extensions" => extensions

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

@@ -3,26 +3,7 @@ module GraphQL
   module StaticValidation
     module ArgumentsAreDefined
       def on_argument(node, parent)
-        parent_defn = case parent
-        when GraphQL::Language::Nodes::InputObject
-          arg_defn = context.argument_definition
-          if arg_defn.nil?
-            nil
-          else
-            arg_ret_type = arg_defn.type.unwrap
-            if arg_ret_type.kind.input_object?
-              arg_ret_type
-            else
-              nil
-            end
-          end
-        when GraphQL::Language::Nodes::Directive
-          context.schema.directives[parent.name]
-        when GraphQL::Language::Nodes::Field
-          context.field_definition
-        else
-          raise "Unexpected argument parent: #{parent.class} (##{parent})"
-        end
+        parent_defn = parent_definition(parent)
 
         if parent_defn && context.warden.arguments(parent_defn).any? { |arg| arg.name == node.name }
           super
@@ -44,6 +25,7 @@ module GraphQL
 
       private
 
+      # TODO smell: these methods are added to all visitors, since they're included in a module.
       def parent_name(parent, type_defn)
         case parent
         when GraphQL::Language::Nodes::Field
@@ -60,6 +42,29 @@ module GraphQL
       def node_type(parent)
         parent.class.name.split("::").last
       end
+
+      def parent_definition(parent)
+        case parent
+        when GraphQL::Language::Nodes::InputObject
+          arg_defn = context.argument_definition
+          if arg_defn.nil?
+            nil
+          else
+            arg_ret_type = arg_defn.type.unwrap
+            if arg_ret_type.kind.input_object?
+              arg_ret_type
+            else
+              nil
+            end
+          end
+        when GraphQL::Language::Nodes::Directive
+          context.schema.directives[parent.name]
+        when GraphQL::Language::Nodes::Field
+          context.field_definition
+        else
+          raise "Unexpected argument parent: #{parent.class} (##{parent})"
+        end
+      end
     end
   end
 end

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

@@ -17,22 +17,22 @@ module GraphQL
             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
+              validation_result = context.validate_literal(value, type)
+
+              if !validation_result.valid?
+                problems = validation_result.problems
+                first_problem = problems && problems.first
+                if first_problem
+                  error_message = first_problem["message"]
+                end
 
-              if !valid
                 error_message ||= "Default value for $#{node.name} doesn't match type #{type.to_type_signature}"
                 add_error(GraphQL::StaticValidation::VariableDefaultValuesAreCorrectlyTypedError.new(
                   error_message,
                   nodes: node,
                   name: node.name,
                   type: type.to_type_signature,
-                  error_type: VariableDefaultValuesAreCorrectlyTypedError::VIOLATIONS[:INVALID_TYPE]
+                  error_type: VariableDefaultValuesAreCorrectlyTypedError::VIOLATIONS[:INVALID_TYPE],
                 ))
               end
             end

data/lib/graphql/static_validation/validation_context.rb

@@ -35,7 +35,7 @@ module GraphQL
         @on_dependency_resolve_handlers << handler
       end
 
-      def valid_literal?(ast_value, type)
+      def validate_literal(ast_value, type)
         @literal_validator.validate(ast_value, type)
       end
     end

data/lib/graphql/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module GraphQL
-  VERSION = "1.10.4"
+  VERSION = "1.10.5"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 1.10.4
+  version: 1.10.5
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-03-03 00:00:00.000000000 Z
+date: 2020-03-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
@@ -482,7 +482,6 @@ files:
 - lib/graphql/language/token.rb
 - lib/graphql/language/visitor.rb
 - lib/graphql/list_type.rb
-- lib/graphql/literal_validation_error.rb
 - lib/graphql/load_application_object_failed_error.rb
 - lib/graphql/name_validator.rb
 - lib/graphql/non_null_type.rb

data/lib/graphql/literal_validation_error.rb

@@ -1,6 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  class LiteralValidationError < GraphQL::Error
-    attr_accessor :ast_value
-  end
-end