graphql 2.0.27 → 2.1.3

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

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require "graphql/execution/interpreter/runtime/graphql_result"
 
 module GraphQL
   module Execution
@@ -15,171 +16,11 @@ module GraphQL
             @current_arguments = nil
             @current_result_name = nil
             @current_result = nil
+            @was_authorized_by_scope_items = nil
           end
 
           attr_accessor :current_result, :current_result_name,
-            :current_arguments, :current_field, :current_object
-        end
-
-        module GraphQLResult
-          def initialize(result_name, parent_result, is_non_null_in_parent)
-            @graphql_parent = parent_result
-            if parent_result && parent_result.graphql_dead
-              @graphql_dead = true
-            end
-            @graphql_result_name = result_name
-            @graphql_is_non_null_in_parent = is_non_null_in_parent
-            # Jump through some hoops to avoid creating this duplicate storage if at all possible.
-            @graphql_metadata = nil
-          end
-
-          def path
-            @path ||= build_path([])
-          end
-
-          def build_path(path_array)
-            graphql_result_name && path_array.unshift(graphql_result_name)
-            @graphql_parent ? @graphql_parent.build_path(path_array) : path_array
-          end
-
-          attr_accessor :graphql_dead
-          attr_reader :graphql_parent, :graphql_result_name, :graphql_is_non_null_in_parent
-
-          # @return [Hash] Plain-Ruby result data (`@graphql_metadata` contains Result wrapper objects)
-          attr_accessor :graphql_result_data
-        end
-
-        class GraphQLResultHash
-          def initialize(_result_name, _parent_result, _is_non_null_in_parent)
-            super
-            @graphql_result_data = {}
-          end
-
-          include GraphQLResult
-
-          attr_accessor :graphql_merged_into
-
-          def set_leaf(key, value)
-            # This is a hack.
-            # Basically, this object is merged into the root-level result at some point.
-            # But the problem is, some lazies are created whose closures retain reference to _this_
-            # object. When those lazies are resolved, they cause an update to this object.
-            #
-            # In order to return a proper top-level result, we have to update that top-level result object.
-            # In order to return a proper partial result (eg, for a directive), we have to update this object, too.
-            # Yowza.
-            if (t = @graphql_merged_into)
-              t.set_leaf(key, value)
-            end
-
-            @graphql_result_data[key] = value
-            # keep this up-to-date if it's been initialized
-            @graphql_metadata && @graphql_metadata[key] = value
-
-            value
-          end
-
-          def set_child_result(key, value)
-            if (t = @graphql_merged_into)
-              t.set_child_result(key, value)
-            end
-            @graphql_result_data[key] = value.graphql_result_data
-            # If we encounter some part of this response that requires metadata tracking,
-            # then create the metadata hash if necessary. It will be kept up-to-date after this.
-            (@graphql_metadata ||= @graphql_result_data.dup)[key] = value
-            value
-          end
-
-          def delete(key)
-            @graphql_metadata && @graphql_metadata.delete(key)
-            @graphql_result_data.delete(key)
-          end
-
-          def each
-            (@graphql_metadata || @graphql_result_data).each { |k, v| yield(k, v) }
-          end
-
-          def values
-            (@graphql_metadata || @graphql_result_data).values
-          end
-
-          def key?(k)
-            @graphql_result_data.key?(k)
-          end
-
-          def [](k)
-            (@graphql_metadata || @graphql_result_data)[k]
-          end
-
-          def merge_into(into_result)
-            self.each do |key, value|
-              case value
-              when GraphQLResultHash
-                next_into = into_result[key]
-                if next_into
-                  value.merge_into(next_into)
-                else
-                  into_result.set_child_result(key, value)
-                end
-              when GraphQLResultArray
-                # There's no special handling of arrays because currently, there's no way to split the execution
-                # of a list over several concurrent flows.
-                next_result.set_child_result(key, value)
-              else
-                # We have to assume that, since this passed the `fields_will_merge` selection,
-                # that the old and new values are the same.
-                into_result.set_leaf(key, value)
-              end
-            end
-            @graphql_merged_into = into_result
-          end
-        end
-
-        class GraphQLResultArray
-          include GraphQLResult
-
-          def initialize(_result_name, _parent_result, _is_non_null_in_parent)
-            super
-            @graphql_result_data = []
-          end
-
-          def graphql_skip_at(index)
-            # Mark this index as dead. It's tricky because some indices may already be storing
-            # `Lazy`s. So the runtime is still holding indexes _before_ skipping,
-            # this object has to coordinate incoming writes to account for any already-skipped indices.
-            @skip_indices ||= []
-            @skip_indices << index
-            offset_by = @skip_indices.count { |skipped_idx| skipped_idx < index}
-            delete_at_index = index - offset_by
-            @graphql_metadata && @graphql_metadata.delete_at(delete_at_index)
-            @graphql_result_data.delete_at(delete_at_index)
-          end
-
-          def set_leaf(idx, value)
-            if @skip_indices
-              offset_by = @skip_indices.count { |skipped_idx| skipped_idx < idx }
-              idx -= offset_by
-            end
-            @graphql_result_data[idx] = value
-            @graphql_metadata && @graphql_metadata[idx] = value
-            value
-          end
-
-          def set_child_result(idx, value)
-            if @skip_indices
-              offset_by = @skip_indices.count { |skipped_idx| skipped_idx < idx }
-              idx -= offset_by
-            end
-            @graphql_result_data[idx] = value.graphql_result_data
-            # If we encounter some part of this response that requires metadata tracking,
-            # then create the metadata hash if necessary. It will be kept up-to-date after this.
-            (@graphql_metadata ||= @graphql_result_data.dup)[idx] = value
-            value
-          end
-
-          def values
-            (@graphql_metadata || @graphql_result_data)
-          end
+            :current_arguments, :current_field, :current_object, :was_authorized_by_scope_items
         end
 
         # @return [GraphQL::Query]
@@ -208,15 +49,16 @@ module GraphQL
               @runtime_directive_names << name
             end
           end
-          # A cache of { Class => { String => Schema::Field } }
-          # Which assumes that MyObject.get_field("myField") will return the same field
-          # during the lifetime of a query
-          @fields_cache = Hash.new { |h, k| h[k] = {} }
-          # this can by by-identity since owners are the same object, but not the sub-hash, which uses strings.
-          @fields_cache.compare_by_identity
           # { Class => Boolean }
           @lazy_cache = {}
           @lazy_cache.compare_by_identity
+
+          @gathered_selections_cache = Hash.new { |h, k|
+            cache = {}
+            cache.compare_by_identity
+            h[k] = cache
+          }
+          @gathered_selections_cache.compare_by_identity
         end
 
         def final_result
@@ -244,6 +86,7 @@ module GraphQL
           root_operation = query.selected_operation
           root_op_type = root_operation.operation_type || "query"
           root_type = schema.root_type_for_operation(root_op_type)
+
           st = get_current_runtime_state
           st.current_object = query.root_value
           st.current_result = @response
@@ -255,7 +98,7 @@ module GraphQL
             @response = nil
           else
             call_method_on_directives(:resolve, runtime_object, root_operation.directives) do # execute query level directives
-              gathered_selections = gather_selections(runtime_object, root_type, root_operation.selections)
+              gathered_selections = gather_selections(runtime_object, root_type, nil, root_operation.selections)
               # This is kind of a hack -- `gathered_selections` is an Array if any of the selections
               # require isolation during execution (because of runtime directives). In that case,
               # make a new, isolated result hash for writing the result into. (That isolated response
@@ -275,6 +118,7 @@ module GraphQL
                 @dataloader.append_job {
                   st = get_current_runtime_state
                   st.current_object = query.root_value
+                  st.current_result_name = nil
                   st.current_result = selection_response
                   # This is a less-frequent case; use a fast check since it's often not there.
                   if (directives = selections[:graphql_directives])
@@ -289,20 +133,28 @@ module GraphQL
                       selection_response,
                       final_response,
                       nil,
+                      st,
                     )
                   end
                 }
               end
             end
           end
-          delete_all_interpreter_context
           nil
         end
 
-        def gather_selections(owner_object, owner_type, selections, selections_to_run = nil, selections_by_name = {})
+        def gather_selections(owner_object, owner_type, ast_node_for_caching, selections, selections_to_run = nil, selections_by_name = nil)
+          if ast_node_for_caching && (cached_selections = @gathered_selections_cache[ast_node_for_caching][owner_type])
+            return cached_selections
+          end
+          selections_by_name ||= {} # allocate this default here so we check the cache first
+
+          should_cache = true
+
           selections.each do |node|
             # Skip gathering this if the directive says so
             if !directives_include?(node, owner_object, owner_type)
+              should_cache = false
               next
             end
 
@@ -327,6 +179,7 @@ module GraphQL
               if @runtime_directive_names.any? && node.directives.any? { |d| @runtime_directive_names.include?(d.name) }
                 next_selections = {}
                 next_selections[:graphql_directives] = node.directives
+                should_cache = false
                 if selections_to_run
                   selections_to_run << next_selections
                 else
@@ -344,41 +197,41 @@ module GraphQL
                   type_defn = schema.get_type(node.type.name, context)
 
                   if query.warden.possible_types(type_defn).include?(owner_type)
-                    gather_selections(owner_object, owner_type, node.selections, selections_to_run, next_selections)
+                    gather_selections(owner_object, owner_type, nil, node.selections, selections_to_run, next_selections)
                   end
                 else
                   # it's an untyped fragment, definitely continue
-                  gather_selections(owner_object, owner_type, node.selections, selections_to_run, next_selections)
+                  gather_selections(owner_object, owner_type, nil, node.selections, selections_to_run, next_selections)
                 end
               when GraphQL::Language::Nodes::FragmentSpread
                 fragment_def = query.fragments[node.name]
                 type_defn = query.get_type(fragment_def.type.name)
                 if query.warden.possible_types(type_defn).include?(owner_type)
-                  gather_selections(owner_object, owner_type, fragment_def.selections, selections_to_run, next_selections)
+                  gather_selections(owner_object, owner_type, nil, fragment_def.selections, selections_to_run, next_selections)
                 end
               else
                 raise "Invariant: unexpected selection class: #{node.class}"
               end
             end
           end
-          selections_to_run || selections_by_name
+          result = selections_to_run || selections_by_name
+          if should_cache
+            @gathered_selections_cache[ast_node_for_caching][owner_type] = result
+          end
+          result
         end
 
         NO_ARGS = GraphQL::EmptyObjects::EMPTY_HASH
 
         # @return [void]
-        def evaluate_selections(owner_object, owner_type, is_eager_selection, gathered_selections, selections_result, target_result, parent_object) # rubocop:disable Metrics/ParameterLists
-          st = get_current_runtime_state
-          st.current_object = owner_object
-          st.current_result_name = nil
-          st.current_result = selections_result
-
+        def evaluate_selections(owner_object, owner_type, is_eager_selection, gathered_selections, selections_result, target_result, parent_object, runtime_state) # rubocop:disable Metrics/ParameterLists
           finished_jobs = 0
           enqueued_jobs = gathered_selections.size
           gathered_selections.each do |result_name, field_ast_nodes_or_ast_node|
             @dataloader.append_job {
+              runtime_state = get_current_runtime_state
               evaluate_selection(
-                result_name, field_ast_nodes_or_ast_node, owner_object, owner_type, is_eager_selection, selections_result, parent_object
+                result_name, field_ast_nodes_or_ast_node, owner_object, owner_type, is_eager_selection, selections_result, parent_object, runtime_state
               )
               finished_jobs += 1
               if target_result && finished_jobs == enqueued_jobs
@@ -389,7 +242,9 @@ module GraphQL
             # so it wouldn't get to the `Resolve` call that happens below.
             # So instead trigger a run from this outer context.
             if is_eager_selection
+              @dataloader.clear_cache
               @dataloader.run
+              @dataloader.clear_cache
             end
           end
 
@@ -397,7 +252,7 @@ module GraphQL
         end
 
         # @return [void]
-        def evaluate_selection(result_name, field_ast_nodes_or_ast_node, owner_object, owner_type, is_eager_field, selections_result, parent_object) # rubocop:disable Metrics/ParameterLists
+        def evaluate_selection(result_name, field_ast_nodes_or_ast_node, owner_object, owner_type, is_eager_field, selections_result, parent_object, runtime_state) # rubocop:disable Metrics/ParameterLists
           return if dead_result?(selections_result)
           # As a performance optimization, the hash key will be a `Node` if
           # there's only one selection of the field. But if there are multiple
@@ -410,57 +265,38 @@ module GraphQL
             ast_node = field_ast_nodes_or_ast_node
           end
           field_name = ast_node.name
-          # This can't use `query.get_field` because it gets confused on introspection below if `field_defn` isn't `nil`,
-          # because of how `is_introspection` is used to call `.authorized_new` later on.
-          field_defn = @fields_cache[owner_type][field_name] ||= owner_type.get_field(field_name, @context)
-          is_introspection = false
-          if field_defn.nil?
-            field_defn = if owner_type == schema.query && (entry_point_field = schema.introspection_system.entry_point(name: field_name))
-              is_introspection = true
-              entry_point_field
-            elsif (dynamic_field = schema.introspection_system.dynamic_field(name: field_name))
-              is_introspection = true
-              dynamic_field
-            else
-              raise "Invariant: no field for #{owner_type}.#{field_name}"
-            end
-          end
+          field_defn = query.warden.get_field(owner_type, field_name)
 
-          return_type = field_defn.type
-
-          # This seems janky, but we need to know
-          # the field's return type at this path in order
-          # to propagate `null`
-          return_type_non_null = return_type.non_null?
           # Set this before calling `run_with_directives`, so that the directive can have the latest path
-          st = get_current_runtime_state
-          st.current_field = field_defn
-          st.current_result = selections_result
-          st.current_result_name = result_name
+          runtime_state.current_field = field_defn
+          runtime_state.current_result = selections_result
+          runtime_state.current_result_name = result_name
 
-          if is_introspection
+          if field_defn.dynamic_introspection
             owner_object = field_defn.owner.wrap(owner_object, context)
           end
 
-          total_args_count = field_defn.arguments(context).size
-          if total_args_count == 0
+          return_type = field_defn.type
+          if !field_defn.any_arguments?
             resolved_arguments = GraphQL::Execution::Interpreter::Arguments::EMPTY
             if field_defn.extras.size == 0
               evaluate_selection_with_resolved_keyword_args(
-                NO_ARGS, resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_type, owner_object, is_eager_field, result_name, selections_result, parent_object, return_type, return_type_non_null
+                NO_ARGS, resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_type, owner_object, is_eager_field, result_name, selections_result, parent_object, return_type, return_type.non_null?, runtime_state
               )
             else
-              evaluate_selection_with_args(resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_type, owner_object, is_eager_field, result_name, selections_result, parent_object, return_type, return_type_non_null)
+              evaluate_selection_with_args(resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_type, owner_object, is_eager_field, result_name, selections_result, parent_object, return_type, runtime_state)
             end
           else
             @query.arguments_cache.dataload_for(ast_node, field_defn, owner_object) do |resolved_arguments|
-              evaluate_selection_with_args(resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_type, owner_object, is_eager_field, result_name, selections_result, parent_object, return_type, return_type_non_null)
+              runtime_state = get_current_runtime_state # This might be in a different fiber
+              evaluate_selection_with_args(resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_type, owner_object, is_eager_field, result_name, selections_result, parent_object, return_type, runtime_state)
             end
           end
         end
 
-        def evaluate_selection_with_args(arguments, field_defn, ast_node, field_ast_nodes, owner_type, object, is_eager_field, result_name, selection_result, parent_object, return_type, return_type_non_null)  # rubocop:disable Metrics/ParameterLists
-          after_lazy(arguments, field: field_defn, ast_node: ast_node, owner_object: object, arguments: arguments, result_name: result_name, result: selection_result) do |resolved_arguments|
+        def evaluate_selection_with_args(arguments, field_defn, ast_node, field_ast_nodes, owner_type, object, is_eager_field, result_name, selection_result, parent_object, return_type, runtime_state)  # rubocop:disable Metrics/ParameterLists
+          after_lazy(arguments, field: field_defn, ast_node: ast_node, owner_object: object, arguments: arguments, result_name: result_name, result: selection_result, runtime_state: runtime_state) do |resolved_arguments, runtime_state|
+            return_type_non_null = return_type.non_null?
             if resolved_arguments.is_a?(GraphQL::ExecutionError) || resolved_arguments.is_a?(GraphQL::UnauthorizedError)
               continue_value(resolved_arguments, owner_type, field_defn, return_type_non_null, ast_node, result_name, selection_result)
               next
@@ -511,17 +347,16 @@ module GraphQL
               resolved_arguments.keyword_arguments
             end
 
-            evaluate_selection_with_resolved_keyword_args(kwarg_arguments, resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_type, object, is_eager_field, result_name, selection_result, parent_object, return_type, return_type_non_null)
+            evaluate_selection_with_resolved_keyword_args(kwarg_arguments, resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_type, object, is_eager_field, result_name, selection_result, parent_object, return_type, return_type_non_null, runtime_state)
           end
         end
 
-        def evaluate_selection_with_resolved_keyword_args(kwarg_arguments, resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_type, object, is_eager_field, result_name, selection_result, parent_object, return_type, return_type_non_null)  # rubocop:disable Metrics/ParameterLists
-          st = get_current_runtime_state
-          st.current_field = field_defn
-          st.current_object = object
-          st.current_arguments = resolved_arguments
-          st.current_result_name = result_name
-          st.current_result = selection_result
+        def evaluate_selection_with_resolved_keyword_args(kwarg_arguments, resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_type, object, is_eager_field, result_name, selection_result, parent_object, return_type, return_type_non_null, runtime_state)  # rubocop:disable Metrics/ParameterLists
+          runtime_state.current_field = field_defn
+          runtime_state.current_object = object
+          runtime_state.current_arguments = resolved_arguments
+          runtime_state.current_result_name = result_name
+          runtime_state.current_result = selection_result
           # Optimize for the case that field is selected only once
           if field_ast_nodes.nil? || field_ast_nodes.size == 1
             next_selections = ast_node.selections
@@ -550,10 +385,12 @@ module GraphQL
                 ex_err
               end
             end
-            after_lazy(app_result, field: field_defn, ast_node: ast_node, owner_object: object, arguments: resolved_arguments, result_name: result_name, result: selection_result) do |inner_result|
+            after_lazy(app_result, field: field_defn, ast_node: ast_node, owner_object: object, arguments: resolved_arguments, result_name: result_name, result: selection_result, runtime_state: runtime_state) do |inner_result, runtime_state|
               continue_value = continue_value(inner_result, owner_type, field_defn, return_type_non_null, ast_node, result_name, selection_result)
               if HALT != continue_value
-                continue_field(continue_value, owner_type, field_defn, return_type, ast_node, next_selections, false, object, resolved_arguments, result_name, selection_result)
+                was_scoped = runtime_state.was_authorized_by_scope_items
+                runtime_state.was_authorized_by_scope_items = nil
+                continue_field(continue_value, owner_type, field_defn, return_type, ast_node, next_selections, false, object, resolved_arguments, result_name, selection_result, was_scoped, runtime_state)
               end
             end
           end
@@ -733,7 +570,7 @@ module GraphQL
         # Location information from `path` and `ast_node`.
         #
         # @return [Lazy, Array, Hash, Object] Lazy, Array, and Hash are all traversed to resolve lazy values later
-        def continue_field(value, owner_type, field, current_type, ast_node, next_selections, is_non_null, owner_object, arguments, result_name, selection_result) # rubocop:disable Metrics/ParameterLists
+        def continue_field(value, owner_type, field, current_type, ast_node, next_selections, is_non_null, owner_object, arguments, result_name, selection_result, was_scoped, runtime_state) # rubocop:disable Metrics/ParameterLists
           if current_type.non_null?
             current_type = current_type.of_type
             is_non_null = true
@@ -750,7 +587,7 @@ module GraphQL
             r
           when "UNION", "INTERFACE"
             resolved_type_or_lazy = resolve_type(current_type, value)
-            after_lazy(resolved_type_or_lazy, ast_node: ast_node, field: field, owner_object: owner_object, arguments: arguments, trace: false, result_name: result_name, result: selection_result) do |resolved_type_result|
+            after_lazy(resolved_type_or_lazy, ast_node: ast_node, field: field, owner_object: owner_object, arguments: arguments, trace: false, result_name: result_name, result: selection_result, runtime_state: runtime_state) do |resolved_type_result, runtime_state|
               if resolved_type_result.is_a?(Array) && resolved_type_result.length == 2
                 resolved_type, resolved_value = resolved_type_result
               else
@@ -767,21 +604,22 @@ module GraphQL
                 set_result(selection_result, result_name, nil, false, is_non_null)
                 nil
               else
-                continue_field(resolved_value, owner_type, field, resolved_type, ast_node, next_selections, is_non_null, owner_object, arguments, result_name, selection_result)
+                continue_field(resolved_value, owner_type, field, resolved_type, ast_node, next_selections, is_non_null, owner_object, arguments, result_name, selection_result, was_scoped, runtime_state)
               end
             end
           when "OBJECT"
             object_proxy = begin
-              current_type.wrap(value, context)
+              was_scoped ? current_type.wrap_scoped(value, context) : current_type.wrap(value, context)
             rescue GraphQL::ExecutionError => err
               err
             end
-            after_lazy(object_proxy, ast_node: ast_node, field: field, owner_object: owner_object, arguments: arguments, trace: false, result_name: result_name, result: selection_result) do |inner_object|
+            after_lazy(object_proxy, ast_node: ast_node, field: field, owner_object: owner_object, arguments: arguments, trace: false, result_name: result_name, result: selection_result, runtime_state: runtime_state) do |inner_object, runtime_state|
               continue_value = continue_value(inner_object, owner_type, field, is_non_null, ast_node, result_name, selection_result)
               if HALT != continue_value
                 response_hash = GraphQLResultHash.new(result_name, selection_result, is_non_null)
                 set_result(selection_result, result_name, response_hash, true, is_non_null)
-                gathered_selections = gather_selections(continue_value, current_type, next_selections)
+
+                gathered_selections = gather_selections(continue_value, current_type, ast_node, next_selections)
                 # There are two possibilities for `gathered_selections`:
                 # 1. All selections of this object should be evaluated together (there are no runtime directives modifying execution).
                 #    This case is handled below, and the result can be written right into the main `response_hash` above.
@@ -800,11 +638,9 @@ module GraphQL
                   end
                   # reset this mutable state
                   # Unset `result_name` here because it's already included in the new response hash
-                  st = get_current_runtime_state
-                  st.current_object = continue_value
-                  st.current_result_name = nil
-                  st.current_result = this_result
-
+                  runtime_state.current_object = continue_value
+                  runtime_state.current_result_name = nil
+                  runtime_state.current_result = this_result
                   # This is a less-frequent case; use a fast check since it's often not there.
                   if (directives = selections[:graphql_directives])
                     selections.delete(:graphql_directives)
@@ -818,6 +654,7 @@ module GraphQL
                       this_result,
                       final_result,
                       owner_object.object,
+                      runtime_state,
                     )
                     this_result
                   end
@@ -839,10 +676,10 @@ module GraphQL
                 idx += 1
                 if use_dataloader_job
                   @dataloader.append_job do
-                    resolve_list_item(inner_value, inner_type, inner_type_non_null, ast_node, field, owner_object, arguments, this_idx, response_list, next_selections, owner_type)
+                    resolve_list_item(inner_value, inner_type, inner_type_non_null, ast_node, field, owner_object, arguments, this_idx, response_list, next_selections, owner_type, was_scoped, runtime_state)
                   end
                 else
-                  resolve_list_item(inner_value, inner_type, inner_type_non_null, ast_node, field, owner_object, arguments, this_idx, response_list, next_selections, owner_type)
+                  resolve_list_item(inner_value, inner_type, inner_type_non_null, ast_node, field, owner_object, arguments, this_idx, response_list, next_selections, owner_type, was_scoped, runtime_state)
                 end
               end
 
@@ -873,16 +710,15 @@ module GraphQL
           end
         end
 
-        def resolve_list_item(inner_value, inner_type, inner_type_non_null, ast_node, field, owner_object, arguments, this_idx, response_list, next_selections, owner_type) # rubocop:disable Metrics/ParameterLists
-          st = get_current_runtime_state
-          st.current_result_name = this_idx
-          st.current_result = response_list
+        def resolve_list_item(inner_value, inner_type, inner_type_non_null, ast_node, field, owner_object, arguments, this_idx, response_list, next_selections, owner_type, was_scoped, runtime_state) # rubocop:disable Metrics/ParameterLists
+          runtime_state.current_result_name = this_idx
+          runtime_state.current_result = response_list
           call_method_on_directives(:resolve_each, owner_object, ast_node.directives) do
             # This will update `response_list` with the lazy
-            after_lazy(inner_value, ast_node: ast_node, field: field, owner_object: owner_object, arguments: arguments, result_name: this_idx, result: response_list) do |inner_inner_value|
+            after_lazy(inner_value, ast_node: ast_node, field: field, owner_object: owner_object, arguments: arguments, result_name: this_idx, result: response_list, runtime_state: runtime_state) do |inner_inner_value, runtime_state|
               continue_value = continue_value(inner_inner_value, owner_type, field, inner_type_non_null, ast_node, this_idx, response_list)
               if HALT != continue_value
-                continue_field(continue_value, owner_type, field, inner_type, ast_node, next_selections, false, owner_object, arguments, this_idx, response_list)
+                continue_field(continue_value, owner_type, field, inner_type, ast_node, next_selections, false, owner_object, arguments, this_idx, response_list, was_scoped, runtime_state)
               end
             end
           end
@@ -959,16 +795,21 @@ module GraphQL
         # @param eager [Boolean] Set to `true` for mutation root fields only
         # @param trace [Boolean] If `false`, don't wrap this with field tracing
         # @return [GraphQL::Execution::Lazy, Object] If loading `object` will be deferred, it's a wrapper over it.
-        def after_lazy(lazy_obj, field:, owner_object:, arguments:, ast_node:, result:, result_name:, eager: false, trace: true, &block)
+        def after_lazy(lazy_obj, field:, owner_object:, arguments:, ast_node:, result:, result_name:, eager: false, runtime_state:, trace: true, &block)
           if lazy?(lazy_obj)
             orig_result = result
+            was_authorized_by_scope_items = runtime_state.was_authorized_by_scope_items
             lazy = GraphQL::Execution::Lazy.new(field: field) do
-              st = get_current_runtime_state
-              st.current_object = owner_object
-              st.current_field = field
-              st.current_arguments = arguments
-              st.current_result_name = result_name
-              st.current_result = orig_result
+              # This block might be called in a new fiber;
+              # In that case, this will initialize a new state
+              # to avoid conflicting with the parent fiber.
+              runtime_state = get_current_runtime_state
+              runtime_state.current_object = owner_object
+              runtime_state.current_field = field
+              runtime_state.current_arguments = arguments
+              runtime_state.current_result_name = result_name
+              runtime_state.current_result = orig_result
+              runtime_state.was_authorized_by_scope_items = was_authorized_by_scope_items
               # Wrap the execution of _this_ method with tracing,
               # but don't wrap the continuation below
               inner_obj = begin
@@ -988,7 +829,7 @@ module GraphQL
                   ex_err
                 end
               end
-              yield(inner_obj)
+              yield(inner_obj, runtime_state)
             end
 
             if eager
@@ -1005,7 +846,7 @@ module GraphQL
             end
           else
             # Don't need to reset state here because it _wasn't_ lazy.
-            yield(lazy_obj)
+            yield(lazy_obj, runtime_state)
           end
         end
 

data/lib/graphql/execution/interpreter.rb

@@ -98,12 +98,6 @@ module GraphQL
                     multiplex.current_trace.execute_query_lazy(multiplex: multiplex, query: query) do
                       Interpreter::Resolve.resolve_each_depth(lazies_at_depth, multiplex.dataloader)
                     end
-                    queries.each do |query|
-                      runtime = query.context.namespace(:interpreter_runtime)[:runtime]
-                      if runtime
-                        runtime.delete_all_interpreter_context
-                      end
-                    end
                   }
                   multiplex.dataloader.run
 

data/lib/graphql/execution/lookahead.rb

@@ -102,7 +102,7 @@ module GraphQL
             @query.warden
               .possible_types(selected_type)
               .map { |t| @query.warden.fields(t) }
-              .flatten
+              .tap(&:flatten!)
           end
 
           if (match_by_orig_name = all_fields.find { |f| f.original_name == field_name })

data/lib/graphql/introspection/dynamic_fields.rb

@@ -2,7 +2,7 @@
 module GraphQL
   module Introspection
     class DynamicFields < Introspection::BaseObject
-      field :__typename, String, "The name of this type", null: false
+      field :__typename, String, "The name of this type", null: false, dynamic_introspection: true
 
       def __typename
         object.class.graphql_name

data/lib/graphql/introspection/entry_points.rb

@@ -2,8 +2,8 @@
 module GraphQL
   module Introspection
     class EntryPoints < Introspection::BaseObject
-      field :__schema, GraphQL::Schema::LateBoundType.new("__Schema"), "This GraphQL schema", null: false
-      field :__type, GraphQL::Schema::LateBoundType.new("__Type"), "A type in the GraphQL system" do
+      field :__schema, GraphQL::Schema::LateBoundType.new("__Schema"), "This GraphQL schema", null: false, dynamic_introspection: true
+      field :__type, GraphQL::Schema::LateBoundType.new("__Type"), "A type in the GraphQL system", dynamic_introspection: true do
         argument :name, String
       end