graphql 2.6.14 → 2.6.15

data/lib/graphql/execution/input_values.rb

@@ -2,44 +2,33 @@
 # typed: true
 module GraphQL
   module Execution
+    # Coerces input values (variables and arguments) for a query.
+    #
+    # Static validation uses [value_from_ast](rdoc-ref:#value_from_ast) to check literal values,
+    # and the runtime uses it to coerce them.
     class InputValues
-      def initialize(query, runner)
+      def initialize(query)
         @query = query
-        @runner = runner
+        @schema = query.schema
         @variable_values = nil
+        @coerced_literals = nil
       end
 
       def variable_values
-        @variable_values ||= begin
-          variable_nodes = @query.selected_operation.variables
-          if variable_nodes.empty?
-            EmptyObjects::EMPTY_HASH
-          else
-            raw_values = @query.provided_variables
-            values = {}
-            variable_nodes.each do |var_node|
-              var_ast_value = if raw_values.key?(var_node.name)
-                raw_values[var_node.name]
-              elsif raw_values.key?(sym_name = var_node.name.to_sym)
-                raw_values[sym_name]
-              elsif !var_node.default_value.nil?
-                var_node.default_value
-              else
-                next
-              end
-
-              var_type = @runner.schema.type_from_ast(var_node.type, context: @query.context)
-              values[var_node.name] = variable_value(var_ast_value, var_type)
-            end
-            values
-          end
-        end
+        @variable_values ||= GraphQL::Execution::VariableValues.new(
+          @query,
+          @query.selected_operation&.variables || EmptyObjects::EMPTY_ARRAY,
+          @query.provided_variables,
+        )
       end
 
       def argument_values(owner_defn, argument_nodes, field_resolve_step)
         arg_defns = @query.types.arguments(owner_defn)
-        argument_values = {}
+        if arg_defns.empty?
+          return [EmptyObjects::EMPTY_HASH, nil]
+        end
         errors = nil #: untyped
+        argument_values = {}
 
         arg_defns.each do |argument_definition|
           arg_ruby_key = argument_definition.keyword
@@ -49,6 +38,8 @@ module GraphQL
             if argument_definition.default_value?
               arg_value = value_from_ast(argument_definition.default_value, argument_definition.type)
               argument_value(argument_values, arg_ruby_key, argument_definition, arg_value, nil, field_resolve_step)
+            elsif argument_definition.type.non_null?
+              # Add an error
             end
           else
             arg_value = value_from_ast(arg_node.value, argument_definition.type)
@@ -64,74 +55,6 @@ module GraphQL
 
       private
 
-      def variable_value(value, type)
-        if type.non_null?
-          type = type.of_type
-        end
-
-        if value.is_a?(Language::Nodes::Enum)
-          value = value.name
-        end
-
-        if value.nil?
-          nil
-        elsif type.list?
-          inner_type = type.of_type
-          if value.is_a?(Array)
-            value.map { |v| variable_value(v, inner_type) }.freeze
-          else
-            [variable_value(value, inner_type)].freeze
-          end
-        elsif type.kind.input_object?
-          coerced_obj = {}
-
-          if value.is_a?(Hash)
-            @query.types.arguments(type).each do |arg|
-              arg_key = arg.keyword
-              if value.key?(arg.graphql_name)
-                arg_value = value[arg.graphql_name]
-              elsif value.key?(sym_name = arg.graphql_name.to_sym)
-                arg_value = value[sym_name]
-              elsif arg.default_value?
-                coerced_obj[arg_key] = arg.default_value
-                next
-              else
-                next
-              end
-
-              if arg_value.nil? && arg.replace_null_with_default?
-                arg_value = arg.default_value
-              end
-
-              coerced_obj[arg_key] = variable_value(arg_value, arg.type)
-            end
-          else
-            @query.types.arguments(type).each do |arg|
-              arg_key = arg.keyword
-              arg_name = arg.graphql_name
-              if (v_node = value.arguments.find { |a| a.name == arg_name }) # rubocop:disable Development/ContextIsPassedCop
-                arg_value = v_node.value
-                coerced_obj[arg_key] = if arg_value.nil? && arg.replace_null_with_default?
-                  arg.default_value
-                else
-                  variable_value(arg_value, arg.type)
-                end
-              elsif arg.default_value?
-                coerced_obj[arg_key] = arg.default_value
-              else
-                # Nothing
-              end
-            end
-          end
-
-          coerced_obj
-        elsif type.kind.leaf?
-          type.coerce_input(value, @query.context)
-        else
-          raise GraphQL::Error, "Unexpected input type: #{type.graphql_name}."
-        end
-      end
-
       def argument_value(argument_values, argument_key, argument_definition, arg_value, override_type, field_resolve_step)
         treat_as_type = override_type || argument_definition.type
         if treat_as_type.non_null?
@@ -183,7 +106,7 @@ module GraphQL
           arg_value = begin
             argument_definition.prepare_value(nil, arg_value, context: @query.context)
           rescue StandardError => err
-            handled_err = @runner.schema.handle_or_reraise(@query.context, err, object: nil, arguments: argument_values, field: field_resolve_step&.field_definition)
+            handled_err = @schema.handle_or_reraise(@query.context, err, object: nil, arguments: argument_values, field: field_resolve_step&.field_definition)
             raise handled_err if handled_err.is_a?(GraphQL::RuntimeError)
             handled_err
           end
@@ -211,7 +134,7 @@ module GraphQL
                 argument_key: idx,
               )
               ps.push(loads_step)
-              @runner.add_step(loads_step)
+              field_resolve_step.runner.add_step(loads_step)
             end
           else
             loads_step = LoadArgumentStep.new(
@@ -223,7 +146,7 @@ module GraphQL
               argument_key: argument_key,
             )
             ps.push(loads_step)
-            @runner.add_step(loads_step)
+            field_resolve_step.runner.add_step(loads_step)
           end
         else
           argument_values[argument_key] = arg_value
@@ -231,31 +154,57 @@ module GraphQL
         nil
       end
 
-      def value_from_ast(value_node, type)
+      public
+
+      # Raised by [value_from_ast](rdoc-ref:#value_from_ast) with `validate: true` when a literal value isn't valid for its type.
+      class InvalidLiteralError < GraphQL::Error # :nodoc:
+        # **Returns**
+        #
+        # - `String, nil` — A description of the problem, if there is one
+        attr_reader :explanation
+
+        def initialize(explanation = nil)
+          @explanation = explanation
+          super(explanation || "Invalid literal value")
+        end
+      end
+
+      # Coerce `value_node` (a literal from a query string or a default value) for `type`.
+      #
+      # **Parameters**
+      #
+      # - `value_node` (`GraphQL::Language::Nodes::AbstractNode, Object`)
+      # - `type` (`Class<GraphQL::Schema::Member>`)
+      # - `validate` (`Boolean`) — When true, raise `InvalidLiteralError` for invalid values and treat variable references as valid.
+      #
+      # :call-seq:
+      #   value_from_ast(GraphQL::Language::Nodes::AbstractNode | Object value_node, Class[GraphQL::Schema::Member] type, bool validate:)
+      def value_from_ast(value_node, type, validate: false)
         if type.non_null?
           type = type.of_type
+          if validate && (value_node.nil? || value_node.is_a?(Language::Nodes::NullValue))
+            raise InvalidLiteralError
+          end
         end
 
-        if value_node.nil?
+        if value_node.nil? || (value_node.is_a?(Language::Nodes::NullValue) && (validate || !type.kind.leaf?))
           nil
         elsif value_node.is_a?(GraphQL::Language::Nodes::VariableIdentifier)
-          variable_values[value_node.name]
+          # Variables are checked by `VariableUsagesAreAllowed` during validation
+          validate ? nil : variable_values.coerced_value(value_node.name)
         elsif type.list?
           inner_type = type.of_type
           if value_node.is_a?(Array)
             coerced_items = value_node.map do |inner_value_node|
-              value_from_ast(inner_value_node, inner_type)
+              value_from_ast(inner_value_node, inner_type, validate: validate)
             end
             coerced_items.freeze
-          elsif value_node.is_a?(Language::Nodes::NullValue)
-            nil
           else
-            item_value = value_from_ast(value_node, inner_type)
+            item_value = value_from_ast(value_node, inner_type, validate: validate)
             [item_value].freeze
           end
         elsif type.kind.input_object?
           coerced_obj = {}
-          # TODO manually handle NullValue here?
           if value_node.is_a?(Hash)
             @query.types.arguments(type).each do |arg|
               arg_value = value_node[arg.keyword]
@@ -267,9 +216,12 @@ module GraphQL
                 next
               end
 
-              coerced_obj[arg_key] = value_from_ast(arg_value, arg.type)
+              coerced_obj[arg_key] = value_from_ast(arg_value, arg.type, validate: validate)
+            end
+          elsif value_node.is_a?(Language::Nodes::InputObject)
+            if validate && type.one_of? && value_node.arguments.size != 1 # rubocop:disable Development/ContextIsPassedCop
+              raise InvalidLiteralError, "`#{type.graphql_name}` is a OneOf type, so only one argument may be given (instead of #{value_node.arguments.size})" # rubocop:disable Development/ContextIsPassedCop
             end
-          else
             arg_nodes_by_name = value_node.arguments.each_with_object({}) do |arg_node, acc| # rubocop:disable Development/ContextIsPassedCop
               acc[arg_node.name] = arg_node
             end
@@ -277,30 +229,53 @@ module GraphQL
             @query.types.arguments(type).each do |arg|
               arg_node = arg_nodes_by_name[arg.graphql_name]
               arg_key = arg.keyword
-              if arg_node.nil? || (arg_node.value.is_a?(Language::Nodes::VariableIdentifier) && !variable_values.key?(arg_node.value.name))
+              if arg_node.nil? || (!validate && arg_node.value.is_a?(Language::Nodes::VariableIdentifier) && !variable_values.key?(arg_node.value.name))
                 if arg.default_value?
                   coerced_obj[arg_key] = arg.default_value
+                elsif validate && arg.type.non_null?
+                  raise InvalidLiteralError
                 end
                 next
               end
 
-              arg_value = value_from_ast(arg_node.value, arg.type)
-              coerced_obj[arg_key] = arg_value
+              coerced_obj[arg_key] = value_from_ast(arg_node.value, arg.type, validate: validate)
             end
-          end
 
+            if validate
+              value_node.arguments.each do |arg_node| # rubocop:disable Development/ContextIsPassedCop
+                if @query.types.argument(type, arg_node.name).nil?
+                  raise InvalidLiteralError
+                end
+              end
+            end
+          elsif validate
+            raise InvalidLiteralError
+          end
 
           coerced_obj
-        elsif type.kind.leaf?
-          if value_node.is_a?(Language::Nodes::AbstractNode) || value_node.is_a?(Array)
-            value_node = coerce_untyped_input(value_node)
+        elsif type.kind.enum?
+          if validate
+            enum_value_from_ast(value_node, type)
+          else
+            if value_node.is_a?(Language::Nodes::Enum)
+              value_node = value_node.name
+            end
+            coerce_leaf_value(value_node, type)
           end
-
-          begin
-            type.coerce_input(value_node, @query.context)
-          rescue GraphQL::UnauthorizedEnumValueError => enum_err
-            @runner.schema.unauthorized_object(enum_err)
+        elsif type.kind.scalar?
+          if validate
+            scalar_value_from_ast(value_node, type)
+          elsif (literals = @coerced_literals&.[](type)) && literals.key?(value_node)
+            # This literal was already coerced during validation
+            literals[value_node]
+          else
+            if value_node.is_a?(Language::Nodes::AbstractNode) || value_node.is_a?(Array)
+              value_node = coerce_untyped_input(value_node)
+            end
+            coerce_leaf_value(value_node, type)
           end
+        elsif validate
+          raise InvalidLiteralError
         else
           raise "Unexpected input type: #{type.to_type_signature}."
         end
@@ -308,6 +283,69 @@ module GraphQL
 
       private
 
+      def coerce_leaf_value(value, type)
+        type.coerce_input(value, @query.context)
+      rescue GraphQL::UnauthorizedEnumValueError => enum_err
+        @schema.unauthorized_object(enum_err)
+      end
+
+      def enum_value_from_ast(value_node, type)
+        if !value_node.is_a?(Language::Nodes::Enum)
+          raise InvalidLiteralError
+        end
+        allowed_values = @query.types.enum_values(type)
+        if allowed_values.none? { |v| v.graphql_name == value_node.name }
+          raise InvalidLiteralError, "Expected #{GraphQL::Language.serialize(value_node.name)} to be one of: #{allowed_values.map(&:graphql_name).join(', ')}"
+        end
+        # Authorization is checked at runtime
+        nil
+      end
+
+      def scalar_value_from_ast(value_node, type)
+        literals = (@coerced_literals ||= {}.compare_by_identity)[type] ||= {}.compare_by_identity
+        if literals.key?(value_node)
+          return literals[value_node]
+        end
+
+        if contains_variable?(value_node)
+          # Variables aren't supported inside scalar literals
+          raise InvalidLiteralError
+        end
+
+        ruby_value = case value_node
+        when Language::Nodes::InputObject, Array
+          # Top-level enums are passed as AST nodes,
+          # but nested ones are converted to strings, to match previous behavior.
+          coerce_untyped_input(value_node)
+        else
+          value_node
+        end
+        coerced_value = begin
+          type.coerce_input(ruby_value, @query.context)
+        rescue GraphQL::CoercionError
+          raise
+        rescue StandardError => err
+          @query.handle_or_reraise(err)
+        end
+        if coerced_value.nil?
+          raise InvalidLiteralError, "Could not coerce value #{GraphQL::Language.serialize(ruby_value)} to #{type.graphql_name}"
+        end
+        literals[value_node] = coerced_value
+      end
+
+      def contains_variable?(value_node)
+        case value_node
+        when Language::Nodes::VariableIdentifier
+          true
+        when Array
+          value_node.any? { |v| contains_variable?(v) }
+        when Language::Nodes::InputObject
+          value_node.arguments.any? { |arg| contains_variable?(arg.value) } # rubocop:disable Development/ContextIsPassedCop
+        else
+          false
+        end
+      end
+
       def coerce_untyped_input(input_value)
         case input_value
         when Language::Nodes::AbstractNode
@@ -322,6 +360,8 @@ module GraphQL
               value_h[arg.name] = coerce_untyped_input(arg.value)
             end
             value_h
+          when Language::Nodes::VariableIdentifier
+            coerce_untyped_input(variable_values[input_value.name])
           else
             raise "Unhandled untyped input AST node: #{input_value.class}"
           end

data/lib/graphql/execution/interpreter/runtime.rb

@@ -221,7 +221,7 @@ module GraphQL
         end
 
         #: (untyped, untyped, untyped, untyped, Array[untyped]?, untyped, untyped) -> untyped
-        def gather_selections(graphql_response, owner_object, owner_type, selections, selections_to_run, selections_by_name, ordered_result_keys)
+        def gather_selections(graphql_response, owner_object, owner_type, selections, selections_to_run, selections_by_name, ordered_result_keys, inlined_fragments: nil)
           selections.each do |node|
             if node.is_a?(GraphQL::Language::Nodes::Field)
               response_key = node.alias || node.name
@@ -271,14 +271,14 @@ module GraphQL
                   )
 
                   if query.types.possible_types(type_defn).include?(owner_type)
-                    result = gather_selections(graphql_response, owner_object, owner_type, node.selections, selections_to_run, next_selections, ordered_result_keys)
+                    result = gather_selections(graphql_response, owner_object, owner_type, node.selections, selections_to_run, next_selections, ordered_result_keys, inlined_fragments: inlined_fragments)
                     if !result.equal?(next_selections)
                       selections_to_run = result
                     end
                   end
                 else
                   # it's an untyped fragment, definitely continue
-                  result = gather_selections(graphql_response, owner_object, owner_type, node.selections, selections_to_run, next_selections, ordered_result_keys)
+                  result = gather_selections(graphql_response, owner_object, owner_type, node.selections, selections_to_run, next_selections, ordered_result_keys, inlined_fragments: inlined_fragments)
                   if !result.equal?(next_selections)
                     selections_to_run = result
                   end
@@ -286,8 +286,12 @@ module GraphQL
               when GraphQL::Language::Nodes::FragmentSpread
                 fragment_def = query.fragments[node.name]
                 type_defn = query.types.type(fragment_def.type.name)
-                if query.types.possible_types(type_defn).include?(owner_type)
-                  result = gather_selections(graphql_response, owner_object, owner_type, fragment_def.selections, selections_to_run, next_selections, ordered_result_keys)
+                # Spreading the same fragment again into these selections adds nothing, so only gather it once.
+                inlined_fragments ||= {}.compare_by_identity
+                inlined_names = (inlined_fragments[next_selections] ||= {})
+                if !inlined_names.key?(node.name) && query.types.possible_types(type_defn).include?(owner_type)
+                  inlined_names[node.name] = true
+                  result = gather_selections(graphql_response, owner_object, owner_type, fragment_def.selections, selections_to_run, next_selections, ordered_result_keys, inlined_fragments: inlined_fragments)
                   if !result.equal?(next_selections)
                     selections_to_run = result
                   end

data/lib/graphql/execution/lookahead.rb

@@ -344,7 +344,7 @@ module GraphQL
         false
       end
 
-      def find_selections(subselections_by_type, selections_on_type, selected_type, ast_selections, arguments)
+      def find_selections(subselections_by_type, selections_on_type, selected_type, ast_selections, arguments, inlined_fragments: nil)
         ast_selections.each do |ast_selection|
           next if skipped_by_directive?(ast_selection)
 
@@ -369,13 +369,19 @@ module GraphQL
               on_type = @query.types.type(t.name)
               subselections_on_type = subselections_by_type[on_type] ||= {}
             end
-            find_selections(subselections_by_type, subselections_on_type, on_type, ast_selection.selections, arguments)
+            find_selections(subselections_by_type, subselections_on_type, on_type, ast_selection.selections, arguments, inlined_fragments: inlined_fragments)
           when GraphQL::Language::Nodes::FragmentSpread
             frag_defn = lookup_fragment(ast_selection)
             # Again, assuming a valid AST
             on_type = @query.types.type(frag_defn.type.name)
             subselections_on_type = subselections_by_type[on_type] ||= {}
-            find_selections(subselections_by_type, subselections_on_type, on_type, frag_defn.selections, arguments)
+            # Spreading the same fragment again into these selections adds nothing, so only find its selections once.
+            inlined_fragments ||= {}.compare_by_identity
+            inlined_names = (inlined_fragments[subselections_on_type] ||= {})
+            if !inlined_names.key?(ast_selection.name)
+              inlined_names[ast_selection.name] = true
+              find_selections(subselections_by_type, subselections_on_type, on_type, frag_defn.selections, arguments, inlined_fragments: inlined_fragments)
+            end
           else
             raise "Invariant: Unexpected selection type: #{ast_selection.class}"
           end
@@ -384,7 +390,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:, alias_name: NOT_CONFIGURED)
+      def find_selected_nodes(node, field_name, field_defn, arguments:, matches:, alias_name: NOT_CONFIGURED, inlined_fragments: nil)
         return if skipped_by_directive?(node)
         case node
         when GraphQL::Language::Nodes::Field
@@ -397,10 +403,14 @@ module GraphQL
             end
           end
         when GraphQL::Language::Nodes::InlineFragment
-          node.selections.each { |s| find_selected_nodes(s, field_name, field_defn, arguments: arguments, matches: matches, alias_name: alias_name) }
+          node.selections.each { |s| find_selected_nodes(s, field_name, field_defn, arguments: arguments, matches: matches, alias_name: alias_name, inlined_fragments: inlined_fragments) }
         when GraphQL::Language::Nodes::FragmentSpread
-          frag_defn = lookup_fragment(node)
-          frag_defn.selections.each { |s| find_selected_nodes(s, field_name, field_defn, arguments: arguments, matches: matches, alias_name: alias_name) }
+          # A fragment spread again would only add the same nodes, so only search it once.
+          if inlined_fragments.nil? || !inlined_fragments.key?(node.name)
+            (inlined_fragments ||= {})[node.name] = true
+            frag_defn = lookup_fragment(node)
+            frag_defn.selections.each { |s| find_selected_nodes(s, field_name, field_defn, arguments: arguments, matches: matches, alias_name: alias_name, inlined_fragments: inlined_fragments) }
+          end
         else
           raise "Unexpected selection comparison on #{node.class.name} (#{node})"
         end
@@ -425,9 +435,10 @@ module GraphQL
 
         next_nodes = []
         field_name = field_defn.name
+        inlined_fragments = {}
         @ast_nodes.each do |ast_node|
           ast_node.selections.each do |selection|
-            find_selected_nodes(selection, field_name, field_defn, arguments: arguments, matches: next_nodes, alias_name: alias_name)
+            find_selected_nodes(selection, field_name, field_defn, arguments: arguments, matches: next_nodes, alias_name: alias_name, inlined_fragments: inlined_fragments)
           end
         end
 

data/lib/graphql/execution/next.rb

@@ -2,6 +2,7 @@
 # typed: true
 require "graphql/execution/prepare_object_step"
 require "graphql/execution/input_values"
+require "graphql/execution/variable_values"
 require "graphql/execution/field_resolve_step"
 require "graphql/execution/finalize"
 require "graphql/execution/load_argument_step"

data/lib/graphql/execution/runner.rb

@@ -12,9 +12,6 @@ module GraphQL
         @selected_operation = nil
         @dataloader = multiplex.context[:dataloader] ||= @schema.dataloader_class.new
         @resolves_lazies = @schema.resolves_lazies?
-        @input_values = Hash.new do |h, query|
-          h[query] = InputValues.new(query, self)
-        end.compare_by_identity
 
         @runtime_directives = nil #: Hash[String, singleton(GraphQL::Schema::Directive)]?
         @schema.directives.each do |name, dir_class|
@@ -53,7 +50,7 @@ module GraphQL
         @dataloader.append_job(step)
       end
 
-      attr_reader :schema, :variables, :dataloader, :resolves_lazies, :authorizes, :static_type_at, :runtime_type_at, :finalizers, :input_values
+      attr_reader :schema, :variables, :dataloader, :resolves_lazies, :authorizes, :static_type_at, :runtime_type_at, :finalizers
 
       # **Returns**
       #
@@ -95,11 +92,15 @@ module GraphQL
 
           results = {}.compare_by_identity
           queries.each do |query|
-            if query.validate && !query.valid?
+            # `valid?` also covers variable, operation name and analysis errors, which apply even with `validate: false`.
+            if !query.valid? || !query.context.errors.empty?
               results[query] = {
                 "errors" => query.static_errors.map(&:to_h)
               }
               next
+            elsif query.selected_operation.nil?
+              results[query] = {}
+              next
             end
 
             root_type = query.root_type
@@ -176,7 +177,7 @@ module GraphQL
         Fiber[:__graphql_current_multiplex] = previous_multiplex
       end
 
-      def gather_selections(type_defn, ast_selections, selections_step, query, all_selections, prototype_result, into:)
+      def gather_selections(type_defn, ast_selections, selections_step, query, all_selections, prototype_result, into:, inlined_fragments: nil)
         ast_selections.each do |ast_selection|
           next if !directives_include?(query, ast_selection)
 
@@ -201,7 +202,7 @@ module GraphQL
                 all_selections << (into = { __node: ast_selection })
                 all_selections << (prototype_result = {})
               end
-              gather_selections(type_defn, ast_selection.selections, selections_step, query, all_selections, prototype_result, into: into)
+              gather_selections(type_defn, ast_selection.selections, selections_step, query, all_selections, prototype_result, into: into, inlined_fragments: inlined_fragments)
             end
           when GraphQL::Language::Nodes::FragmentSpread
             fragment_definition = query.fragments[ast_selection.name]
@@ -211,7 +212,13 @@ module GraphQL
                 all_selections << (into = { __node: ast_selection })
                 all_selections << (prototype_result = {})
               end
-              gather_selections(type_defn, fragment_definition.selections, selections_step, query, all_selections, prototype_result, into: into)
+              # Spreading the same fragment again into these selections adds nothing, so only gather it once.
+              inlined_fragments ||= {}.compare_by_identity
+              inlined_names = (inlined_fragments[into] ||= {})
+              if !inlined_names.key?(ast_selection.name)
+                inlined_names[ast_selection.name] = true
+                gather_selections(type_defn, fragment_definition.selections, selections_step, query, all_selections, prototype_result, into: into, inlined_fragments: inlined_fragments)
+              end
             end
           else
             raise ArgumentError, "Unsupported graphql selection node: #{ast_selection.class} (#{ast_selection.inspect})"
@@ -285,7 +292,7 @@ module GraphQL
             continue_execution = true #: bool
             query_dirs.each do |dir_node|
               dir_defn = runtime_directives[dir_node.name] || raise(GraphQL::Error, "No directive definition found for: #{dir_node.name.inspect}")
-              dir_args, errors = input_values[query].argument_values(dir_defn, dir_node.arguments, nil) # rubocop:disable Development/ContextIsPassedCop
+              dir_args, errors = query.input_values.argument_values(dir_defn, dir_node.arguments, nil) # rubocop:disable Development/ContextIsPassedCop
               if errors
                 errors.each { |e|
                   e.ast_node = dir_node
@@ -412,14 +419,14 @@ module GraphQL
         if ast_selection.directives.any? { |dir_node|
               case dir_node.name
               when "skip"
-                skip_args, _errors = @input_values[query].argument_values(GraphQL::Schema::Directive::Skip, dir_node.arguments, nil) # rubocop:disable Development/ContextIsPassedCop
+                skip_args, _errors = query.input_values.argument_values(GraphQL::Schema::Directive::Skip, dir_node.arguments, nil) # rubocop:disable Development/ContextIsPassedCop
                 skip_args[:if] == true
               when "include"
-                include_args, _errors = @input_values[query].argument_values(GraphQL::Schema::Directive::Include, dir_node.arguments, nil) # rubocop:disable Development/ContextIsPassedCop
+                include_args, _errors = query.input_values.argument_values(GraphQL::Schema::Directive::Include, dir_node.arguments, nil) # rubocop:disable Development/ContextIsPassedCop
                 include_args[:if] == false
               else
                 dir_defn = runtime_directives[dir_node.name]
-                dir_args, _errors = @input_values[query].argument_values(dir_defn, dir_node.arguments, nil) # rubocop:disable Development/ContextIsPassedCop
+                dir_args, _errors = query.input_values.argument_values(dir_defn, dir_node.arguments, nil) # rubocop:disable Development/ContextIsPassedCop
                 !dir_defn.include?(nil, dir_args, query.context)
               end
             }

data/lib/graphql/execution/selections_step.rb

@@ -43,7 +43,7 @@ module GraphQL
             directives.each do |dir_node|
               dir_defn = @runner.runtime_directives[dir_node.name]
               if dir_defn # not present for `skip` or `include`
-                dir_args, _errors = @runner.input_values[query].argument_values(dir_defn, dir_node.arguments, nil) # rubocop:disable Development/ContextIsPassedCop
+                dir_args, _errors = query.input_values.argument_values(dir_defn, dir_node.arguments, nil) # rubocop:disable Development/ContextIsPassedCop
                 result = case directives_owner
                 when Language::Nodes::FragmentSpread
                   dir_defn.resolve_fragment_spread(directives_owner, @parent_type, @objects, dir_args, self.query.context)