graphql 1.10.1 → 1.13.0

data/lib/graphql/static_validation/all_rules.rb

@@ -34,6 +34,7 @@ module GraphQL
       GraphQL::StaticValidation::VariableUsagesAreAllowed,
       GraphQL::StaticValidation::MutationRootExists,
       GraphQL::StaticValidation::SubscriptionRootExists,
+      GraphQL::StaticValidation::InputObjectNamesAreUnique,
     ]
   end
 end

data/lib/graphql/static_validation/base_visitor.rb

@@ -94,7 +94,7 @@ module GraphQL
 
         def on_field(node, parent)
           parent_type = @object_types.last
-          field_definition = @schema.get_field(parent_type, node.name)
+          field_definition = @schema.get_field(parent_type, node.name, @context.query.context)
           @field_definitions.push(field_definition)
           if !field_definition.nil?
             next_object_type = field_definition.type.unwrap
@@ -120,14 +120,14 @@ module GraphQL
           argument_defn = if (arg = @argument_definitions.last)
             arg_type = arg.type.unwrap
             if arg_type.kind.input_object?
-              arg_type.arguments[node.name]
+              @context.warden.get_argument(arg_type, node.name)
             else
               nil
             end
           elsif (directive_defn = @directive_definitions.last)
-            directive_defn.arguments[node.name]
+            @context.warden.get_argument(directive_defn, node.name)
           elsif (field_defn = @field_definitions.last)
-            field_defn.arguments[node.name]
+            @context.warden.get_argument(field_defn, node.name)
           else
             nil
           end
@@ -187,7 +187,7 @@ module GraphQL
 
         def on_fragment_with_type(node)
           object_type = if node.type
-            @schema.get_type(node.type.name)
+            @context.warden.get_type(node.type.name)
           else
             @object_types.last
           end
@@ -205,6 +205,9 @@ module GraphQL
       private
 
       def add_error(error, path: nil)
+        if @context.too_many_errors?
+          throw :too_many_validation_errors
+        end
         error.path ||= (path || @path.dup)
         context.errors << error
       end

data/lib/graphql/static_validation/definition_dependencies.rb

@@ -70,7 +70,6 @@ module GraphQL
         @dependency_map ||= resolve_dependencies(&block)
       end
 
-
       # Map definition AST nodes to the definition AST nodes they depend on.
       # Expose circular dependencies.
       class DependencyMap

data/lib/graphql/static_validation/error.rb

@@ -32,8 +32,10 @@ module GraphQL
 
       private
 
+      attr_reader :nodes
+
       def locations
-        @nodes.map do |node|
+        nodes.map do |node|
           h = {"line" => node.line, "column" => node.col}
           h["filename"] = node.filename if node.filename
           h

data/lib/graphql/static_validation/literal_validator.rb

@@ -6,59 +6,73 @@ module GraphQL
       def initialize(context:)
         @context = context
         @warden = context.warden
+        @invalid_response = GraphQL::Query::InputValidationResult.new(valid: false, problems: [])
+        @valid_response = GraphQL::Query::InputValidationResult.new(valid: true, problems: [])
       end
 
       def validate(ast_value, type)
+        catch(:invalid) do
+          recursively_validate(ast_value, type)
+        end
+      end
+
+      private
+
+      def recursively_validate(ast_value, type)
         if type.nil?
           # this means we're an undefined argument, see #present_input_field_values_are_valid
           maybe_raise_if_invalid(ast_value) do
-            false
+            @invalid_response
           end
         elsif ast_value.is_a?(GraphQL::Language::Nodes::NullValue)
           maybe_raise_if_invalid(ast_value) do
-            !type.kind.non_null?
+            type.kind.non_null? ? @invalid_response : @valid_response
           end
         elsif type.kind.non_null?
           maybe_raise_if_invalid(ast_value) do
-            (!ast_value.nil?)
-          end && validate(ast_value, type.of_type)
+            ast_value.nil? ?
+              @invalid_response :
+              recursively_validate(ast_value, type.of_type)
+          end
         elsif type.kind.list?
           item_type = type.of_type
-          ensure_array(ast_value).all? { |val| validate(val, item_type) }
+          results = ensure_array(ast_value).map { |val| recursively_validate(val, item_type) }
+          merge_results(results)
         elsif ast_value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
-          true
+          @valid_response
         elsif type.kind.scalar? && constant_scalar?(ast_value)
           maybe_raise_if_invalid(ast_value) do
-            type.valid_input?(ast_value, @context)
+            type.validate_input(ast_value, @context)
           end
         elsif type.kind.enum?
           maybe_raise_if_invalid(ast_value) do
             if ast_value.is_a?(GraphQL::Language::Nodes::Enum)
-              type.valid_input?(ast_value.name, @context)
+              type.validate_input(ast_value.name, @context)
             else
               # if our ast_value isn't an Enum it's going to be invalid so return false
-              false
+              @invalid_response
             end
           end
         elsif type.kind.input_object? && ast_value.is_a?(GraphQL::Language::Nodes::InputObject)
           maybe_raise_if_invalid(ast_value) do
-            required_input_fields_are_present(type, ast_value) && present_input_field_values_are_valid(type, ast_value)
+            merge_results([
+              required_input_fields_are_present(type, ast_value),
+              present_input_field_values_are_valid(type, ast_value)
+            ])
           end
         else
           maybe_raise_if_invalid(ast_value) do
-            false
+            @invalid_response
           end
         end
       end
 
-      private
-
+      # When `error_bubbling` is false, we want to bail on the first failure that we find.
+      # Use `throw` to escape the current call stack, returning the invalid response.
       def maybe_raise_if_invalid(ast_value)
         ret = yield
-        if !@context.schema.error_bubbling && !ret
-          e = LiteralValidationError.new
-          e.ast_value = ast_value
-          raise e
+        if !@context.schema.error_bubbling && !ret.valid?
+          throw(:invalid, ret)
         else
           ret
         end
@@ -82,33 +96,44 @@ module GraphQL
         # TODO - would be nice to use these to create an error message so the caller knows
         # that required fields are missing
         required_field_names = @warden.arguments(type)
-          .select { |f| f.type.kind.non_null? }
+          .select { |argument| argument.type.kind.non_null? && @warden.get_argument(type, argument.name) }
           .map(&:name)
+
         present_field_names = ast_node.arguments.map(&:name)
         missing_required_field_names = required_field_names - present_field_names
         if @context.schema.error_bubbling
-          missing_required_field_names.empty?
+          missing_required_field_names.empty? ? @valid_response : @invalid_response
         else
-          missing_required_field_names.all? do |name|
-            validate(GraphQL::Language::Nodes::NullValue.new(name: name), @warden.arguments(type).find { |f| f.name == name }.type )
+          results = missing_required_field_names.map do |name|
+            arg_type = @warden.get_argument(type, name).type
+            recursively_validate(GraphQL::Language::Nodes::NullValue.new(name: name), arg_type)
           end
+          merge_results(results)
         end
       end
 
       def present_input_field_values_are_valid(type, ast_node)
-        field_map = @warden.arguments(type).reduce({}) { |m, f| m[f.name] = f; m}
-        ast_node.arguments.all? do |value|
-          field = field_map[value.name]
+        results = ast_node.arguments.map do |value|
+          field = @warden.get_argument(type, value.name)
           # we want to call validate on an argument even if it's an invalid one
           # so that our raise exception is on it instead of the entire InputObject
-          type = field && field.type
-          validate(value.value, type)
+          field_type = field && field.type
+          recursively_validate(value.value, field_type)
         end
+        merge_results(results)
       end
 
       def ensure_array(value)
         value.is_a?(Array) ? value : [value]
       end
+
+      def merge_results(results_list)
+        merged_result = Query::InputValidationResult.new
+        results_list.each do |inner_result|
+          merged_result.merge_result!([], inner_result)
+        end
+        merged_result
+      end
     end
   end
 end

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

@@ -2,108 +2,65 @@
 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 = context.warden.get_argument(parent_defn, 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_name: node.name,
+                argument: arg_defn,
+                value: node.value
+              }
+              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

@@ -4,20 +4,36 @@ module GraphQL
     class ArgumentLiteralsAreCompatibleError < StaticValidation::Error
       attr_reader :type_name
       attr_reader :argument_name
+      attr_reader :argument
+      attr_reader :value
 
-      def initialize(message, path: nil, nodes: [], type:, argument: nil, extensions: nil)
+      def initialize(message, path: nil, nodes: [], type:, argument_name: nil, extensions: nil, coerce_extensions: nil, argument: nil, value: nil)
         super(message, path: path, nodes: nodes)
         @type_name = type
-        @argument_name = argument
+        @argument_name = argument_name
         @extensions = extensions
+        @coerce_extensions = coerce_extensions
+        @argument = argument
+        @value = value
       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,28 +3,9 @@ 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 }
+        if parent_defn && context.warden.get_argument(parent_defn, node.name)
           super
         elsif parent_defn
           kind_of_node = node_type(parent)
@@ -34,7 +15,8 @@ module GraphQL
             nodes: node,
             name: error_arg_name,
             type: kind_of_node,
-            argument: node.name
+            argument_name: node.name,
+            parent: parent_defn
           ))
         else
           # Some other weird error
@@ -44,6 +26,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 +43,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/arguments_are_defined_error.rb

@@ -5,12 +5,14 @@ module GraphQL
       attr_reader :name
       attr_reader :type_name
       attr_reader :argument_name
+      attr_reader :parent
 
-      def initialize(message, path: nil, nodes: [], name:, type:, argument:)
+      def initialize(message, path: nil, nodes: [], name:, type:, argument_name:, parent:)
         super(message, path: path, nodes: nodes)
         @name = name
         @type_name = type
-        @argument_name = argument
+        @argument_name = argument_name
+        @parent = parent
       end
 
       # A hash representation of this Message

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

@@ -4,7 +4,7 @@ module GraphQL
     module DirectivesAreDefined
       def initialize(*)
         super
-        @directive_names = context.schema.directives.keys
+        @directive_names = context.warden.directives.map(&:graphql_name)
       end
 
       def on_directive(node, parent)