graphql 2.0.16 → 2.0.21

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

@@ -8,6 +8,18 @@ module GraphQL
       #
       # @api private
       class Runtime
+        class CurrentState
+          def initialize
+            @current_object = nil
+            @current_field = nil
+            @current_arguments = nil
+            @current_result_name = nil
+            @current_result = nil
+          end
+
+          attr_accessor :current_result, :current_result_name,
+            :current_arguments, :current_field, :current_object
+        end
 
         module GraphQLResult
           def initialize(result_name, parent_result)
@@ -20,6 +32,15 @@ module GraphQL
             @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
 
@@ -45,7 +66,7 @@ module GraphQL
 
           attr_accessor :graphql_merged_into
 
-          def []=(key, value)
+          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_
@@ -55,23 +76,27 @@ module GraphQL
             # 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[key] = value
+              t.set_leaf(key, value)
             end
 
-            if value.respond_to?(:graphql_result_data)
-              @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
-            else
-              @graphql_result_data[key] = value
-              # keep this up-to-date if it's been initialized
-              @graphql_metadata && @graphql_metadata[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)
@@ -92,6 +117,29 @@ module GraphQL
           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
@@ -114,19 +162,25 @@ module GraphQL
             @graphql_result_data.delete_at(delete_at_index)
           end
 
-          def []=(idx, value)
+          def set_leaf(idx, value)
             if @skip_indices
               offset_by = @skip_indices.count { |skipped_idx| skipped_idx < idx }
               idx -= offset_by
             end
-            if value.respond_to?(:graphql_result_data)
-              @graphql_result_data[idx] = value.graphql_result_data
-              (@graphql_metadata ||= @graphql_result_data.dup)[idx] = value
-            else
-              @graphql_result_data[idx] = value
-              @graphql_metadata && @graphql_metadata[idx] = value
-            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
 
@@ -148,18 +202,10 @@ module GraphQL
         # @return [GraphQL::Query::Context]
         attr_reader :context
 
-        def thread_info
-          info = Thread.current[:__graphql_runtime_info]
-          if !info
-            new_ti = {}
-            info = Thread.current[:__graphql_runtime_info] = new_ti
-          end
-          info
-        end
-
-        def initialize(query:)
+        def initialize(query:, lazies_at_depth:)
           @query = query
           @dataloader = query.multiplex.dataloader
+          @lazies_at_depth = lazies_at_depth
           @schema = query.schema
           @context = query.context
           @multiplex_context = query.multiplex.context
@@ -208,8 +254,9 @@ 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)
-          path = []
-          set_all_interpreter_context(query.root_value, nil, nil, path)
+          st = get_current_runtime_state
+          st.current_object = query.root_value
+          st.current_result = @response
           object_proxy = authorized_new(root_type, query.root_value, context)
           object_proxy = schema.sync_lazy(object_proxy)
 
@@ -236,10 +283,12 @@ module GraphQL
                 end
 
                 @dataloader.append_job {
-                  set_all_interpreter_context(query.root_value, nil, nil, path)
+                  st = get_current_runtime_state
+                  st.current_object = query.root_value
+                  st.current_result = selection_response
+
                   call_method_on_directives(:resolve, object_proxy, selections.graphql_directives) do
                     evaluate_selections(
-                      path,
                       object_proxy,
                       root_type,
                       root_op_type == "mutation",
@@ -253,32 +302,7 @@ module GraphQL
               end
             end
           end
-          delete_interpreter_context(:current_path)
-          delete_interpreter_context(:current_field)
-          delete_interpreter_context(:current_object)
-          delete_interpreter_context(:current_arguments)
-          nil
-        end
-
-        # @return [void]
-        def deep_merge_selection_result(from_result, into_result)
-          from_result.each do |key, value|
-            if !into_result.key?(key)
-              into_result[key] = value
-            else
-              case value
-              when GraphQLResultHash
-                deep_merge_selection_result(value, into_result[key])
-              else
-                # We have to assume that, since this passed the `fields_will_merge` selection,
-                # that the old and new values are the same.
-                # There's no special handling of arrays because currently, there's no way to split the execution
-                # of a list over several concurrent flows.
-                into_result[key] = value
-              end
-            end
-          end
-          from_result.graphql_merged_into = into_result
+          delete_all_interpreter_context
           nil
         end
 
@@ -355,22 +379,25 @@ module GraphQL
           selections_to_run || selections_by_name
         end
 
-        NO_ARGS = {}.freeze
+        NO_ARGS = GraphQL::EmptyObjects::EMPTY_HASH
 
         # @return [void]
-        def evaluate_selections(path, owner_object, owner_type, is_eager_selection, gathered_selections, selections_result, target_result, parent_object) # rubocop:disable Metrics/ParameterLists
-          set_all_interpreter_context(owner_object, nil, nil, path)
+        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
 
           finished_jobs = 0
           enqueued_jobs = gathered_selections.size
           gathered_selections.each do |result_name, field_ast_nodes_or_ast_node|
             @dataloader.append_job {
               evaluate_selection(
-                path, 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
               )
               finished_jobs += 1
               if target_result && finished_jobs == enqueued_jobs
-                deep_merge_selection_result(selections_result, target_result)
+                selections_result.merge_into(target_result)
               end
             }
           end
@@ -378,10 +405,8 @@ module GraphQL
           selections_result
         end
 
-        attr_reader :progress_path
-
         # @return [void]
-        def evaluate_selection(path, 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) # 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
@@ -409,19 +434,22 @@ module GraphQL
               raise "Invariant: no field for #{owner_type}.#{field_name}"
             end
           end
-          return_type = field_defn.type
 
-          next_path = path + [result_name]
-          next_path.freeze
+          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`
-          if return_type.non_null?
+          return_type_non_null = return_type.non_null?
+          if return_type_non_null
             (selections_result.graphql_non_null_field_names ||= []).push(result_name)
           end
           # Set this before calling `run_with_directives`, so that the directive can have the latest path
-          set_all_interpreter_context(nil, field_defn, nil, next_path)
+          st = get_current_runtime_state
+          st.current_field = field_defn
+          st.current_result = selections_result
+          st.current_result_name = result_name
+
           object = owner_object
 
           if is_introspection
@@ -431,26 +459,34 @@ module GraphQL
           total_args_count = field_defn.arguments(context).size
           if total_args_count == 0
             resolved_arguments = GraphQL::Execution::Interpreter::Arguments::EMPTY
-            evaluate_selection_with_args(resolved_arguments, field_defn, next_path, ast_node, field_ast_nodes, owner_type, object, is_eager_field, result_name, selections_result, parent_object)
+            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, object, is_eager_field, result_name, selections_result, parent_object, return_type, return_type_non_null
+              )
+            else
+              evaluate_selection_with_args(resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_type, object, is_eager_field, result_name, selections_result, parent_object, return_type, return_type_non_null)
+            end
           else
-            # TODO remove all arguments(...) usages?
             @query.arguments_cache.dataload_for(ast_node, field_defn, object) do |resolved_arguments|
-              evaluate_selection_with_args(resolved_arguments, field_defn, next_path, ast_node, field_ast_nodes, owner_type, object, is_eager_field, result_name, selections_result, parent_object)
+              evaluate_selection_with_args(resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_type, object, is_eager_field, result_name, selections_result, parent_object, return_type, return_type_non_null)
             end
           end
         end
 
-        def evaluate_selection_with_args(arguments, field_defn, next_path, ast_node, field_ast_nodes, owner_type, object, is_eager_field, result_name, selection_result, parent_object)  # rubocop:disable Metrics/ParameterLists
-          return_type = field_defn.type
-          after_lazy(arguments, owner: owner_type, field: field_defn, path: next_path, 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, return_type_non_null)  # rubocop:disable Metrics/ParameterLists
+          after_lazy(arguments, owner: owner_type, field: field_defn, ast_node: ast_node, owner_object: object, arguments: arguments, result_name: result_name, result: selection_result) do |resolved_arguments|
             if resolved_arguments.is_a?(GraphQL::ExecutionError) || resolved_arguments.is_a?(GraphQL::UnauthorizedError)
-              continue_value(next_path, resolved_arguments, owner_type, field_defn, return_type.non_null?, ast_node, result_name, selection_result)
+              continue_value(resolved_arguments, owner_type, field_defn, return_type_non_null, ast_node, result_name, selection_result)
               next
             end
 
-            kwarg_arguments = if resolved_arguments.empty? && field_defn.extras.empty?
-              # We can avoid allocating the `{ Symbol => Object }` hash in this case
-              NO_ARGS
+            kwarg_arguments = if field_defn.extras.empty?
+              if resolved_arguments.empty?
+                # We can avoid allocating the `{ Symbol => Object }` hash in this case
+                NO_ARGS
+              else
+                resolved_arguments.keyword_arguments
+              end
             else
               # Bundle up the extras, then make a new arguments instance
               # that includes the extras, too.
@@ -460,9 +496,9 @@ module GraphQL
                 when :ast_node
                   extra_args[:ast_node] = ast_node
                 when :execution_errors
-                  extra_args[:execution_errors] = ExecutionErrors.new(context, ast_node, next_path)
+                  extra_args[:execution_errors] = ExecutionErrors.new(context, ast_node, current_path)
                 when :path
-                  extra_args[:path] = next_path
+                  extra_args[:path] = current_path
                 when :lookahead
                   if !field_ast_nodes
                     field_ast_nodes = [ast_node]
@@ -489,61 +525,70 @@ module GraphQL
               resolved_arguments.keyword_arguments
             end
 
-            set_all_interpreter_context(nil, nil, resolved_arguments, nil)
+            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)
+          end
+        end
 
-            # 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
-              directives = ast_node.directives
-            else
-              next_selections = []
-              directives = []
-              field_ast_nodes.each { |f|
-                next_selections.concat(f.selections)
-                directives.concat(f.directives)
-              }
-            end
-
-            field_result = call_method_on_directives(:resolve, object, directives) do
-              # Actually call the field resolver and capture the result
-              app_result = begin
-                query.trace("execute_field", {owner: owner_type, field: field_defn, path: next_path, ast_node: ast_node, query: query, object: object, arguments: kwarg_arguments}) do
-                  field_defn.resolve(object, kwarg_arguments, context)
-                end
-              rescue GraphQL::ExecutionError => err
-                err
-              rescue StandardError => err
-                begin
-                  query.handle_or_reraise(err)
-                rescue GraphQL::ExecutionError => ex_err
-                  ex_err
-                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
+          # 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
+            directives = ast_node.directives
+          else
+            next_selections = []
+            directives = []
+            field_ast_nodes.each { |f|
+              next_selections.concat(f.selections)
+              directives.concat(f.directives)
+            }
+          end
+
+          field_result = call_method_on_directives(:resolve, object, directives) do
+            # Actually call the field resolver and capture the result
+            app_result = begin
+              query.current_trace.execute_field(field: field_defn, ast_node: ast_node, query: query, object: object, arguments: kwarg_arguments) do
+                field_defn.resolve(object, kwarg_arguments, context)
               end
-              after_lazy(app_result, owner: owner_type, field: field_defn, path: next_path, ast_node: ast_node, owner_object: object, arguments: resolved_arguments, result_name: result_name, result: selection_result) do |inner_result|
-                continue_value = continue_value(next_path, inner_result, owner_type, field_defn, return_type.non_null?, ast_node, result_name, selection_result)
-                if HALT != continue_value
-                  continue_field(next_path, continue_value, owner_type, field_defn, return_type, ast_node, next_selections, false, object, resolved_arguments, result_name, selection_result)
-                end
+            rescue GraphQL::ExecutionError => err
+              err
+            rescue StandardError => err
+              begin
+                query.handle_or_reraise(err)
+              rescue GraphQL::ExecutionError => ex_err
+                ex_err
               end
             end
-
-            # If this field is a root mutation field, immediately resolve
-            # all of its child fields before moving on to the next root mutation field.
-            # (Subselections of this mutation will still be resolved level-by-level.)
-            if is_eager_field
-              Interpreter::Resolve.resolve_all([field_result], @dataloader)
-            else
-              # Return this from `after_lazy` because it might be another lazy that needs to be resolved
-              field_result
+            after_lazy(app_result, owner: owner_type, field: field_defn, ast_node: ast_node, owner_object: object, arguments: resolved_arguments, result_name: result_name, result: selection_result) do |inner_result|
+              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)
+              end
             end
           end
+
+          # If this field is a root mutation field, immediately resolve
+          # all of its child fields before moving on to the next root mutation field.
+          # (Subselections of this mutation will still be resolved level-by-level.)
+          if is_eager_field
+            Interpreter::Resolve.resolve_all([field_result], @dataloader)
+          else
+            # Return this from `after_lazy` because it might be another lazy that needs to be resolved
+            field_result
+          end
         end
 
+
         def dead_result?(selection_result)
-          selection_result.graphql_dead || ((parent = selection_result.graphql_parent) && parent.graphql_dead)
+          selection_result.graphql_dead  # || ((parent = selection_result.graphql_parent) && parent.graphql_dead)
         end
 
-        def set_result(selection_result, result_name, value)
+        def set_result(selection_result, result_name, value, is_child_result)
           if !dead_result?(selection_result)
             if value.nil? &&
                 ( # there are two conditions under which `nil` is not allowed in the response:
@@ -563,11 +608,13 @@ module GraphQL
               if parent.nil? # This is a top-level result hash
                 @response = nil
               else
-                set_result(parent, name_in_parent, nil)
+                set_result(parent, name_in_parent, nil, false)
                 set_graphql_dead(selection_result)
               end
+            elsif is_child_result
+              selection_result.set_child_result(result_name, value)
             else
-              selection_result[result_name] = value
+              selection_result.set_leaf(result_name, value)
             end
           end
         end
@@ -587,18 +634,29 @@ module GraphQL
           end
         end
 
+        def current_path
+          st = get_current_runtime_state
+          result = st.current_result
+          path = result && result.path
+          if path && (rn = st.current_result_name)
+            path = path.dup
+            path.push(rn)
+          end
+          path
+        end
+
         HALT = Object.new
-        def continue_value(path, value, parent_type, field, is_non_null, ast_node, result_name, selection_result) # rubocop:disable Metrics/ParameterLists
+        def continue_value(value, parent_type, field, is_non_null, ast_node, result_name, selection_result) # rubocop:disable Metrics/ParameterLists
           case value
           when nil
             if is_non_null
-              set_result(selection_result, result_name, nil) do
+              set_result(selection_result, result_name, nil, false) do
                 # This block is called if `result_name` is not dead. (Maybe a previous invalid nil caused it be marked dead.)
                 err = parent_type::InvalidNullError.new(parent_type, field, value)
                 schema.type_error(err, context)
               end
             else
-              set_result(selection_result, result_name, nil)
+              set_result(selection_result, result_name, nil, false)
             end
             HALT
           when GraphQL::Error
@@ -607,14 +665,24 @@ module GraphQL
             # every time.
             if value.is_a?(GraphQL::ExecutionError)
               if selection_result.nil? || !dead_result?(selection_result)
-                value.path ||= path
+                value.path ||= current_path
                 value.ast_node ||= ast_node
                 context.errors << value
                 if selection_result
-                  set_result(selection_result, result_name, nil)
+                  set_result(selection_result, result_name, nil, false)
                 end
               end
               HALT
+            elsif value.is_a?(GraphQL::UnauthorizedFieldError)
+              value.field ||= field
+              # this hook might raise & crash, or it might return
+              # a replacement value
+              next_value = begin
+                schema.unauthorized_field(value)
+              rescue GraphQL::ExecutionError => err
+                err
+              end
+              continue_value(next_value, parent_type, field, is_non_null, ast_node, result_name, selection_result)
             elsif value.is_a?(GraphQL::UnauthorizedError)
               # this hook might raise & crash, or it might return
               # a replacement value
@@ -623,7 +691,7 @@ module GraphQL
               rescue GraphQL::ExecutionError => err
                 err
               end
-              continue_value(path, next_value, parent_type, field, is_non_null, ast_node, result_name, selection_result)
+              continue_value(next_value, parent_type, field, is_non_null, ast_node, result_name, selection_result)
             elsif GraphQL::Execution::SKIP == value
               # It's possible a lazy was already written here
               case selection_result
@@ -649,15 +717,15 @@ module GraphQL
               if selection_result.nil? || !dead_result?(selection_result)
                 value.each_with_index do |error, index|
                   error.ast_node ||= ast_node
-                  error.path ||= path + (list_type_at_all ? [index] : [])
+                  error.path ||= current_path + (list_type_at_all ? [index] : [])
                   context.errors << error
                 end
                 if selection_result
                   if list_type_at_all
                     result_without_errors = value.map { |v| v.is_a?(GraphQL::ExecutionError) ? nil : v }
-                    set_result(selection_result, result_name, result_without_errors)
+                    set_result(selection_result, result_name, result_without_errors, false)
                   else
-                    set_result(selection_result, result_name, nil)
+                    set_result(selection_result, result_name, nil, false)
                   end
                 end
               end
@@ -667,7 +735,7 @@ module GraphQL
             end
           when GraphQL::Execution::Interpreter::RawValue
             # Write raw value directly to the response without resolving nested objects
-            set_result(selection_result, result_name, value.resolve)
+            set_result(selection_result, result_name, value.resolve, false)
             HALT
           else
             value
@@ -682,7 +750,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(path, 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) # rubocop:disable Metrics/ParameterLists
           if current_type.non_null?
             current_type = current_type.of_type
             is_non_null = true
@@ -695,11 +763,11 @@ module GraphQL
             rescue StandardError => err
               schema.handle_or_reraise(context, err)
             end
-            set_result(selection_result, result_name, r)
+            set_result(selection_result, result_name, r, false)
             r
           when "UNION", "INTERFACE"
-            resolved_type_or_lazy = resolve_type(current_type, value, path)
-            after_lazy(resolved_type_or_lazy, owner: current_type, path: path, 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|
+            resolved_type_or_lazy = resolve_type(current_type, value)
+            after_lazy(resolved_type_or_lazy, owner: current_type, 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|
               if resolved_type_result.is_a?(Array) && resolved_type_result.length == 2
                 resolved_type, resolved_value = resolved_type_result
               else
@@ -713,10 +781,10 @@ module GraphQL
                 err_class = current_type::UnresolvedTypeError
                 type_error = err_class.new(resolved_value, field, parent_type, resolved_type, possible_types)
                 schema.type_error(type_error, context)
-                set_result(selection_result, result_name, nil)
+                set_result(selection_result, result_name, nil, false)
                 nil
               else
-                continue_field(path, 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)
               end
             end
           when "OBJECT"
@@ -725,11 +793,11 @@ module GraphQL
             rescue GraphQL::ExecutionError => err
               err
             end
-            after_lazy(object_proxy, owner: current_type, path: path, ast_node: ast_node, field: field, owner_object: owner_object, arguments: arguments, trace: false, result_name: result_name, result: selection_result) do |inner_object|
-              continue_value = continue_value(path, inner_object, owner_type, field, is_non_null, ast_node, result_name, selection_result)
+            after_lazy(object_proxy, owner: current_type, ast_node: ast_node, field: field, owner_object: owner_object, arguments: arguments, trace: false, result_name: result_name, result: selection_result) do |inner_object|
+              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)
-                set_result(selection_result, result_name, response_hash)
+                set_result(selection_result, result_name, response_hash, true)
                 gathered_selections = gather_selections(continue_value, current_type, 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).
@@ -747,10 +815,15 @@ module GraphQL
                     this_result = response_hash
                     final_result = nil
                   end
-                  set_all_interpreter_context(continue_value, nil, nil, path) # reset this mutable state
+                  # 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
+
                   call_method_on_directives(:resolve, continue_value, selections.graphql_directives) do
                     evaluate_selections(
-                      path,
                       continue_value,
                       current_type,
                       false,
@@ -768,43 +841,30 @@ module GraphQL
             inner_type = current_type.of_type
             # This is true for objects, unions, and interfaces
             use_dataloader_job = !inner_type.unwrap.kind.input?
+            inner_type_non_null = inner_type.non_null?
             response_list = GraphQLResultArray.new(result_name, selection_result)
-            response_list.graphql_non_null_list_items = inner_type.non_null?
-            set_result(selection_result, result_name, response_list)
-            result_was_set = false
+            response_list.graphql_non_null_list_items = inner_type_non_null
+            set_result(selection_result, result_name, response_list, true)
             idx = 0
             list_value = begin
               value.each do |inner_value|
-                break if dead_result?(response_list)
-                if !result_was_set
-                  # Don't set the result unless `.each` is successful
-                  set_result(selection_result, result_name, response_list)
-                  result_was_set = true
-                end
-                next_path = path + [idx]
                 this_idx = idx
-                next_path.freeze
                 idx += 1
                 if use_dataloader_job
                   @dataloader.append_job do
-                    resolve_list_item(inner_value, inner_type, next_path, 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)
                   end
                 else
-                  resolve_list_item(inner_value, inner_type, next_path, 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)
                 end
               end
-              # Maybe the list was empty and the block was never called.
-              if !result_was_set
-                set_result(selection_result, result_name, response_list)
-                result_was_set = true
-              end
 
               response_list
             rescue NoMethodError => err
               # Ruby 2.2 doesn't have NoMethodError#receiver, can't check that one in this case. (It's been EOL since 2017.)
               if err.name == :each && (err.respond_to?(:receiver) ? err.receiver == value : true)
                 # This happens when the GraphQL schema doesn't match the implementation. Help the dev debug.
-                raise ListResultFailedError.new(value: value, field: field, path: path)
+                raise ListResultFailedError.new(value: value, field: field, path: current_path)
               else
                 # This was some other NoMethodError -- let it bubble to reveal the real error.
                 raise
@@ -819,20 +879,22 @@ module GraphQL
               end
             end
 
-            continue_value(path, list_value, owner_type, field, inner_type.non_null?, ast_node, result_name, selection_result)
+            continue_value(list_value, owner_type, field, inner_type.non_null?, ast_node, result_name, selection_result)
           else
             raise "Invariant: Unhandled type kind #{current_type.kind} (#{current_type})"
           end
         end
 
-        def resolve_list_item(inner_value, inner_type, next_path, ast_node, field, owner_object, arguments, this_idx, response_list, next_selections, owner_type) # rubocop:disable Metrics/ParameterLists
-          set_all_interpreter_context(nil, nil, nil, next_path)
+        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
           call_method_on_directives(:resolve_each, owner_object, ast_node.directives) do
             # This will update `response_list` with the lazy
-            after_lazy(inner_value, owner: inner_type, path: next_path, ast_node: ast_node, field: field, owner_object: owner_object, arguments: arguments, result_name: this_idx, result: response_list) do |inner_inner_value|
-              continue_value = continue_value(next_path, inner_inner_value, owner_type, field, inner_type.non_null?, ast_node, this_idx, response_list)
+            after_lazy(inner_value, owner: inner_type, ast_node: ast_node, field: field, owner_object: owner_object, arguments: arguments, result_name: this_idx, result: response_list) do |inner_inner_value|
+              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(next_path, 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)
               end
             end
           end
@@ -851,7 +913,6 @@ module GraphQL
             dir_defn = @schema_directives.fetch(dir_node.name)
             raw_dir_args = arguments(nil, dir_defn, dir_node)
             dir_args = continue_value(
-              @context[:current_path], # path
               raw_dir_args, # value
               dir_defn, # parent_type
               nil, # field
@@ -883,37 +944,30 @@ module GraphQL
           true
         end
 
-        def set_all_interpreter_context(object, field, arguments, path)
-          ti = thread_info
-          if object
-            ti[:current_object] = object
-          end
-          if field
-            ti[:current_field] = field
-          end
-          if arguments
-            ti[:current_arguments] = arguments
-          end
-          if path
-            ti[:current_path] = path
-          end
+        def get_current_runtime_state
+          Thread.current[:__graphql_runtime_info] ||= CurrentState.new
         end
 
         # @param obj [Object] Some user-returned value that may want to be batched
-        # @param path [Array<String>]
         # @param field [GraphQL::Schema::Field]
         # @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, owner:, field:, path:, owner_object:, arguments:, ast_node:, result:, result_name:, eager: false, trace: true, &block)
+        def after_lazy(lazy_obj, owner:, field:, owner_object:, arguments:, ast_node:, result:, result_name:, eager: false, trace: true, &block)
           if lazy?(lazy_obj)
-            lazy = GraphQL::Execution::Lazy.new(path: path, field: field) do
-              set_all_interpreter_context(owner_object, field, arguments, path)
+            orig_result = result
+            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
               # Wrap the execution of _this_ method with tracing,
               # but don't wrap the continuation below
               inner_obj = begin
                 if trace
-                  query.trace("execute_field_lazy", {owner: owner, field: field, path: path, query: query, object: owner_object, arguments: arguments, ast_node: ast_node}) do
+                  query.current_trace.execute_field_lazy(field: field, query: query, object: owner_object, arguments: arguments, ast_node: ast_node) do
                     schema.sync_lazy(lazy_obj)
                   end
                 else
@@ -934,11 +988,17 @@ module GraphQL
             if eager
               lazy.value
             else
-              set_result(result, result_name, lazy)
+              set_result(result, result_name, lazy, false)
+              current_depth = 0
+              while result
+                current_depth += 1
+                result = result.graphql_parent
+              end
+              @lazies_at_depth[current_depth] << lazy
               lazy
             end
           else
-            set_all_interpreter_context(owner_object, field, arguments, path)
+            # Don't need to reset state here because it _wasn't_ lazy.
             yield(lazy_obj)
           end
         end
@@ -952,25 +1012,18 @@ module GraphQL
           end
         end
 
-        # Set this pair in the Query context, but also in the interpeter namespace,
-        # for compatibility.
-        def set_interpreter_context(key, value)
-          thread_info[key] = value
-        end
-
-        def delete_interpreter_context(key)
-          (ti = thread_info) && ti.delete(key)
+        def delete_all_interpreter_context
+          Thread.current[:__graphql_runtime_info] = nil
         end
 
-        def resolve_type(type, value, path)
-          trace_payload = { context: context, type: type, object: value, path: path }
-          resolved_type, resolved_value = query.trace("resolve_type", trace_payload) do
+        def resolve_type(type, value)
+          resolved_type, resolved_value = query.current_trace.resolve_type(query: query, type: type, object: value) do
             query.resolve_type(type, value)
           end
 
           if lazy?(resolved_type)
             GraphQL::Execution::Lazy.new do
-              query.trace("resolve_type_lazy", trace_payload) do
+              query.current_trace.resolve_type_lazy(query: query, type: type, object: value) do
                 schema.sync_lazy(resolved_type)
               end
             end