graphql 1.10.0 → 1.10.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5410e491e639ee266d3c13a8f3073be2d8270289548f6c63e10a056fe5ff8a43
-  data.tar.gz: 9b6a6a7dd62e3946b49b0e46c8dbf7745feeb4b48cb931b9d9d2deb9221bb43a
+  metadata.gz: 206501adb93cafefa37313d5cb3bc58413701cd5a2cc4028a9b749c119d7868d
+  data.tar.gz: 34e9b0f601cb1517c1060b4c964e6a25e020540b115d876af8c3c775cfd28793
 SHA512:
-  metadata.gz: 78f06f66e32517103a861c2adeeeac0f090dbb111d4827a22f3f7a398b8825b10fc1d89bfcc96be3543e8c043351a7023ef1542284bc5ce60518ed5eeb6e6c70
-  data.tar.gz: 53264646f1a059b97494503b350de5908d2ca70392c749426d6863275ac4b99f4629dbf18ae21fc21f1bd85fbb02ad4f7f17b7a8ce54a64e0aa89ee6bbee253b
+  metadata.gz: e68296c1cb93a1164ce0123a77fc0ec7efd86e51afd029b808bb3f466b2287744d1e54b01f685b1bcf71c7e4265a064b1e88ee5cfbcfc6647312758d2e7962f9
+  data.tar.gz: 01de56922522f3984950ddfc1821c7d15fd27ea7055470cf6102f9af9fa3c8402eefa41061c82d83a9461d4ae9df3f45935e10775ac6322ef9e0c40bd978c3a1

data/lib/graphql.rb

@@ -7,6 +7,14 @@ require "forwardable"
 require_relative "./graphql/railtie" if defined? Rails::Railtie
 
 module GraphQL
+  # forwards-compat for argument handling
+  module Ruby2Keywords
+    if RUBY_VERSION < "2.7"
+      def ruby2_keywords(*)
+      end
+    end
+  end
+
   class Error < StandardError
   end
 

data/lib/graphql/analysis/ast/query_complexity.rb

@@ -8,7 +8,7 @@ module GraphQL
         # - `complexities_on_type` holds complexity scores for each type in an IRep node
         def initialize(query)
           super
-          @complexities_on_type = [ConcreteTypeComplexity.new]
+          @complexities_on_type_by_query = {}
         end
 
         # Overide this method to use the complexity result
@@ -16,17 +16,68 @@ module GraphQL
           max_possible_complexity
         end
 
+        class ScopedTypeComplexity
+          # A single proc for {#scoped_children} hashes. Use this to avoid repeated allocations,
+          # since the lexical binding isn't important.
+          HASH_CHILDREN = ->(h, k) { h[k] = {} }
+
+          # @param node [Language::Nodes::Field] The AST node; used for providing argument values when necessary
+          # @param field_definition [GraphQL::Field, GraphQL::Schema::Field] Used for getting the `.complexity` configuration
+          # @param query [GrpahQL::Query] Used for `query.possible_types`
+          def initialize(node, field_definition, query)
+            @field_definition = field_definition
+            @query = query
+            @node = node
+            @scoped_children = nil
+          end
+
+          # Returns true if this field has no selections, ie, it's a scalar.
+          # We need a quick way to check whether we should continue traversing.
+          def terminal?
+            @scoped_children.nil?
+          end
+
+          # This value is only calculated when asked for to avoid needless hash allocations.
+          # Also, if it's never asked for, we determine that this scope complexity
+          # is a scalar field ({#terminal?}).
+          # @return [Hash<Hash<Class => ScopedTypeComplexity>]
+          def scoped_children
+            @scoped_children ||= Hash.new(&HASH_CHILDREN)
+          end
+
+          def own_complexity(child_complexity)
+            defined_complexity = @field_definition.complexity
+            case defined_complexity
+            when Proc
+              arguments = @query.arguments_for(@node, @field_definition)
+              defined_complexity.call(@query.context, arguments, child_complexity)
+            when Numeric
+              defined_complexity + child_complexity
+            else
+              raise("Invalid complexity: #{defined_complexity.inspect} on #{@field_definition.name}")
+            end
+          end
+        end
+
         def on_enter_field(node, parent, visitor)
           # We don't want to visit fragment definitions,
           # we'll visit them when we hit the spreads instead
           return if visitor.visiting_fragment_definition?
           return if visitor.skipping?
-
-          if visitor.type_definition.kind.abstract?
-            @complexities_on_type.push(AbstractTypeComplexity.new)
-          else
-            @complexities_on_type.push(ConcreteTypeComplexity.new)
-          end
+          parent_type = visitor.parent_type_definition
+          field_key = node.alias || node.name
+          # Find the complexity calculation for this field --
+          # if we're re-entering a selection, we'll already have one.
+          # Otherwise, make a new one and store it.
+          #
+          # `node` and `visitor.field_definition` may appear from a cache,
+          # but I think that's ok. If the arguments _didn't_ match,
+          # then the query would have been rejected as invalid.
+          complexities_on_type = @complexities_on_type_by_query[visitor.query] ||= [ScopedTypeComplexity.new(nil, nil, query)]
+
+          complexity = complexities_on_type.last.scoped_children[parent_type][field_key] ||= ScopedTypeComplexity.new(node, visitor.field_definition, visitor.query)
+          # Push it on the stack.
+          complexities_on_type.push(complexity)
         end
 
         def on_leave_field(node, parent, visitor)
@@ -34,87 +85,126 @@ module GraphQL
           # we'll visit them when we hit the spreads instead
           return if visitor.visiting_fragment_definition?
           return if visitor.skipping?
-
-          type_complexities = @complexities_on_type.pop
-          child_complexity = type_complexities.max_possible_complexity
-          own_complexity = get_complexity(node, visitor.field_definition, child_complexity, visitor)
-
-          if @complexities_on_type.last.is_a?(AbstractTypeComplexity)
-            key = selection_key(visitor.response_path, visitor.query)
-            parent_type = visitor.parent_type_definition
-            visitor.query.possible_types(parent_type).each do |type|
-              @complexities_on_type.last.merge(type, key, own_complexity)
-            end
-          else
-            @complexities_on_type.last.merge(own_complexity)
-          end
+          complexities_on_type = @complexities_on_type_by_query[visitor.query]
+          complexities_on_type.pop
         end
 
         # @return [Integer]
         def max_possible_complexity
-          @complexities_on_type.last.max_possible_complexity
-        end
-
-        private
-
-        def selection_key(response_path, query)
-          # We add the query object id to support multiplex queries
-          # even if they have the same response path, they should
-          # always be added.
-          "#{response_path.join(".")}-#{query.object_id}"
-        end
-
-        # Get a complexity value for a field,
-        # by getting the number or calling its proc
-        def get_complexity(ast_node, field_defn, child_complexity, visitor)
-        # Return if we've visited this response path before (not counting duplicates)
-          defined_complexity = field_defn.complexity
-
-          arguments = visitor.arguments_for(ast_node, field_defn)
-
-          case defined_complexity
-          when Proc
-            defined_complexity.call(visitor.query.context, arguments, child_complexity)
-          when Numeric
-            defined_complexity + (child_complexity || 0)
-          else
-            raise("Invalid complexity: #{defined_complexity.inspect} on #{field_defn.name}")
+          @complexities_on_type_by_query.reduce(0) do |total, (query, complexities_on_type)|
+            root_complexity = complexities_on_type.last
+            # Use this entry point to calculate the total complexity
+            total_complexity_for_query = ComplexityMergeFunctions.merged_max_complexity_for_scopes(query, [root_complexity.scoped_children])
+            total + total_complexity_for_query
           end
         end
 
-        # Selections on an object may apply differently depending on what is _actually_ returned by the resolve function.
-        # Find the maximum possible complexity among those combinations.
-        class AbstractTypeComplexity
-          def initialize
-            @types = Hash.new { |h, k| h[k] = {} }
+        # These functions use `ScopedTypeComplexity` objects,
+        # especially their `scoped_children`, to traverse down the tree
+        # and find the max complexity for any possible runtime type.
+        # Yowza.
+        module ComplexityMergeFunctions
+          module_function
+          # When looking at two selection scopes, figure out whether the selections on
+          # `right_scope` should be applied when analyzing `left_scope`.
+          # This is like the `Typecast.subtype?`, except it's using query-specific type filtering.
+          def applies_to?(query, left_scope, right_scope)
+            if left_scope == right_scope
+              # This can happen when several branches are being analyzed together
+              true
+            else
+              # Check if these two scopes have _any_ types in common.
+              possible_right_types = query.possible_types(right_scope)
+              possible_left_types = query.possible_types(left_scope)
+              !(possible_right_types & possible_left_types).empty?
+            end
           end
 
-          # Return the max possible complexity for types in this selection
-          def max_possible_complexity
-            max = 0
-            @types.each_value do |fields|
-              complexity = fields.each_value.inject(:+)
-              max = complexity if complexity > max
+          def merged_max_complexity_for_scopes(query, scoped_children_hashes)
+            # Figure out what scopes are possible here.
+            # Use a hash, but ignore the values; it's just a fast way to work with the keys.
+            all_scopes = {}
+            scoped_children_hashes.each do |h|
+              all_scopes.merge!(h)
             end
-            max
-          end
 
-          # Store the complexity for the branch on `type_defn`.
-          # Later we will see if this is the max complexity among branches.
-          def merge(type_defn, key, complexity)
-            @types[type_defn][key] = complexity
-          end
-        end
+            # If an abstract scope is present, but _all_ of its concrete types
+            # are also in the list, remove it from the list of scopes to check,
+            # because every possible type is covered by a concrete type.
+            # (That is, there are no remainder types to check.)
+            all_scopes.reject! do |scope, _|
+              scope.kind.abstract? && (
+                query.possible_types(scope).all? { |t| all_scopes.include?(t) }
+              )
+            end
 
-        class ConcreteTypeComplexity
-          attr_reader :max_possible_complexity
+            # This will hold `{ type => int }` pairs, one for each possible branch
+            complexity_by_scope = {}
+
+            # For each scope,
+            # find the lexical selections that might apply to it,
+            # and gather them together into an array.
+            # Then, treat the set of selection hashes
+            # as a set and calculate the complexity for them as a unit
+            all_scopes.each do |scope, _|
+              # These will be the selections on `scope`
+              children_for_scope = []
+              scoped_children_hashes.each do |sc_h|
+                sc_h.each do |inner_scope, children_hash|
+                  if applies_to?(query, scope, inner_scope)
+                    children_for_scope << children_hash
+                  end
+                end
+              end
+
+              # Calculate the complexity for `scope`, merging all
+              # possible lexical branches.
+              complexity_value = merged_max_complexity(query, children_for_scope)
+              complexity_by_scope[scope] = complexity_value
+            end
 
-          def initialize
-            @max_possible_complexity = 0
+            # Return the max complexity among all scopes
+            complexity_by_scope.each_value.max
           end
 
-          def merge(complexity)
-            @max_possible_complexity += complexity
+          # @param children_for_scope [Array<Hash>] An array of `scoped_children[scope]` hashes (`{field_key => complexity}`)
+          # @return [Integer] Complexity value for all these selections in the current scope
+          def merged_max_complexity(query, children_for_scope)
+            all_keys = []
+            children_for_scope.each do |c|
+              all_keys.concat(c.keys)
+            end
+            all_keys.uniq!
+            complexity_for_keys = {}
+            all_keys.each do |child_key|
+
+              scoped_children_for_key = nil
+              complexity_for_key = nil
+              children_for_scope.each do |children_hash|
+                if children_hash.key?(child_key)
+                  complexity_for_key = children_hash[child_key]
+                  if complexity_for_key.terminal?
+                    # Assume that all terminals would return the same complexity
+                    # Since it's a terminal, its child complexity is zero.
+                    complexity_for_key = complexity_for_key.own_complexity(0)
+                    complexity_for_keys[child_key] = complexity_for_key
+                  else
+                    scoped_children_for_key ||= []
+                    scoped_children_for_key << complexity_for_key.scoped_children
+                  end
+                end
+              end
+
+              if scoped_children_for_key
+                child_complexity = merged_max_complexity_for_scopes(query, scoped_children_for_key)
+                # This is the _last_ one we visited; assume it's representative.
+                max_complexity = complexity_for_key.own_complexity(child_complexity)
+                complexity_for_keys[child_key] = max_complexity
+              end
+            end
+
+            # Calculate the child complexity by summing the complexity of all selections
+            complexity_for_keys.each_value.inject(0, &:+)
           end
         end
       end

data/lib/graphql/define/defined_object_proxy.rb

@@ -1,10 +1,12 @@
 # frozen_string_literal: true
+
 module GraphQL
   module Define
     # This object delegates most methods to a dictionary of functions, {@dictionary}.
     # {@target} is passed to the specified function, along with any arguments and block.
     # This allows a method-based DSL without adding methods to the defined class.
     class DefinedObjectProxy
+      extend GraphQL::Ruby2Keywords
       # The object which will be defined by definition functions
       attr_reader :target
 
@@ -32,16 +34,11 @@ module GraphQL
       end
 
       # Lookup a function from the dictionary and call it if it's found.
-      def method_missing(name, *args, **kwargs, &block)
+      ruby2_keywords
+      def method_missing(name, *args, &block)
         definition = @dictionary[name]
         if definition
-          # Avoid passing `kwargs` when it's not used.
-          # Ruby 2.7 does fine here, but older Rubies receive too many arguments.
-          if kwargs.any?
-            definition.call(@target, *args, **kwargs, &block)
-          else
-            definition.call(@target, *args, &block)
-          end
+          definition.call(@target, *args, &block)
         else
           msg = "#{@target.class.name} can't define '#{name}'"
           raise NoDefinitionError, msg, caller

data/lib/graphql/define/instance_definable.rb

@@ -191,12 +191,18 @@ module GraphQL
       end
 
       class AssignAttribute
+        extend GraphQL::Ruby2Keywords
+
         def initialize(attr_name)
           @attr_assign_method = :"#{attr_name}="
         end
 
-        def call(defn, value)
-          defn.public_send(@attr_assign_method, value)
+        # Even though we're just using the first value here,
+        # We have to add a splat here to use `ruby2_keywords`,
+        # so that it will accept a `[{}]` input from the caller.
+        ruby2_keywords
+        def call(defn, *value)
+          defn.public_send(@attr_assign_method, value.first)
         end
       end
     end

data/lib/graphql/execution/lookahead.rb

@@ -51,7 +51,7 @@ module GraphQL
 
       # @return [Hash<Symbol, Object>]
       def arguments
-        @arguments ||= @field && ArgumentHelpers.arguments(@query, nil, @field, ast_nodes.first)
+        @arguments ||= @field && ArgumentHelpers.arguments(@query, @field, ast_nodes.first)
       end
 
       # True if this node has a selection on `field_name`.
@@ -203,8 +203,22 @@ module GraphQL
         end
       end
 
+      def skipped_by_directive?(ast_selection)
+        ast_selection.directives.each do |directive|
+          dir_defn = @query.schema.directives.fetch(directive.name)
+          directive_class = dir_defn.type_class
+          if directive_class
+            dir_args = GraphQL::Execution::Lookahead::ArgumentHelpers.arguments(@query, dir_defn, directive)
+            return true unless directive_class.static_include?(dir_args, @query.context)
+          end
+        end
+        false
+      end
+
       def find_selections(subselections_by_type, selections_on_type, selected_type, ast_selections, arguments)
         ast_selections.each do |ast_selection|
+          next if skipped_by_directive?(ast_selection)
+
           case ast_selection
           when GraphQL::Language::Nodes::Field
             response_key = ast_selection.alias || ast_selection.name
@@ -242,6 +256,7 @@ module GraphQL
       # If a selection on `node` matches `field_name` (which is backed by `field_defn`)
       # and matches the `arguments:` constraints, then add that node to `matches`
       def find_selected_nodes(node, field_name, field_defn, arguments:, matches:)
+        return if skipped_by_directive?(node)
         case node
         when GraphQL::Language::Nodes::Field
           if node.name == field_name
@@ -263,7 +278,7 @@ module GraphQL
       end
 
       def arguments_match?(arguments, field_defn, field_node)
-        query_kwargs = ArgumentHelpers.arguments(@query, nil, field_defn, field_node)
+        query_kwargs = ArgumentHelpers.arguments(@query, field_defn, field_node)
         arguments.all? do |arg_name, arg_value|
           arg_name = normalize_keyword(arg_name)
           # Make sure the constraint is present with a matching value
@@ -275,20 +290,15 @@ module GraphQL
       module ArgumentHelpers
         module_function
 
-        def arguments(query, graphql_object, arg_owner, ast_node)
+        def arguments(query, arg_owner, ast_node)
           kwarg_arguments = {}
           arg_defns = arg_owner.arguments
           ast_node.arguments.each do |arg|
             arg_defn = arg_defns[arg.name] || raise("Invariant: missing argument definition for #{arg.name.inspect} in #{arg_defns.keys} from #{arg_owner}")
             # Need to distinguish between client-provided `nil`
             # and nothing-at-all
-            is_present, value = arg_to_value(query, graphql_object, arg_defn.type, arg.value)
+            is_present, value = arg_to_value(query, arg_defn.type, arg.value)
             if is_present
-              # This doesn't apply to directives, which are legacy
-              # Can remove this when Skip and Include use classes or something.
-              if graphql_object
-                value = arg_defn.prepare_value(graphql_object, value)
-              end
               kwarg_arguments[arg_defn.keyword] = value
             end
           end
@@ -305,7 +315,7 @@ module GraphQL
         # @param arg_type [Class, GraphQL::Schema::NonNull, GraphQL::Schema::List]
         # @param ast_value [GraphQL::Language::Nodes::VariableIdentifier, String, Integer, Float, Boolean]
         # @return [Array(is_present, value)]
-        def arg_to_value(query, graphql_object, arg_type, ast_value)
+        def arg_to_value(query, arg_type, ast_value)
           if ast_value.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
             # If it's not here, it will get added later
             if query.variables.key?(ast_value.name)
@@ -316,13 +326,13 @@ module GraphQL
           elsif ast_value.is_a?(GraphQL::Language::Nodes::NullValue)
             return true, nil
           elsif arg_type.is_a?(GraphQL::Schema::NonNull)
-            arg_to_value(query, graphql_object, arg_type.of_type, ast_value)
+            arg_to_value(query, arg_type.of_type, ast_value)
           elsif arg_type.is_a?(GraphQL::Schema::List)
             # Treat a single value like a list
             arg_value = Array(ast_value)
             list = []
             arg_value.map do |inner_v|
-              _present, value = arg_to_value(query, graphql_object, arg_type.of_type, inner_v)
+              _present, value = arg_to_value(query, arg_type.of_type, inner_v)
               list << value
             end
             return true, list

data/lib/graphql/pagination/relation_connection.rb

@@ -11,12 +11,32 @@ module GraphQL
       end
 
       def has_previous_page
-        load_nodes
+        if @has_previous_page.nil?
+          @has_previous_page = if @after_offset && @after_offset > 0
+            true
+          elsif last
+            # See whether there are any nodes _before_ the current offset.
+            # If there _is no_ current offset, then there can't be any nodes before it.
+            # Assume that if the offset is positive, there are nodes before the offset.
+            limited_nodes
+            !(@paged_nodes_offset.nil? || @paged_nodes_offset == 0)
+          else
+            false
+          end
+        end
         @has_previous_page
       end
 
       def has_next_page
-        load_nodes
+        if @has_next_page.nil?
+          @has_next_page = if @before_offset && @before_offset > 0
+            true
+          elsif first
+            relation_count(set_limit(sliced_nodes, first + 1)) == first + 1
+          else
+            false
+          end
+        end
         @has_next_page
       end
 
@@ -80,37 +100,45 @@ module GraphQL
         end
       end
 
-      # Populate all the pagination info _once_,
-      # It doesn't do anything on subsequent calls.
-      def load_nodes
-        @nodes ||= begin
+      # Apply `before` and `after` to the underlying `items`,
+      # returning a new relation.
+      def sliced_nodes
+        @sliced_nodes ||= begin
           paginated_nodes = items
-          after_offset = after && offset_from_cursor(after)
-          before_offset = before && offset_from_cursor(before)
+          @after_offset = after && offset_from_cursor(after)
+          @before_offset = before && offset_from_cursor(before)
 
-          if after_offset
+          if @after_offset
             previous_offset = relation_offset(items) || 0
-            paginated_nodes = set_offset(paginated_nodes, previous_offset + after_offset)
+            paginated_nodes = set_offset(paginated_nodes, previous_offset + @after_offset)
           end
 
-          if before_offset && after_offset
-            if after_offset < before_offset
+          if @before_offset && @after_offset
+            if @after_offset < @before_offset
               # Get the number of items between the two cursors
-              space_between = before_offset - after_offset - 1
+              space_between = @before_offset - @after_offset - 1
               paginated_nodes = set_limit(paginated_nodes, space_between)
             else
               # TODO I think this is untested
               # The cursors overextend one another to an empty set
               paginated_nodes = null_relation(paginated_nodes)
             end
-          elsif before_offset
+          elsif @before_offset
             # Use limit to cut off the tail of the relation
-            paginated_nodes = set_limit(paginated_nodes, before_offset - 1)
+            paginated_nodes = set_limit(paginated_nodes, @before_offset - 1)
           end
 
-          sliced_nodes_count = relation_count(paginated_nodes)
+          paginated_nodes
+        end
+      end
+
+      # Apply `first` and `last` to `sliced_nodes`,
+      # returning a new relation
+      def limited_nodes
+        @limited_nodes ||= begin
+          paginated_nodes = sliced_nodes
 
-          if first && (relation_limit(paginated_nodes).nil? || relation_limit(paginated_nodes) > first)
+          if first && (relation_limit(paginated_nodes).nil? || relation_limit(paginated_nodes) > first) && last.nil?
             # `first` would create a stricter limit that the one already applied, so add it
             paginated_nodes = set_limit(paginated_nodes, first)
           end
@@ -125,27 +153,24 @@ module GraphQL
               end
             else
               # No limit, so get the last items
+              sliced_nodes_count = relation_count(@sliced_nodes)
               offset = (relation_offset(paginated_nodes) || 0) + sliced_nodes_count - [last, sliced_nodes_count].min
               paginated_nodes = set_offset(paginated_nodes, offset)
               paginated_nodes = set_limit(paginated_nodes, last)
             end
           end
 
-          @has_next_page = !!(
-            (before_offset && before_offset > 0) ||
-            (first && sliced_nodes_count > first)
-          )
-
-          @has_previous_page = !!(
-            (after_offset && after_offset > 0) ||
-            (last && sliced_nodes_count > last)
-          )
-
           @paged_nodes_offset = relation_offset(paginated_nodes)
-          # Return an array so we can consistently use `.index(node)` on it
-          paginated_nodes.to_a
+          paginated_nodes
         end
       end
+
+      # Load nodes after applying first/last/before/after,
+      # returns an array of nodes
+      def load_nodes
+        # Return an array so we can consistently use `.index(node)` on it
+        @nodes ||= limited_nodes.to_a
+      end
     end
   end
 end

data/lib/graphql/query/variables.rb

@@ -29,7 +29,6 @@ module GraphQL
             default_value = ast_variable.default_value
             provided_value = @provided_variables[variable_name]
             value_was_provided =  @provided_variables.key?(variable_name)
-
             begin
               validation_result = variable_type.validate_input(provided_value, ctx)
               if validation_result.valid?

data/lib/graphql/rake_task/validate.rb

@@ -7,6 +7,9 @@ module GraphQL
     desc "Get the checksum of a graphql-pro version and compare it to published versions on GitHub and graphql-ruby.org"
     task "graphql:pro:validate", [:gem_version] do |t, args|
       version = args[:gem_version]
+      if version.nil?
+        raise ArgumentError, "A specific version is required, eg `rake graphql:pro:validate[1.12.0]`"
+      end
       check = "\e[32m✓\e[0m"
       ex = "\e[31m✘\e[0m"
       puts "Validating graphql-pro v#{version}"

data/lib/graphql/schema.rb

@@ -1817,6 +1817,11 @@ module GraphQL
               add_type(t, owner: type, late_types: late_types)
             end
           end
+          if type.kind.interface?
+            type.orphan_types.each do |t|
+              add_type(t, owner: type, late_types: late_types)
+            end
+          end
           if type.kind.object?
             own_possible_types[type.graphql_name] = [type]
             type.interfaces.each do |i|

data/lib/graphql/schema/directive.rb

@@ -60,7 +60,12 @@ module GraphQL
         end
 
         # If false, this part of the query won't be evaluated
-        def include?(_object, _arguments, _context)
+        def include?(_object, arguments, context)
+          static_include?(arguments, context)
+        end
+
+        # Determines whether {Execution::Lookahead} considers the field to be selected
+        def static_include?(_arguments, _context)
           true
         end
 

data/lib/graphql/schema/directive/include.rb

@@ -16,7 +16,7 @@ module GraphQL
 
         default_directive true
 
-        def self.include?(obj, args, ctx)
+        def self.static_include?(args, ctx)
           !!args[:if]
         end
       end

data/lib/graphql/schema/directive/skip.rb

@@ -16,7 +16,7 @@ module GraphQL
 
         default_directive true
 
-        def self.include?(obj, args, ctx)
+        def self.static_include?(args, ctx)
           !args[:if]
         end
       end

data/lib/graphql/schema/field.rb

@@ -689,7 +689,7 @@ module GraphQL
       # Written iteratively to avoid big stack traces.
       # @return [Object] Whatever the
       def with_extensions(obj, args, ctx)
-        if @extensions.nil?
+        if @extensions.empty?
           yield(obj, args)
         else
           # Save these so that the originals can be re-given to `after_resolve` handlers.

data/lib/graphql/schema/input_object.rb

@@ -185,11 +185,15 @@ module GraphQL
         end
 
         def coerce_input(value, ctx)
+          if value.nil?
+            return nil
+          end
           input_values = {}
 
           arguments.each do |name, argument_defn|
             arg_key = argument_defn.keyword
             has_value = false
+
             # Accept either string or symbol
             field_value = if value.key?(name)
               has_value = true

data/lib/graphql/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 1.10.0
+  version: 1.10.1
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-01-20 00:00:00.000000000 Z
+date: 2020-01-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: benchmark-ips