graphql 1.8.7 → 1.9.0

data/lib/graphql/static_validation/definition_dependencies.rb

@@ -4,81 +4,75 @@ module GraphQL
     # Track fragment dependencies for operations
     # and expose the fragment definitions which
     # are used by a given operation
-    class DefinitionDependencies
-      def self.mount(visitor)
-        deps = self.new
-        deps.mount(visitor)
-        deps
-      end
+    module DefinitionDependencies
+      attr_reader :dependencies
 
-      def initialize
-        @node_paths = {}
+      def initialize(*)
+        super
+        @defdep_node_paths = {}
 
         # { name => node } pairs for fragments
-        @fragment_definitions = {}
+        @defdep_fragment_definitions = {}
 
         # This tracks dependencies from fragment to Node where it was used
         # { fragment_definition_node => [dependent_node, dependent_node]}
-        @dependent_definitions = Hash.new { |h, k| h[k] = Set.new }
+        @defdep_dependent_definitions = Hash.new { |h, k| h[k] = Set.new }
 
         # First-level usages of spreads within definitions
         # (When a key has an empty list as its value,
-        #  we can resolve that key's depenedents)
+        #  we can resolve that key's dependents)
         # { definition_node => [node, node ...] }
-        @immediate_dependencies = Hash.new { |h, k| h[k] = Set.new }
-      end
-
-      # A map of operation definitions to an array of that operation's dependencies
-      # @return [DependencyMap]
-      def dependency_map(&block)
-        @dependency_map ||= resolve_dependencies(&block)
-      end
+        @defdep_immediate_dependencies = Hash.new { |h, k| h[k] = Set.new }
 
-      def mount(context)
-        visitor = context.visitor
         # When we encounter a spread,
         # this node is the one who depends on it
-        current_parent = nil
-
-        visitor[GraphQL::Language::Nodes::Document] << ->(node, prev_node) {
-          node.definitions.each do |definition|
-            case definition
-            when GraphQL::Language::Nodes::OperationDefinition
-            when GraphQL::Language::Nodes::FragmentDefinition
-              @fragment_definitions[definition.name] = definition
-            end
-          end
-        }
+        @defdep_current_parent = nil
+      end
 
-        visitor[GraphQL::Language::Nodes::OperationDefinition] << ->(node, prev_node) {
-          @node_paths[node] = NodeWithPath.new(node, context.path)
-          current_parent = node
+      def on_document(node, parent)
+        node.definitions.each do |definition|
+          if definition.is_a? GraphQL::Language::Nodes::FragmentDefinition
+            @defdep_fragment_definitions[definition.name] = definition
+          end
+        end
+        super
+        @dependencies = dependency_map { |defn, spreads, frag|
+          context.on_dependency_resolve_handlers.each { |h| h.call(defn, spreads, frag) }
         }
+      end
 
-        visitor[GraphQL::Language::Nodes::OperationDefinition].leave << ->(node, prev_node) {
-          current_parent = nil
-        }
+      def on_operation_definition(node, prev_node)
+        @defdep_node_paths[node] = NodeWithPath.new(node, context.path)
+        @defdep_current_parent = node
+        super
+        @defdep_current_parent = nil
+      end
 
-        visitor[GraphQL::Language::Nodes::FragmentDefinition] << ->(node, prev_node) {
-          @node_paths[node] = NodeWithPath.new(node, context.path)
-          current_parent = node
-        }
+      def on_fragment_definition(node, parent)
+        @defdep_node_paths[node] = NodeWithPath.new(node, context.path)
+        @defdep_current_parent = node
+        super
+        @defdep_current_parent = nil
+      end
 
-        visitor[GraphQL::Language::Nodes::FragmentDefinition].leave << ->(node, prev_node) {
-          current_parent = nil
-        }
+      def on_fragment_spread(node, parent)
+        @defdep_node_paths[node] = NodeWithPath.new(node, context.path)
 
-        visitor[GraphQL::Language::Nodes::FragmentSpread] << ->(node, prev_node) {
-          @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_immediate_dependencies[@defdep_current_parent] << node
+        super
+      end
 
-          # Track both sides of the dependency
-          @dependent_definitions[@fragment_definitions[node.name]] << current_parent
-          @immediate_dependencies[current_parent] << node
-        }
+      # A map of operation definitions to an array of that operation's dependencies
+      # @return [DependencyMap]
+      def dependency_map(&block)
+        @dependency_map ||= resolve_dependencies(&block)
       end
 
+
       # Map definition AST nodes to the definition AST nodes they depend on.
-      # Expose circular depednencies.
+      # Expose circular dependencies.
       class DependencyMap
         # @return [Array<GraphQL::Language::Nodes::FragmentDefinition>]
         attr_reader :cyclical_definitions
@@ -122,14 +116,14 @@ 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 = @fragment_definitions.size
+        max_loops = @defdep_fragment_definitions.size
         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 = @fragment_definitions.values - @immediate_dependencies.keys
+        independent_fragment_nodes = @defdep_fragment_definitions.values - @defdep_immediate_dependencies.keys
 
         while fragment_node = independent_fragment_nodes.pop
           loops += 1
@@ -138,26 +132,26 @@ module GraphQL
           end
           # Since it's independent, let's remove it from here.
           # That way, we can use the remainder to identify cycles
-          @immediate_dependencies.delete(fragment_node)
-          fragment_usages = @dependent_definitions[fragment_node]
-          if fragment_usages.none?
+          @defdep_immediate_dependencies.delete(fragment_node)
+          fragment_usages = @defdep_dependent_definitions[fragment_node]
+          if fragment_usages.empty?
             # If we didn't record any usages during the visit,
             # then this fragment is unused.
-            dependency_map.unused_dependencies << @node_paths[fragment_node]
+            dependency_map.unused_dependencies << @defdep_node_paths[fragment_node]
           else
             fragment_usages.each do |definition_node|
               # Register the dependency AND second-order dependencies
               dependency_map[definition_node] << fragment_node
               dependency_map[definition_node].concat(dependency_map[fragment_node])
-              # Since we've regestered it, remove it from our to-do list
-              deps = @immediate_dependencies[definition_node]
+              # Since we've registered it, remove it from our to-do list
+              deps = @defdep_immediate_dependencies[definition_node]
               # Can't find a way to _just_ delete from `deps` and return the deleted entries
               removed, remaining = deps.partition { |spread| spread.name == fragment_node.name }
-              @immediate_dependencies[definition_node] = remaining
+              @defdep_immediate_dependencies[definition_node] = remaining
               if block_given?
                 yield(definition_node, removed, fragment_node)
               end
-              if remaining.none? && definition_node.is_a?(GraphQL::Language::Nodes::FragmentDefinition)
+              if remaining.empty? && definition_node.is_a?(GraphQL::Language::Nodes::FragmentDefinition)
                 # If all of this definition's dependencies have
                 # been resolved, we can now resolve its
                 # own dependents.
@@ -170,20 +164,20 @@ module GraphQL
         # If any dependencies were _unmet_
         # (eg, spreads with no corresponding definition)
         # then they're still in there
-        @immediate_dependencies.each do |defn_node, deps|
+        @defdep_immediate_dependencies.each do |defn_node, deps|
           deps.each do |spread|
-            if @fragment_definitions[spread.name].nil?
-              dependency_map.unmet_dependencies[@node_paths[defn_node]] << @node_paths[spread]
+            if @defdep_fragment_definitions[spread.name].nil?
+              dependency_map.unmet_dependencies[@defdep_node_paths[defn_node]] << @defdep_node_paths[spread]
               deps.delete(spread)
             end
           end
-          if deps.none?
-            @immediate_dependencies.delete(defn_node)
+          if deps.empty?
+            @defdep_immediate_dependencies.delete(defn_node)
           end
         end
 
         # Anything left in @immediate_dependencies is cyclical
-        cyclical_nodes = @immediate_dependencies.keys.map { |n| @node_paths[n] }
+        cyclical_nodes = @defdep_immediate_dependencies.keys.map { |n| @defdep_node_paths[n] }
         # @immediate_dependencies also includes operation names, but we don't care about
         # those. They became nil when we looked them up on `@fragment_definitions`, so remove them.
         cyclical_nodes.compact!

data/lib/graphql/static_validation/{message.rb → error.rb}

@@ -2,22 +2,23 @@
 module GraphQL
   module StaticValidation
     # Generates GraphQL-compliant validation message.
-    class Message
+    class Error
       # Convenience for validators
-      module MessageHelper
-        # Error `message` is located at `node`
-        def message(message, nodes, context: nil, path: nil)
+      module ErrorHelper
+        # Error `error_message` is located at `node`
+        def error(error_message, nodes, context: nil, path: nil, extensions: {})
           path ||= context.path
           nodes = Array(nodes)
-          GraphQL::StaticValidation::Message.new(message, nodes: nodes, path: path)
+          GraphQL::StaticValidation::Error.new(error_message, nodes: nodes, path: path)
         end
       end
 
-      attr_reader :message, :path
+      attr_reader   :message
+      attr_accessor :path
 
-      def initialize(message, path: [], nodes: [])
+      def initialize(message, path: nil, nodes: [])
         @message = message
-        @nodes = nodes
+        @nodes = Array(nodes)
         @path = path
       end
 
@@ -25,9 +26,8 @@ module GraphQL
       def to_h
         {
           "message" => message,
-          "locations" => locations,
-          "fields" => path,
-        }
+          "locations" => locations
+        }.tap { |h| h["path"] = path unless path.nil? }
       end
 
       private

data/lib/graphql/static_validation/interpreter_visitor.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class InterpreterVisitor < BaseVisitor
+      include(GraphQL::StaticValidation::DefinitionDependencies)
+
+      StaticValidation::ALL_RULES.reverse_each do |r|
+        include(r)
+      end
+
+      include(ContextMethods)
+    end
+  end
+end

data/lib/graphql/static_validation/literal_validator.rb

@@ -9,29 +9,61 @@ module GraphQL
       end
 
       def validate(ast_value, type)
-        if ast_value.is_a?(GraphQL::Language::Nodes::NullValue)
-          !type.kind.non_null?
+        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
+          end
+        elsif ast_value.is_a?(GraphQL::Language::Nodes::NullValue)
+          maybe_raise_if_invalid(ast_value) do
+            !type.kind.non_null?
+          end
         elsif type.kind.non_null?
-          (!ast_value.nil?) && validate(ast_value, type.of_type)
+          maybe_raise_if_invalid(ast_value) do
+            (!ast_value.nil?)
+          end && validate(ast_value, type.of_type)
         elsif type.kind.list?
           item_type = type.of_type
           ensure_array(ast_value).all? { |val| validate(val, item_type) }
         elsif ast_value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
           true
         elsif type.kind.scalar? && constant_scalar?(ast_value)
-          type.valid_input?(ast_value, @context)
-        elsif type.kind.enum? && ast_value.is_a?(GraphQL::Language::Nodes::Enum)
-          type.valid_input?(ast_value.name, @context)
+          maybe_raise_if_invalid(ast_value) do
+            type.valid_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)
+            else
+              # if our ast_value isn't an Enum it's going to be invalid so return false
+              false
+            end
+          end
         elsif type.kind.input_object? && ast_value.is_a?(GraphQL::Language::Nodes::InputObject)
-          required_input_fields_are_present(type, ast_value) &&
-            present_input_field_values_are_valid(type, ast_value)
+          maybe_raise_if_invalid(ast_value) do
+            required_input_fields_are_present(type, ast_value) && present_input_field_values_are_valid(type, ast_value)
+          end
         else
-          false
+          maybe_raise_if_invalid(ast_value) do
+            false
+          end
         end
       end
 
       private
 
+      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
+        else
+          ret
+        end
+      end
+
       # The GraphQL grammar supports variables embedded within scalars but graphql.js
       # doesn't support it so we won't either for simplicity
       def constant_scalar?(ast_value)
@@ -47,19 +79,30 @@ module GraphQL
       end
 
       def required_input_fields_are_present(type, ast_node)
+        # 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)
         present_field_names = ast_node.arguments.map(&:name)
         missing_required_field_names = required_field_names - present_field_names
-        missing_required_field_names.none?
+        if @context.schema.error_bubbling
+          missing_required_field_names.empty?
+        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 )
+          end
+        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]
-          field && validate(value.value, field.type)
+          # 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)
         end
       end
 

data/lib/graphql/static_validation/no_validate_visitor.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class NoValidateVisitor < StaticValidation::BaseVisitor
+      include(GraphQL::InternalRepresentation::Rewrite)
+      include(GraphQL::StaticValidation::DefinitionDependencies)
+      include(ContextMethods)
+    end
+  end
+end

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

@@ -1,27 +1,98 @@
 # frozen_string_literal: true
 module GraphQL
   module StaticValidation
-    class ArgumentLiteralsAreCompatible < GraphQL::StaticValidation::ArgumentsValidator
-      def validate_node(parent, node, defn, context)
-        return if node.value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
-        arg_defn = defn.arguments[node.name]
-        return unless arg_defn
-
-        begin
-          valid = context.valid_literal?(node.value, arg_defn.type)
-        rescue GraphQL::CoercionError => err
-          error_message = err.message
+    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})"
         end
 
-        return if valid
+        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)
+              else
+                # otherwise we just check equality
+                node.value == (err.ast_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
 
-        error_message ||= begin
-          kind_of_node = node_type(parent)
-          error_arg_name = parent_name(parent, defn)
-          "Argument '#{node.name}' on #{kind_of_node} '#{error_arg_name}' has an invalid value. Expected type '#{arg_defn.type}'."
+            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
+                )
+              end
+              add_error(error)
+            end
+          end
+        end
+
+        super
+      end
+
+
+      private
+
+      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
         end
+      end
 
-        context.errors << message(error_message, parent, context: context)
+      def node_type(parent)
+        parent.class.name.split("::").last
       end
     end
   end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+module GraphQL
+  module StaticValidation
+    class ArgumentLiteralsAreCompatibleError < StaticValidation::Error
+      attr_reader :type_name
+      attr_reader :argument_name
+
+      def initialize(message, path: nil, nodes: [], type:, argument: nil)
+        super(message, path: path, nodes: nodes)
+        @type_name = type
+        @argument_name = argument
+      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? }
+
+        super.merge({
+          "extensions" => extensions
+        })
+      end
+
+      def code
+        "argumentLiteralsIncompatible"
+      end
+    end
+  end
+end

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

@@ -1,27 +1,27 @@
 # frozen_string_literal: true
 module GraphQL
   module StaticValidation
-    class ArgumentNamesAreUnique
-      include GraphQL::StaticValidation::Message::MessageHelper
+    module ArgumentNamesAreUnique
+      include GraphQL::StaticValidation::Error::ErrorHelper
 
-      def validate(context)
-        context.visitor[GraphQL::Language::Nodes::Field] << ->(node, parent) {
-          validate_arguments(node, context)
-        }
+      def on_field(node, parent)
+        validate_arguments(node)
+        super
+      end
 
-        context.visitor[GraphQL::Language::Nodes::Directive] << ->(node, parent) {
-          validate_arguments(node, context)
-        }
+      def on_directive(node, parent)
+        validate_arguments(node)
+        super
       end
 
-      def validate_arguments(node, context)
+      def validate_arguments(node)
         argument_defns = node.arguments
         if argument_defns.any?
           args_by_name = Hash.new { |h, k| h[k] = [] }
           argument_defns.each { |a| args_by_name[a.name] << a }
           args_by_name.each do |name, defns|
             if defns.size > 1
-              context.errors << message("There can be only one argument named \"#{name}\"", defns, context: context)
+              add_error(GraphQL::StaticValidation::ArgumentNamesAreUniqueError.new("There can be only one argument named \"#{name}\"", nodes: defns, name: name))
             end
           end
         end

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

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

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

@@ -1,18 +1,62 @@
 # frozen_string_literal: true
 module GraphQL
   module StaticValidation
-    class ArgumentsAreDefined < GraphQL::StaticValidation::ArgumentsValidator
-      def validate_node(parent, node, defn, context)
-        argument_defn = context.warden.arguments(defn).find { |arg| arg.name == node.name }
-        if argument_defn.nil?
+    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.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})"
+        end
+
+        if parent_defn && context.warden.arguments(parent_defn).any? { |arg| arg.name == node.name }
+          super
+        elsif parent_defn
           kind_of_node = node_type(parent)
-          error_arg_name = parent_name(parent, defn)
-          context.errors << message("#{kind_of_node} '#{error_arg_name}' doesn't accept argument '#{node.name}'", node, context: context)
-          GraphQL::Language::Visitor::SKIP
+          error_arg_name = parent_name(parent, parent_defn)
+          add_error(GraphQL::StaticValidation::ArgumentsAreDefinedError.new(
+            "#{kind_of_node} '#{error_arg_name}' doesn't accept argument '#{node.name}'",
+            nodes: node,
+            name: error_arg_name,
+            type: kind_of_node,
+            argument: node.name
+          ))
+        else
+          # Some other weird error
+          super
+        end
+      end
+
+      private
+
+      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
-          nil
+          parent.name
         end
       end
+
+      def node_type(parent)
+        parent.class.name.split("::").last
+      end
     end
   end
 end