graphql 1.9.0.pre1 → 1.9.0.pre2

data/lib/graphql/schema/relay_classic_mutation.rb

@@ -32,7 +32,12 @@ module GraphQL
         # Without the interpreter, the inputs are unwrapped by an instrumenter.
         # But when using the interpreter, no instrumenters are applied.
         if context.interpreter?
-          input = inputs[:input]
+          input = inputs[:input].to_h
+          # Transfer these from the top-level hash to the
+          # shortcutted `input:` object
+          self.class.extras.each do |ext|
+            input[ext] = inputs[ext]
+          end
         else
           input = inputs
         end

data/lib/graphql/schema/resolver.rb

@@ -310,7 +310,7 @@ module GraphQL
             type: type_expr,
             description: description,
             extras: extras,
-            method: :resolve_with_support,
+            resolver_method: :resolve_with_support,
             resolver_class: self,
             arguments: arguments,
             null: null,

data/lib/graphql/static_validation.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
-require "graphql/static_validation/message"
+require "graphql/static_validation/error"
 require "graphql/static_validation/definition_dependencies"
 require "graphql/static_validation/type_stack"
 require "graphql/static_validation/validator"
@@ -15,3 +15,4 @@ end
 
 require "graphql/static_validation/all_rules"
 require "graphql/static_validation/default_visitor"
+require "graphql/static_validation/interpreter_visitor"

data/lib/graphql/static_validation/all_rules.rb

@@ -25,6 +25,7 @@ module GraphQL
       GraphQL::StaticValidation::ArgumentsAreDefined,
       GraphQL::StaticValidation::ArgumentLiteralsAreCompatible,
       GraphQL::StaticValidation::RequiredArgumentsArePresent,
+      GraphQL::StaticValidation::RequiredInputObjectAttributesArePresent,
       GraphQL::StaticValidation::ArgumentNamesAreUnique,
       GraphQL::StaticValidation::VariableNamesAreUnique,
       GraphQL::StaticValidation::VariablesAreInputTypes,

data/lib/graphql/static_validation/base_visitor.rb

@@ -14,6 +14,11 @@ 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
@@ -27,12 +32,22 @@ 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)
+      def self.including_rules(rules, rewrite: true)
         if rules.none?
-          NoValidateVisitor
+          if rewrite
+            NoValidateVisitor
+          else
+            # It's not doing _anything?!?_
+            BaseVisitor
+          end
         elsif rules == ALL_RULES
-          DefaultVisitor
+          if rewrite
+            DefaultVisitor
+          else
+            InterpreterVisitor
+          end
         else
           visitor_class = Class.new(self) do
             include(GraphQL::StaticValidation::DefinitionDependencies)
@@ -45,7 +60,9 @@ module GraphQL
             end
           end
 
-          visitor_class.include(GraphQL::InternalRepresentation::Rewrite)
+          if rewrite
+            visitor_class.include(GraphQL::InternalRepresentation::Rewrite)
+          end
           visitor_class.include(ContextMethods)
           visitor_class
         end
@@ -172,13 +189,11 @@ module GraphQL
 
       private
 
-      # Error `message` is located at `node`
-      def add_error(message, nodes, path: nil)
-        path ||= @path.dup
-        nodes = Array(nodes)
-        m = GraphQL::StaticValidation::Message.new(message, nodes: nodes, path: path)
-        context.errors << m
+      def add_error(error, path: nil)
+        error.path ||= (path || @path.dup)
+        context.errors << error
       end
+
     end
   end
 end

data/lib/graphql/static_validation/definition_dependencies.rb

@@ -20,7 +20,7 @@ module GraphQL
 
         # 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 ...] }
         @defdep_immediate_dependencies = Hash.new { |h, k| h[k] = Set.new }
 
@@ -72,7 +72,7 @@ module GraphQL
 
 
       # 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
@@ -143,7 +143,7 @@ module GraphQL
               # 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
+              # 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 }

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.none?
+        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/rules/argument_literals_are_compatible.rb

@@ -31,17 +31,46 @@ module GraphQL
             begin
               valid = context.valid_literal?(node.value, arg_defn.type)
             rescue GraphQL::CoercionError => err
-              error_message = err.message
+              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
+                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
 
             if !valid
-              error_message ||= begin
+              error ||= begin
                 kind_of_node = node_type(parent)
                 error_arg_name = parent_name(parent, parent_defn)
-                "Argument '#{node.name}' on #{kind_of_node} '#{error_arg_name}' has an invalid value. Expected type '#{arg_defn.type}'."
-              end
 
-              add_error(error_message, parent)
+                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

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

@@ -2,7 +2,7 @@
 module GraphQL
   module StaticValidation
     module ArgumentNamesAreUnique
-      include GraphQL::StaticValidation::Message::MessageHelper
+      include GraphQL::StaticValidation::Error::ErrorHelper
 
       def on_field(node, parent)
         validate_arguments(node)
@@ -21,7 +21,7 @@ module GraphQL
           argument_defns.each { |a| args_by_name[a.name] << a }
           args_by_name.each do |name, defns|
             if defns.size > 1
-              add_error("There can be only one argument named \"#{name}\"", defns)
+              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

@@ -29,7 +29,13 @@ module GraphQL
         elsif parent_defn
           kind_of_node = node_type(parent)
           error_arg_name = parent_name(parent, parent_defn)
-          add_error("#{kind_of_node} '#{error_arg_name}' doesn't accept argument '#{node.name}'", node)
+          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