graphql 1.9.0 → 2.1.1

data/lib/graphql/static_validation/all_rules.rb

@@ -3,7 +3,7 @@ module GraphQL
   module StaticValidation
     # Default rules for {GraphQL::StaticValidation::Validator}
     #
-    # Order is important here. Some validators return {GraphQL::Language::Visitor::SKIP}
+    # Order is important here. Some validators skip later hooks.
     # which stops the visit on that node. That way it doesn't try to find fields on types that
     # don't exist, etc.
     ALL_RULES = [
@@ -33,7 +33,10 @@ module GraphQL
       GraphQL::StaticValidation::VariablesAreUsedAndDefined,
       GraphQL::StaticValidation::VariableUsagesAreAllowed,
       GraphQL::StaticValidation::MutationRootExists,
+      GraphQL::StaticValidation::QueryRootExists,
       GraphQL::StaticValidation::SubscriptionRootExists,
+      GraphQL::StaticValidation::InputObjectNamesAreUnique,
+      GraphQL::StaticValidation::OneOfInputObjectsAreValid,
     ]
   end
 end

data/lib/graphql/static_validation/base_visitor.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 module GraphQL
   module StaticValidation
-    class BaseVisitor < GraphQL::Language::Visitor
+    class BaseVisitor < GraphQL::Language::StaticVisitor
       def initialize(document, context)
         @path = []
         @object_types = []
@@ -14,11 +14,6 @@ module GraphQL
         super(document)
       end
 
-      # This will be overwritten by {InternalRepresentation::Rewrite} if it's included
-      def rewrite_document
-        nil
-      end
-
       attr_reader :context
 
       # @return [Array<GraphQL::ObjectType>] Types whose scope we've entered
@@ -32,22 +27,13 @@ module GraphQL
       # Build a class to visit the AST and perform validation,
       # or use a pre-built class if rules is `ALL_RULES` or empty.
       # @param rules [Array<Module, Class>]
-      # @param rewrite [Boolean] if `false`, don't include rewrite
       # @return [Class] A class for validating `rules` during visitation
-      def self.including_rules(rules, rewrite: true)
+      def self.including_rules(rules)
         if rules.empty?
-          if rewrite
-            NoValidateVisitor
-          else
-            # It's not doing _anything?!?_
-            BaseVisitor
-          end
+          # It's not doing _anything?!?_
+          BaseVisitor
         elsif rules == ALL_RULES
-          if rewrite
-            DefaultVisitor
-          else
-            InterpreterVisitor
-          end
+          InterpreterVisitor
         else
           visitor_class = Class.new(self) do
             include(GraphQL::StaticValidation::DefinitionDependencies)
@@ -60,9 +46,6 @@ module GraphQL
             end
           end
 
-          if rewrite
-            visitor_class.include(GraphQL::InternalRepresentation::Rewrite)
-          end
           visitor_class.include(ContextMethods)
           visitor_class
         end
@@ -71,7 +54,7 @@ module GraphQL
       module ContextMethods
         def on_operation_definition(node, parent)
           object_type = @schema.root_type_for_operation(node.operation_type)
-          @object_types.push(object_type)
+          push_type(object_type)
           @path.push("#{node.operation_type}#{node.name ? " #{node.name}" : ""}")
           super
           @object_types.pop
@@ -94,13 +77,13 @@ 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
-            @object_types.push(next_object_type)
+            push_type(next_object_type)
           else
-            @object_types.push(nil)
+            push_type(nil)
           end
           @path.push(node.alias || node.name)
           super
@@ -110,7 +93,7 @@ module GraphQL
         end
 
         def on_directive(node, parent)
-          directive_defn = @schema.directives[node.name]
+          directive_defn = @context.schema_directives[node.name]
           @directive_definitions.push(directive_defn)
           super
           @directive_definitions.pop
@@ -120,14 +103,14 @@ module GraphQL
           argument_defn = if (arg = @argument_definitions.last)
             arg_type = arg.type.unwrap
             if arg_type.kind.input_object?
-              arg_type.input_fields[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
@@ -145,6 +128,17 @@ module GraphQL
           @path.pop
         end
 
+        def on_input_object(node, parent)
+          arg_defn = @argument_definitions.last
+          if arg_defn && arg_defn.type.list?
+            @path.push(parent.children.index(node))
+            super
+            @path.pop
+          else
+            super
+          end
+        end
+
         # @return [GraphQL::BaseType] The current object type
         def type_definition
           @object_types.last
@@ -176,20 +170,27 @@ module GraphQL
 
         def on_fragment_with_type(node)
           object_type = if node.type
-            @schema.types.fetch(node.type.name, nil)
+            @context.warden.get_type(node.type.name)
           else
             @object_types.last
           end
-          @object_types.push(object_type)
+          push_type(object_type)
           yield(node)
           @object_types.pop
           @path.pop
         end
+
+        def push_type(t)
+          @object_types.push(t)
+        end
       end
 
       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

@@ -11,11 +11,11 @@ module GraphQL
         super
         @defdep_node_paths = {}
 
-        # { name => node } pairs for fragments
-        @defdep_fragment_definitions = {}
+        # { name => [node, ...] } pairs for fragments (although duplicate-named fragments are _invalid_, they are _possible_)
+        @defdep_fragment_definitions = Hash.new{ |h, k| h[k] = [] }
 
         # This tracks dependencies from fragment to Node where it was used
-        # { fragment_definition_node => [dependent_node, dependent_node]}
+        # { fragment_definition_name => [dependent_node, dependent_node]}
         @defdep_dependent_definitions = Hash.new { |h, k| h[k] = Set.new }
 
         # First-level usages of spreads within definitions
@@ -32,7 +32,7 @@ module GraphQL
       def on_document(node, parent)
         node.definitions.each do |definition|
           if definition.is_a? GraphQL::Language::Nodes::FragmentDefinition
-            @defdep_fragment_definitions[definition.name] = definition
+            @defdep_fragment_definitions[definition.name] << definition
           end
         end
         super
@@ -42,7 +42,7 @@ module GraphQL
       end
 
       def on_operation_definition(node, prev_node)
-        @defdep_node_paths[node] = NodeWithPath.new(node, context.path)
+        @defdep_node_paths[node.name] = NodeWithPath.new(node, context.path)
         @defdep_current_parent = node
         super
         @defdep_current_parent = nil
@@ -59,7 +59,7 @@ module GraphQL
         @defdep_node_paths[node] = NodeWithPath.new(node, context.path)
 
         # Track both sides of the dependency
-        @defdep_dependent_definitions[@defdep_fragment_definitions[node.name]] << @defdep_current_parent
+        @defdep_dependent_definitions[node.name] << @defdep_current_parent
         @defdep_immediate_dependencies[@defdep_current_parent] << node
         super
       end
@@ -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
@@ -116,24 +115,34 @@ module GraphQL
         dependency_map = DependencyMap.new
         # Don't allow the loop to run more times
         # than the number of fragments in the document
-        max_loops = @defdep_fragment_definitions.size
+        max_loops = 0
+        @defdep_fragment_definitions.each_value do |v|
+          max_loops += v.size
+        end
+
         loops = 0
 
         # Instead of tracking independent fragments _as you visit_,
         # determine them at the end. This way, we can treat fragments with the
         # same name as if they were the same name. If _any_ of the fragments
         # with that name has a dependency, we record it.
-        independent_fragment_nodes = @defdep_fragment_definitions.values - @defdep_immediate_dependencies.keys
-
+        independent_fragment_nodes = @defdep_fragment_definitions.values.flatten - @defdep_immediate_dependencies.keys
+        visited_fragment_names = Set.new
         while fragment_node = independent_fragment_nodes.pop
+          if visited_fragment_names.add?(fragment_node.name)
+            # this is a new fragment name
+          else
+            # this is a duplicate fragment name
+            next
+          end
           loops += 1
           if loops > max_loops
-            raise("Resolution loops exceeded the number of definitions; infinite loop detected.")
+            raise("Resolution loops exceeded the number of definitions; infinite loop detected. (Max: #{max_loops}, Current: #{loops})")
           end
           # Since it's independent, let's remove it from here.
           # That way, we can use the remainder to identify cycles
           @defdep_immediate_dependencies.delete(fragment_node)
-          fragment_usages = @defdep_dependent_definitions[fragment_node]
+          fragment_usages = @defdep_dependent_definitions[fragment_node.name]
           if fragment_usages.empty?
             # If we didn't record any usages during the visit,
             # then this fragment is unused.
@@ -151,10 +160,15 @@ module GraphQL
               if block_given?
                 yield(definition_node, removed, fragment_node)
               end
-              if remaining.empty? && definition_node.is_a?(GraphQL::Language::Nodes::FragmentDefinition)
+              if remaining.empty? &&
+                definition_node.is_a?(GraphQL::Language::Nodes::FragmentDefinition) &&
+                definition_node.name != fragment_node.name
                 # If all of this definition's dependencies have
                 # been resolved, we can now resolve its
                 # own dependents.
+                #
+                # But, it's possible to have a duplicate-named fragment here.
+                # Skip it in that case
                 independent_fragment_nodes << definition_node
               end
             end
@@ -166,7 +180,7 @@ module GraphQL
         # then they're still in there
         @defdep_immediate_dependencies.each do |defn_node, deps|
           deps.each do |spread|
-            if @defdep_fragment_definitions[spread.name].nil?
+            if !@defdep_fragment_definitions.key?(spread.name)
               dependency_map.unmet_dependencies[@defdep_node_paths[defn_node]] << @defdep_node_paths[spread]
               deps.delete(spread)
             end

data/lib/graphql/static_validation/error.rb

@@ -30,10 +30,12 @@ module GraphQL
         }.tap { |h| h["path"] = path unless path.nil? }
       end
 
+      attr_reader :nodes
+
       private
 
       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,87 @@ 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 replace_nulls_in(ast_value)
+        case ast_value
+        when Array
+          ast_value.map { |v| replace_nulls_in(v) }
+        when GraphQL::Language::Nodes::InputObject
+          ast_value.to_h
+        when GraphQL::Language::Nodes::NullValue
+          nil
+        else
+          ast_value
+        end
+      end
+
+      def recursively_validate(ast_value, type)
         if type.nil?
           # this means we're an undefined argument, see #present_input_field_values_are_valid
-          return maybe_raise_if_invalid(ast_value) do
-            false
+          maybe_raise_if_invalid(ast_value) do
+            @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)
+            ruby_value = replace_nulls_in(ast_value)
+            type.validate_input(ruby_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 +110,48 @@ 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? }
-          .map(&:name)
+          .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
+
+          if type.one_of? && ast_node.arguments.size != 1
+            results << Query::InputValidationResult.from_problem("`#{type.graphql_name}` is a OneOf type, so only one argument may be given (instead of #{ast_node.arguments.size})")
+          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,98 +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.is_a?(GraphQL::InputObjectType)
-              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")
-            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.
-              matched = if arg_defn.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_defn.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 @context.schema.error_bubbling || context.errors.none? { |err| err.path.take(@path.size) == @path }
+          parent_defn = parent_definition(parent)
+
+          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)
 
-                GraphQL::StaticValidation::ArgumentLiteralsAreCompatibleError.new(
-                  "Argument '#{node.name}' on #{kind_of_node} '#{error_arg_name}' has an invalid value. Expected type '#{arg_defn.type}'.",
-                  nodes: parent,
-                  type: kind_of_node,
-                  argument: node.name
-                )
+              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
               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.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,37 @@ 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)
+      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
         })