graphql 1.12.8 → 1.12.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 10ea46e2edf136b445de343ee1a58dd98b0a6c5800ef31923d7d184198ed58fd
-  data.tar.gz: f2f6dff0bf020bfef04769deb3fd548317121f0e636d7a47a94baea862f341ac
+  metadata.gz: 2cad71b0084305ae219dd00e6c6ed48871f126d90c38cf47b9708db1eaf1feb6
+  data.tar.gz: afe00c0b1f14134068015098392817c0c0f0841f8016863789d319590dc5a9ba
 SHA512:
-  metadata.gz: a79fde55cedcd391b7dfe7c141e22c51563aeefceb0fda494dd50f4281fefb0104f8663e688395268c95361ee10e01c7bfb69250368441ec8b8c9ad0d00ac279
-  data.tar.gz: 49a7b0f5cdf9d3a64ff05b0898c7ef93c6cdfd210baf93affa25afe3f3d7b59187fe3e7727f467af9411a085c5f6e8e281fafd27352fe97128f98bd82ffde330
+  metadata.gz: 8fc7bee0a1a2bdc836358338d41d56c394f495dcc78d17403c60efd47ae8f807ad447fcb96a9c270137fa247fde43b5936961436efb6d1276768f945bd5be077
+  data.tar.gz: a0da8f32b54df7b1254dac3749ffe1e9a9b2d93ec273313280d755b5c2bf3910880f2a13f4861d7efb0b2e39a5aefc63491918a89bcdfa223893769a0a9a1ddf

data/lib/generators/graphql/install_generator.rb

@@ -122,7 +122,7 @@ module Graphql
         if options.api?
           say("Skipped graphiql, as this rails project is API only")
           say("  You may wish to use GraphiQL.app for development: https://github.com/skevy/graphiql-app")
-        elsif !options[:skip_graphiql]
+        elsif !options[:skip_graphiql] && !File.read(Rails.root.join("Gemfile")).include?("graphiql-rails")
           gem("graphiql-rails", group: :development)
 
           # This is a little cheat just to get cleaner shell output:

data/lib/generators/graphql/templates/graphql_controller.erb

@@ -15,9 +15,9 @@ class GraphqlController < ApplicationController
     }
     result = <%= schema_name %>.execute(query, variables: variables, context: context, operation_name: operation_name)
     render json: result
-  rescue => e
+  rescue StandardError => e
     raise e unless Rails.env.development?
-    handle_error_in_development e
+    handle_error_in_development(e)
   end
 
   private

data/lib/graphql.rb

@@ -81,10 +81,19 @@ end
 # Order matters for these:
 
 require "graphql/execution_error"
+require "graphql/runtime_type_error"
+require "graphql/unresolved_type_error"
+require "graphql/invalid_null_error"
+require "graphql/analysis_error"
+require "graphql/coercion_error"
+require "graphql/invalid_name_error"
+require "graphql/integer_decoding_error"
+require "graphql/integer_encoding_error"
+require "graphql/string_encoding_error"
+
 require "graphql/define"
 require "graphql/base_type"
 require "graphql/object_type"
-
 require "graphql/enum_type"
 require "graphql/input_object_type"
 require "graphql/interface_type"
@@ -109,9 +118,6 @@ require "graphql/analysis"
 require "graphql/tracing"
 require "graphql/dig"
 require "graphql/execution"
-require "graphql/runtime_type_error"
-require "graphql/unresolved_type_error"
-require "graphql/invalid_null_error"
 require "graphql/pagination"
 require "graphql/schema"
 require "graphql/query"
@@ -133,12 +139,6 @@ require "graphql/static_validation"
 require "graphql/dataloader"
 require "graphql/introspection"
 
-require "graphql/analysis_error"
-require "graphql/coercion_error"
-require "graphql/invalid_name_error"
-require "graphql/integer_decoding_error"
-require "graphql/integer_encoding_error"
-require "graphql/string_encoding_error"
 require "graphql/version"
 require "graphql/compatibility"
 require "graphql/function"

data/lib/graphql/backtrace/table.rb

@@ -83,7 +83,7 @@ module GraphQL
           value = if top && @override_value
             @override_value
           else
-            @context.query.context.namespace(:interpreter)[:runtime].value_at(context_entry.path)
+            value_at(@context.query.context.namespace(:interpreter)[:runtime], context_entry.path)
           end
           rows << [
             "#{context_entry.ast_node ? context_entry.ast_node.position.join(":") : ""}",
@@ -130,7 +130,7 @@ module GraphQL
           if object.is_a?(GraphQL::Schema::Object)
             object = object.object
           end
-          value = context_entry.namespace(:interpreter)[:runtime].value_at([])
+          value = value_at(context_entry.namespace(:interpreter)[:runtime], [])
           rows << [
             "#{position}",
             "#{op_type}#{op_name ? " #{op_name}" : ""}",
@@ -142,6 +142,18 @@ module GraphQL
           raise "Unexpected get_rows subject #{context_entry.class} (#{context_entry.inspect})"
         end
       end
+
+      def value_at(runtime, path)
+        response = runtime.final_result
+        path.each do |key|
+          if response && (response = response[key])
+            next
+          else
+            break
+          end
+        end
+        response
+      end
     end
   end
 end

data/lib/graphql/backtrace/tracer.rb

@@ -22,7 +22,7 @@ module GraphQL
         when "execute_field", "execute_field_lazy"
           query = metadata[:query] || raise(ArgumentError, "Add `legacy: true` to use GraphQL::Backtrace without the interpreter runtime.")
           multiplex = query.multiplex
-          push_key = metadata[:path].reject { |i| i.is_a?(Integer) }
+          push_key = metadata[:path]
           parent_frame = multiplex.context[:graphql_backtrace_contexts][push_key[0..-2]]
 
           if parent_frame.is_a?(GraphQL::Query)

data/lib/graphql/dataloader.rb

@@ -29,7 +29,12 @@ module GraphQL
 
     def initialize
       @source_cache = Hash.new { |h, source_class| h[source_class] = Hash.new { |h2, batch_parameters|
-          source = source_class.new(*batch_parameters)
+          source = if RUBY_VERSION < "3"
+            source_class.new(*batch_parameters)
+          else
+            batch_args, batch_kwargs = batch_parameters
+            source_class.new(*batch_args, **batch_kwargs)
+          end
           source.setup(self)
           h2[batch_parameters] = source
         }
@@ -43,8 +48,15 @@ module GraphQL
     # @param batch_parameters [Array<Object>]
     # @return [GraphQL::Dataloader::Source] An instance of {source_class}, initialized with `self, *batch_parameters`,
     #   and cached for the lifetime of this {Multiplex}.
-    def with(source_class, *batch_parameters)
-      @source_cache[source_class][batch_parameters]
+    if RUBY_VERSION < "3"
+      def with(source_class, *batch_parameters)
+        @source_cache[source_class][batch_parameters]
+      end
+    else
+      def with(source_class, *batch_args, **batch_kwargs)
+        batch_parameters = [batch_args, batch_kwargs]
+        @source_cache[source_class][batch_parameters]
+      end
     end
 
     # Tell the dataloader that this fiber is waiting for data.
@@ -65,6 +77,21 @@ module GraphQL
       nil
     end
 
+    # Use a self-contained queue for the work in the block.
+    def run_isolated
+      prev_queue = @pending_jobs
+      @pending_jobs = []
+      res = nil
+      # Make sure the block is inside a Fiber, so it can `Fiber.yield`
+      append_job {
+        res = yield
+      }
+      run
+      res
+    ensure
+      @pending_jobs = prev_queue
+    end
+
     # @api private Move along, move along
     def run
       # At a high level, the algorithm is:
@@ -104,7 +131,7 @@ module GraphQL
         while @pending_jobs.any?
           # Create a Fiber to consume jobs until one of the jobs yields
           # or jobs run out
-          f = Fiber.new {
+          f = spawn_fiber {
             while (job = @pending_jobs.shift)
               job.call
             end
@@ -124,26 +151,24 @@ module GraphQL
           # This is where an evented approach would be even better -- can we tell which
           # fibers are ready to continue, and continue execution there?
           #
-          source_fiber_stack = if (first_source_fiber = create_source_fiber)
+          source_fiber_queue = if (first_source_fiber = create_source_fiber)
             [first_source_fiber]
           else
             nil
           end
 
-          if source_fiber_stack
-            # Use a stack with `.pop` here so that when a source causes another source to become pending,
-            # that newly-pending source will run _before_ the one that depends on it.
-            # (See below where the old fiber is pushed to the stack, then the new fiber is pushed on the stack.)
-            while (outer_source_fiber = source_fiber_stack.pop)
+          if source_fiber_queue
+            while (outer_source_fiber = source_fiber_queue.shift)
               resume(outer_source_fiber)
 
-              if outer_source_fiber.alive?
-                source_fiber_stack << outer_source_fiber
-              end
               # If this source caused more sources to become pending, run those before running this one again:
               next_source_fiber = create_source_fiber
               if next_source_fiber
-                source_fiber_stack << next_source_fiber
+                source_fiber_queue << next_source_fiber
+              end
+
+              if outer_source_fiber.alive?
+                source_fiber_queue << outer_source_fiber
               end
             end
           end
@@ -191,7 +216,7 @@ module GraphQL
         #
         # This design could probably be improved by maintaining a `@pending_sources` queue which is shared by the fibers,
         # similar to `@pending_jobs`. That way, when a fiber is resumed, it would never pick up work that was finished by a different fiber.
-        source_fiber = Fiber.new do
+        source_fiber = spawn_fiber do
           pending_sources.each(&:run_pending_keys)
         end
       end
@@ -204,5 +229,24 @@ module GraphQL
     rescue UncaughtThrowError => e
       throw e.tag, e.value
     end
+
+    # Copies the thread local vars into the fiber thread local vars. Many
+    # gems (such as RequestStore, MiniRacer, etc.) rely on thread local vars
+    # to keep track of execution context, and without this they do not
+    # behave as expected.
+    #
+    # @see https://github.com/rmosolgo/graphql-ruby/issues/3449
+    def spawn_fiber
+      fiber_locals = {}
+
+      Thread.current.keys.each do |fiber_var_key|
+        fiber_locals[fiber_var_key] = Thread.current[fiber_var_key]
+      end
+
+      Fiber.new do
+        fiber_locals.each { |k, v| Thread.current[k] = v }
+        yield
+      end
+    end
   end
 end

data/lib/graphql/dataloader/null_dataloader.rb

@@ -10,6 +10,7 @@ module GraphQL
       # These are all no-ops because code was
       # executed sychronously.
       def run; end
+      def run_isolated; yield; end
       def yield; end
 
       def append_job

data/lib/graphql/execution/execute.rb

@@ -6,7 +6,7 @@ module GraphQL
     class Execute
 
       # @api private
-      class Skip; end
+      class Skip < GraphQL::Error; end
 
       # Just a singleton for implementing {Query::Context#skip}
       # @api private

data/lib/graphql/execution/interpreter.rb

@@ -4,7 +4,6 @@ require "graphql/execution/interpreter/argument_value"
 require "graphql/execution/interpreter/arguments"
 require "graphql/execution/interpreter/arguments_cache"
 require "graphql/execution/interpreter/execution_errors"
-require "graphql/execution/interpreter/hash_response"
 require "graphql/execution/interpreter/runtime"
 require "graphql/execution/interpreter/resolve"
 require "graphql/execution/interpreter/handles_raw_value"
@@ -19,7 +18,7 @@ module GraphQL
       def execute(_operation, _root_type, query)
         runtime = evaluate(query)
         sync_lazies(query: query)
-        runtime.final_value
+        runtime.final_result
       end
 
       def self.use(schema_class)
@@ -57,7 +56,7 @@ module GraphQL
 
       def self.finish_query(query, _multiplex)
         {
-          "data" => query.context.namespace(:interpreter)[:runtime].final_value
+          "data" => query.context.namespace(:interpreter)[:runtime].final_result
         }
       end
 
@@ -67,10 +66,7 @@ module GraphQL
         # Although queries in a multiplex _share_ an Interpreter instance,
         # they also have another item of state, which is private to that query
         # in particular, assign it here:
-        runtime = Runtime.new(
-          query: query,
-          response: HashResponse.new,
-        )
+        runtime = Runtime.new(query: query)
         query.context.namespace(:interpreter)[:runtime] = runtime
 
         query.trace("execute_query", {query: query}) do
@@ -91,7 +87,7 @@ module GraphQL
         final_values = queries.map do |query|
           runtime = query.context.namespace(:interpreter)[:runtime]
           # it might not be present if the query has an error
-          runtime ? runtime.final_value : nil
+          runtime ? runtime.final_result : nil
         end
         final_values.compact!
         tracer.trace("execute_query_lazy", {multiplex: multiplex, query: query}) do

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

@@ -28,11 +28,12 @@ module GraphQL
         end
 
         def fetch(ast_node, argument_owner, parent_object)
-          @storage[ast_node][argument_owner][parent_object]
           # If any jobs were enqueued, run them now,
           # since this might have been called outside of execution.
           # (The jobs are responsible for updating `result` in-place.)
-          @dataloader.run
+          @dataloader.run_isolated do
+            @storage[ast_node][argument_owner][parent_object]
+          end
           # Ack, the _hash_ is updated, but the key is eventually
           # overridden with an immutable arguments instance.
           # The first call queues up the job,

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

@@ -34,7 +34,10 @@ module GraphQL
           next_results = []
           while results.any?
             result_value = results.shift
-            if result_value.is_a?(Hash)
+            if result_value.is_a?(Runtime::GraphQLResultHash) || result_value.is_a?(Hash)
+              results.concat(result_value.values)
+              next
+            elsif result_value.is_a?(Runtime::GraphQLResultArray)
               results.concat(result_value.values)
               next
             elsif result_value.is_a?(Array)
@@ -46,7 +49,8 @@ module GraphQL
                 # Since this field returned another lazy,
                 # add it to the same queue
                 results << loaded_value
-              elsif loaded_value.is_a?(Hash) || loaded_value.is_a?(Array)
+              elsif loaded_value.is_a?(Runtime::GraphQLResultHash) || loaded_value.is_a?(Runtime::GraphQLResultArray) ||
+                  loaded_value.is_a?(Hash) || loaded_value.is_a?(Array)
                 # Add these values in wholesale --
                 # they might be modified by later work in the dataloader.
                 next_results << loaded_value

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

@@ -8,6 +8,128 @@ module GraphQL
       #
       # @api private
       class Runtime
+
+        module GraphQLResult
+          attr_accessor :graphql_dead, :graphql_parent, :graphql_result_name
+          # Although these are used by only one of the Result classes,
+          # it's handy to have the methods implemented on both (even though they just return `nil`)
+          # because it makes it easy to check if anything is assigned.
+          # @return [nil, Array<String>]
+          attr_accessor :graphql_non_null_field_names
+          # @return [nil, true]
+          attr_accessor :graphql_non_null_list_items
+
+          # @return [Hash] Plain-Ruby result data (`@graphql_metadata` contains Result wrapper objects)
+          attr_accessor :graphql_result_data
+        end
+
+        class GraphQLResultHash
+          def initialize
+            # Jump through some hoops to avoid creating this duplicate hash if at all possible.
+            @graphql_metadata = nil
+            @graphql_result_data = {}
+          end
+
+          include GraphQLResult
+
+          attr_accessor :graphql_merged_into
+
+          def []=(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[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
+
+            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
+        end
+
+        class GraphQLResultArray
+          include GraphQLResult
+
+          def initialize
+            # Avoid this duplicate allocation if possible -
+            # but it will require some work to keep it up-to-date if it's created.
+            @graphql_metadata = nil
+            @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 []=(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
+
+            value
+          end
+
+          def values
+            (@graphql_metadata || @graphql_result_data)
+          end
+        end
+
+        class GraphQLSelectionSet < Hash
+          attr_accessor :graphql_directives
+        end
+
         # @return [GraphQL::Query]
         attr_reader :query
 
@@ -17,30 +139,48 @@ module GraphQL
         # @return [GraphQL::Query::Context]
         attr_reader :context
 
-        def initialize(query:, response:)
+        def initialize(query:)
           @query = query
           @dataloader = query.multiplex.dataloader
           @schema = query.schema
           @context = query.context
           @multiplex_context = query.multiplex.context
           @interpreter_context = @context.namespace(:interpreter)
-          @response = response
-          @dead_paths = {}
-          @types_at_paths = {}
+          @response = GraphQLResultHash.new
+          # Identify runtime directives by checking which of this schema's directives have overridden `def self.resolve`
+          @runtime_directive_names = []
+          noop_resolve_owner = GraphQL::Schema::Directive.singleton_class
+          schema.directives.each do |name, dir_defn|
+            if dir_defn.method(:resolve).owner != noop_resolve_owner
+              @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] = {} }
+          # { Class => Boolean }
+          @lazy_cache = {}
         end
 
-        def final_value
-          @response.final_value
+        def final_result
+          @response && @response.graphql_result_data
         end
 
         def inspect
           "#<#{self.class.name} response=#{@response.inspect}>"
         end
 
+        def tap_or_each(obj_or_array)
+          if obj_or_array.is_a?(Array)
+            obj_or_array.each do |item|
+              yield(item, true)
+            end
+          else
+            yield(obj_or_array, false)
+          end
+        end
+
         # This _begins_ the execution. Some deferred work
         # might be stored up in lazies.
         # @return [void]
@@ -50,24 +190,48 @@ module GraphQL
           root_type = schema.root_type_for_operation(root_op_type)
           path = []
           set_all_interpreter_context(query.root_value, nil, nil, path)
-          object_proxy = authorized_new(root_type, query.root_value, context, path)
+          object_proxy = authorized_new(root_type, query.root_value, context)
           object_proxy = schema.sync_lazy(object_proxy)
+
           if object_proxy.nil?
             # Root .authorized? returned false.
-            write_in_response(path, nil)
+            @response = nil
           else
-            gathered_selections = gather_selections(object_proxy, root_type, root_operation.selections)
-            # Make the first fiber which will begin execution
-            @dataloader.append_job {
-              evaluate_selections(
-                path,
-                context.scoped_context,
-                object_proxy,
-                root_type,
-                root_op_type == "mutation",
-                gathered_selections,
-              )
-            }
+            resolve_with_directives(object_proxy, root_operation.directives) do # execute query level directives
+              gathered_selections = gather_selections(object_proxy, root_type, 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
+              # is eventually merged back into the main response)
+              #
+              # Otherwise, `gathered_selections` is a hash of selections which can be
+              # directly evaluated and the results can be written right into the main response hash.
+              tap_or_each(gathered_selections) do |selections, is_selection_array|
+                if is_selection_array
+                  selection_response = GraphQLResultHash.new
+                  final_response = @response
+                else
+                  selection_response = @response
+                  final_response = nil
+                end
+
+                @dataloader.append_job {
+                  set_all_interpreter_context(query.root_value, nil, nil, path)
+                  resolve_with_directives(object_proxy, selections.graphql_directives) do
+                    evaluate_selections(
+                      path,
+                      context.scoped_context,
+                      object_proxy,
+                      root_type,
+                      root_op_type == "mutation",
+                      selections,
+                      selection_response,
+                      final_response,
+                    )
+                  end
+                }
+              end
+            end
           end
           delete_interpreter_context(:current_path)
           delete_interpreter_context(:current_field)
@@ -76,15 +240,36 @@ module GraphQL
           nil
         end
 
-        def gather_selections(owner_object, owner_type, selections, selections_by_name = {})
+        # @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
+          nil
+        end
+
+        def gather_selections(owner_object, owner_type, selections, selections_to_run = nil, selections_by_name = GraphQLSelectionSet.new)
           selections.each do |node|
             # Skip gathering this if the directive says so
             if !directives_include?(node, owner_object, owner_type)
               next
             end
 
-            case node
-            when GraphQL::Language::Nodes::Field
+            if node.is_a?(GraphQL::Language::Nodes::Field)
               response_key = node.alias || node.name
               selections = selections_by_name[response_key]
               # if there was already a selection of this field,
@@ -100,58 +285,83 @@ module GraphQL
                 # No selection was found for this field yet
                 selections_by_name[response_key] = node
               end
-            when GraphQL::Language::Nodes::InlineFragment
-              if node.type
-                type_defn = schema.get_type(node.type.name)
-                # Faster than .map{}.include?()
-                query.warden.possible_types(type_defn).each do |t|
+            else
+              # This is an InlineFragment or a FragmentSpread
+              if @runtime_directive_names.any? && node.directives.any? { |d| @runtime_directive_names.include?(d.name) }
+                next_selections = GraphQLSelectionSet.new
+                next_selections.graphql_directives = node.directives
+                if selections_to_run
+                  selections_to_run << next_selections
+                else
+                  selections_to_run = []
+                  selections_to_run << selections_by_name
+                  selections_to_run << next_selections
+                end
+              else
+                next_selections = selections_by_name
+              end
+
+              case node
+              when GraphQL::Language::Nodes::InlineFragment
+                if node.type
+                  type_defn = schema.get_type(node.type.name)
+
+                  # Faster than .map{}.include?()
+                  query.warden.possible_types(type_defn).each do |t|
+                    if t == owner_type
+                      gather_selections(owner_object, owner_type, node.selections, selections_to_run, next_selections)
+                      break
+                    end
+                  end
+                else
+                  # it's an untyped fragment, definitely continue
+                  gather_selections(owner_object, owner_type, node.selections, selections_to_run, next_selections)
+                end
+              when GraphQL::Language::Nodes::FragmentSpread
+                fragment_def = query.fragments[node.name]
+                type_defn = schema.get_type(fragment_def.type.name)
+                possible_types = query.warden.possible_types(type_defn)
+                possible_types.each do |t|
                   if t == owner_type
-                    gather_selections(owner_object, owner_type, node.selections, selections_by_name)
+                    gather_selections(owner_object, owner_type, fragment_def.selections, selections_to_run, next_selections)
                     break
                   end
                 end
               else
-                # it's an untyped fragment, definitely continue
-                gather_selections(owner_object, owner_type, node.selections, selections_by_name)
+                raise "Invariant: unexpected selection class: #{node.class}"
               end
-            when GraphQL::Language::Nodes::FragmentSpread
-              fragment_def = query.fragments[node.name]
-              type_defn = schema.get_type(fragment_def.type.name)
-              possible_types = query.warden.possible_types(type_defn)
-              possible_types.each do |t|
-                if t == owner_type
-                  gather_selections(owner_object, owner_type, fragment_def.selections, selections_by_name)
-                  break
-                end
-              end
-            else
-              raise "Invariant: unexpected selection class: #{node.class}"
             end
           end
-          selections_by_name
+          selections_to_run || selections_by_name
         end
 
         NO_ARGS = {}.freeze
 
         # @return [void]
-        def evaluate_selections(path, scoped_context, owner_object, owner_type, is_eager_selection, gathered_selections)
+        def evaluate_selections(path, scoped_context, owner_object, owner_type, is_eager_selection, gathered_selections, selections_result, target_result) # rubocop:disable Metrics/ParameterLists
           set_all_interpreter_context(owner_object, nil, nil, path)
 
+          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, scoped_context, owner_object, owner_type, is_eager_selection
+                path, result_name, field_ast_nodes_or_ast_node, scoped_context, owner_object, owner_type, is_eager_selection, selections_result
               )
+              finished_jobs += 1
+              if target_result && finished_jobs == enqueued_jobs
+                deep_merge_selection_result(selections_result, target_result)
+              end
             }
           end
 
-          nil
+          selections_result
         end
 
         attr_reader :progress_path
 
         # @return [void]
-        def evaluate_selection(path, result_name, field_ast_nodes_or_ast_node, scoped_context, owner_object, owner_type, is_eager_field)
+        def evaluate_selection(path, result_name, field_ast_nodes_or_ast_node, scoped_context, owner_object, owner_type, is_eager_field, selections_result) # rubocop:disable Metrics/ParameterLists
           # 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
           # selections of the field, it will be an Array of nodes
@@ -185,7 +395,9 @@ module GraphQL
           # This seems janky, but we need to know
           # the field's return type at this path in order
           # to propagate `null`
-          set_type_at_path(next_path, return_type)
+          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)
 
@@ -193,27 +405,27 @@ module GraphQL
           object = owner_object
 
           if is_introspection
-            object = authorized_new(field_defn.owner, object, context, next_path)
+            object = authorized_new(field_defn.owner, object, context)
           end
 
           total_args_count = field_defn.arguments.size
           if total_args_count == 0
             kwarg_arguments = GraphQL::Execution::Interpreter::Arguments::EMPTY
-            evaluate_selection_with_args(kwarg_arguments, field_defn, next_path, ast_node, field_ast_nodes, scoped_context, owner_type, object, is_eager_field)
+            evaluate_selection_with_args(kwarg_arguments, field_defn, next_path, ast_node, field_ast_nodes, scoped_context, owner_type, object, is_eager_field, result_name, selections_result)
           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, scoped_context, owner_type, object, is_eager_field)
+              evaluate_selection_with_args(resolved_arguments, field_defn, next_path, ast_node, field_ast_nodes, scoped_context, owner_type, object, is_eager_field, result_name, selections_result)
             end
           end
         end
 
-        def evaluate_selection_with_args(kwarg_arguments, field_defn, next_path, ast_node, field_ast_nodes, scoped_context, owner_type, object, is_eager_field)  # rubocop:disable Metrics/ParameterLists
+        def evaluate_selection_with_args(kwarg_arguments, field_defn, next_path, ast_node, field_ast_nodes, scoped_context, owner_type, object, is_eager_field, result_name, selection_result)  # rubocop:disable Metrics/ParameterLists
           context.scoped_context = scoped_context
           return_type = field_defn.type
-          after_lazy(kwarg_arguments, owner: owner_type, field: field_defn, path: next_path, ast_node: ast_node, scoped_context: context.scoped_context, owner_object: object, arguments: kwarg_arguments) do |resolved_arguments|
+          after_lazy(kwarg_arguments, owner: owner_type, field: field_defn, path: next_path, ast_node: ast_node, scoped_context: context.scoped_context, owner_object: object, arguments: kwarg_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)
+              continue_value(next_path, resolved_arguments, owner_type, field_defn, return_type.non_null?, ast_node, result_name, selection_result)
               next
             end
 
@@ -246,11 +458,17 @@ module GraphQL
                   # Use this flag to tell Interpreter::Arguments to add itself
                   # to the keyword args hash _before_ freezing everything.
                   extra_args[:argument_details] = :__arguments_add_self
+                when :irep_node
+                  # This is used by `__typename` in order to support the legacy runtime,
+                  # but it has no use here (and it's always `nil`).
+                  # Stop adding it here to avoid the overhead of `.merge_extras` below.
                 else
                   extra_args[extra] = field_defn.fetch_extra(extra, context)
                 end
               end
-              resolved_arguments = resolved_arguments.merge_extras(extra_args)
+              if extra_args.any?
+                resolved_arguments = resolved_arguments.merge_extras(extra_args)
+              end
               resolved_arguments.keyword_arguments
             end
 
@@ -259,12 +477,17 @@ module GraphQL
             # 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 = []
-              field_ast_nodes.each { |f| next_selections.concat(f.selections) }
+              directives = []
+              field_ast_nodes.each { |f|
+                next_selections.concat(f.selections)
+                directives.concat(f.directives)
+              }
             end
 
-            field_result = resolve_with_directives(object, ast_node) do
+            field_result = resolve_with_directives(object, directives) do
               # Actually call the field resolver and capture the result
               app_result = begin
                 query.with_error_handling do
@@ -275,10 +498,10 @@ module GraphQL
               rescue GraphQL::ExecutionError => err
                 err
               end
-              after_lazy(app_result, owner: owner_type, field: field_defn, path: next_path, ast_node: ast_node, scoped_context: context.scoped_context, owner_object: object, arguments: kwarg_arguments) do |inner_result|
-                continue_value = continue_value(next_path, inner_result, owner_type, field_defn, return_type.non_null?, ast_node)
+              after_lazy(app_result, owner: owner_type, field: field_defn, path: next_path, ast_node: ast_node, scoped_context: context.scoped_context, owner_object: object, arguments: kwarg_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, kwarg_arguments)
+                  continue_field(next_path, continue_value, owner_type, field_defn, return_type, ast_node, next_selections, false, object, kwarg_arguments, result_name, selection_result)
                 end
               end
             end
@@ -295,43 +518,129 @@ module GraphQL
           end
         end
 
+        def dead_result?(selection_result)
+          selection_result.graphql_dead || ((parent = selection_result.graphql_parent) && parent.graphql_dead)
+        end
+
+        def set_result(selection_result, result_name, value)
+          if !dead_result?(selection_result)
+            if value.nil? &&
+                ( # there are two conditions under which `nil` is not allowed in the response:
+                  (selection_result.graphql_non_null_list_items) || # this value would be written into a list that doesn't allow nils
+                  ((nn = selection_result.graphql_non_null_field_names) && nn.include?(result_name)) # this value would be written into a field that doesn't allow nils
+                )
+              # This is an invalid nil that should be propagated
+              # One caller of this method passes a block,
+              # namely when application code returns a `nil` to GraphQL and it doesn't belong there.
+              # The other possibility for reaching here is when a field returns an ExecutionError, so we write
+              # `nil` to the response, not knowing whether it's an invalid `nil` or not.
+              # (And in that case, we don't have to call the schema's handler, since it's not a bug in the application.)
+              # TODO the code is trying to tell me something.
+              yield if block_given?
+              parent = selection_result.graphql_parent
+              name_in_parent = selection_result.graphql_result_name
+              if parent.nil? # This is a top-level result hash
+                @response = nil
+              else
+                set_result(parent, name_in_parent, nil)
+                set_graphql_dead(selection_result)
+              end
+            else
+              selection_result[result_name] = value
+            end
+          end
+        end
+
+        # Mark this node and any already-registered children as dead,
+        # so that it accepts no more writes.
+        def set_graphql_dead(selection_result)
+          case selection_result
+          when GraphQLResultArray
+            selection_result.graphql_dead = true
+            selection_result.values.each { |v| set_graphql_dead(v) }
+          when GraphQLResultHash
+            selection_result.graphql_dead = true
+            selection_result.each { |k, v| set_graphql_dead(v) }
+          else
+            # It's a scalar, no way to mark it dead.
+          end
+        end
+
         HALT = Object.new
-        def continue_value(path, value, parent_type, field, is_non_null, ast_node)
-          if value.nil?
+        def continue_value(path, 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
-              err = parent_type::InvalidNullError.new(parent_type, field, value)
-              write_invalid_null_in_response(path, err)
+              set_result(selection_result, result_name, nil) 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
-              write_in_response(path, nil)
+              set_result(selection_result, result_name, nil)
             end
             HALT
-          elsif value.is_a?(GraphQL::ExecutionError)
-            value.path ||= path
-            value.ast_node ||= ast_node
-            write_execution_errors_in_response(path, [value])
-            HALT
-          elsif value.is_a?(Array) && value.any? && value.all? { |v| v.is_a?(GraphQL::ExecutionError) }
-            value.each_with_index do |error, index|
-              error.ast_node ||= ast_node
-              error.path ||= path + (field.type.list? ? [index] : [])
+          when GraphQL::Error
+            # Handle these cases inside a single `when`
+            # to avoid the overhead of checking three different classes
+            # every time.
+            if value.is_a?(GraphQL::ExecutionError)
+              if selection_result.nil? || !dead_result?(selection_result)
+                value.path ||= path
+                value.ast_node ||= ast_node
+                context.errors << value
+                if selection_result
+                  set_result(selection_result, result_name, nil)
+                end
+              end
+              HALT
+            elsif value.is_a?(GraphQL::UnauthorizedError)
+              # this hook might raise & crash, or it might return
+              # a replacement value
+              next_value = begin
+                schema.unauthorized_object(value)
+              rescue GraphQL::ExecutionError => err
+                err
+              end
+              continue_value(path, next_value, parent_type, field, is_non_null, ast_node, result_name, selection_result)
+            elsif GraphQL::Execution::Execute::SKIP == value
+              # It's possible a lazy was already written here
+              case selection_result
+              when GraphQLResultHash
+                selection_result.delete(result_name)
+              when GraphQLResultArray
+                selection_result.graphql_skip_at(result_name)
+              when nil
+                # this can happen with directives
+              else
+                raise "Invariant: unexpected result class #{selection_result.class} (#{selection_result.inspect})"
+              end
+              HALT
+            else
+              # What could this actually _be_? Anyhow,
+              # preserve the default behavior of doing nothing with it.
+              value
             end
-            write_execution_errors_in_response(path, value)
-            HALT
-          elsif value.is_a?(GraphQL::UnauthorizedError)
-            # this hook might raise & crash, or it might return
-            # a replacement value
-            next_value = begin
-              schema.unauthorized_object(value)
-            rescue GraphQL::ExecutionError => err
-              err
+          when Array
+            # It's an array full of execution errors; add them all.
+            if value.any? && value.all? { |v| v.is_a?(GraphQL::ExecutionError) }
+              if selection_result.nil? || !dead_result?(selection_result)
+                value.each_with_index do |error, index|
+                  error.ast_node ||= ast_node
+                  error.path ||= path + ((field && field.type.list?) ? [index] : [])
+                  context.errors << error
+                end
+                if selection_result
+                  set_result(selection_result, result_name, nil)
+                end
+              end
+              HALT
+            else
+              value
             end
-
-            continue_value(path, next_value, parent_type, field, is_non_null, ast_node)
-          elsif GraphQL::Execution::Execute::SKIP == value
-            HALT
-          elsif value.is_a?(GraphQL::Execution::Interpreter::RawValue)
+          when GraphQL::Execution::Interpreter::RawValue
             # Write raw value directly to the response without resolving nested objects
-            write_in_response(path, value.resolve)
+            set_result(selection_result, result_name, value.resolve)
             HALT
           else
             value
@@ -346,17 +655,22 @@ 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) # rubocop:disable Metrics/ParameterLists
+        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
+          if current_type.non_null?
+            current_type = current_type.of_type
+            is_non_null = true
+          end
+
           case current_type.kind.name
           when "SCALAR", "ENUM"
             r = current_type.coerce_result(value, context)
-            write_in_response(path, r)
+            set_result(selection_result, result_name, r)
             r
           when "UNION", "INTERFACE"
             resolved_type_or_lazy, resolved_value = resolve_type(current_type, value, path)
             resolved_value ||= value
 
-            after_lazy(resolved_type_or_lazy, owner: current_type, path: path, ast_node: ast_node, scoped_context: context.scoped_context, field: field, owner_object: owner_object, arguments: arguments, trace: false) do |resolved_type|
+            after_lazy(resolved_type_or_lazy, owner: current_type, path: path, ast_node: ast_node, scoped_context: context.scoped_context, field: field, owner_object: owner_object, arguments: arguments, trace: false, result_name: result_name, result: selection_result) do |resolved_type|
               possible_types = query.possible_types(current_type)
 
               if !possible_types.include?(resolved_type)
@@ -364,46 +678,83 @@ 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)
-                write_in_response(path, nil)
+                set_result(selection_result, result_name, nil)
                 nil
               else
-                continue_field(path, resolved_value, owner_type, field, resolved_type, ast_node, next_selections, is_non_null, owner_object, arguments)
+                continue_field(path, 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"
             object_proxy = begin
-              authorized_new(current_type, value, context, path)
+              authorized_new(current_type, value, context)
             rescue GraphQL::ExecutionError => err
               err
             end
-            after_lazy(object_proxy, owner: current_type, path: path, ast_node: ast_node, scoped_context: context.scoped_context, field: field, owner_object: owner_object, arguments: arguments, trace: false) do |inner_object|
-              continue_value = continue_value(path, inner_object, owner_type, field, is_non_null, ast_node)
+            after_lazy(object_proxy, owner: current_type, path: path, ast_node: ast_node, scoped_context: context.scoped_context, 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)
               if HALT != continue_value
-                response_hash = {}
-                write_in_response(path, response_hash)
+                response_hash = GraphQLResultHash.new
+                response_hash.graphql_parent = selection_result
+                response_hash.graphql_result_name = result_name
+                set_result(selection_result, result_name, response_hash)
                 gathered_selections = gather_selections(continue_value, current_type, next_selections)
-                evaluate_selections(path, context.scoped_context, continue_value, current_type, false, gathered_selections)
-                response_hash
+                # 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.
+                #    In this case, `gathered_selections` is a hash of selections.
+                # 2. Some selections of this object have runtime directives that may or may not modify execution.
+                #    That part of the selection is evaluated in an isolated way, writing into a sub-response object which is
+                #    eventually merged into the final response. In this case, `gathered_selections` is an array of things to run in isolation.
+                #    (Technically, it's possible that one of those entries _doesn't_ require isolation.)
+                tap_or_each(gathered_selections) do |selections, is_selection_array|
+                  if is_selection_array
+                    this_result = GraphQLResultHash.new
+                    this_result.graphql_parent = selection_result
+                    this_result.graphql_result_name = result_name
+                    final_result = response_hash
+                  else
+                    this_result = response_hash
+                    final_result = nil
+                  end
+                  set_all_interpreter_context(continue_value, nil, nil, path) # reset this mutable state
+                  resolve_with_directives(continue_value, selections.graphql_directives) do
+                    evaluate_selections(
+                      path,
+                      context.scoped_context,
+                      continue_value,
+                      current_type,
+                      false,
+                      selections,
+                      this_result,
+                      final_result,
+                    )
+                    this_result
+                  end
+                end
               end
             end
           when "LIST"
-            response_list = []
-            write_in_response(path, response_list)
             inner_type = current_type.of_type
+            response_list = GraphQLResultArray.new
+            response_list.graphql_non_null_list_items = inner_type.non_null?
+            response_list.graphql_parent = selection_result
+            response_list.graphql_result_name = result_name
+            set_result(selection_result, result_name, response_list)
+
             idx = 0
             scoped_context = context.scoped_context
             begin
               value.each do |inner_value|
                 next_path = path.dup
                 next_path << idx
+                this_idx = idx
                 next_path.freeze
                 idx += 1
-                set_type_at_path(next_path, inner_type)
                 # This will update `response_list` with the lazy
-                after_lazy(inner_value, owner: inner_type, path: next_path, ast_node: ast_node, scoped_context: scoped_context, field: field, owner_object: owner_object, arguments: arguments) do |inner_inner_value|
-                  continue_value = continue_value(next_path, inner_inner_value, owner_type, field, inner_type.non_null?, ast_node)
+                after_lazy(inner_value, owner: inner_type, path: next_path, ast_node: ast_node, scoped_context: scoped_context, 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)
                   if HALT != continue_value
-                    continue_field(next_path, continue_value, owner_type, field, inner_type, ast_node, next_selections, false, owner_object, arguments)
+                    continue_field(next_path, continue_value, owner_type, field, inner_type, ast_node, next_selections, false, owner_object, arguments, this_idx, response_list)
                   end
                 end
               end
@@ -419,23 +770,18 @@ module GraphQL
             end
 
             response_list
-          when "NON_NULL"
-            inner_type = current_type.of_type
-            # Don't `set_type_at_path` because we want the static type,
-            # we're going to use that to determine whether a `nil` should be propagated or not.
-            continue_field(path, value, owner_type, field, inner_type, ast_node, next_selections, true, owner_object, arguments)
           else
             raise "Invariant: Unhandled type kind #{current_type.kind} (#{current_type})"
           end
         end
 
-        def resolve_with_directives(object, ast_node, &block)
-          return yield if ast_node.directives.empty?
-          run_directive(object, ast_node, 0, &block)
+        def resolve_with_directives(object, directives, &block)
+          return yield if directives.nil? || directives.empty?
+          run_directive(object, directives, 0, &block)
         end
 
-        def run_directive(object, ast_node, idx, &block)
-          dir_node = ast_node.directives[idx]
+        def run_directive(object, directives, idx, &block)
+          dir_node = directives[idx]
           if !dir_node
             yield
           else
@@ -443,9 +789,24 @@ module GraphQL
             if !dir_defn.is_a?(Class)
               dir_defn = dir_defn.type_class || raise("Only class-based directives are supported (not `@#{dir_node.name}`)")
             end
-            dir_args = arguments(nil, dir_defn, dir_node).keyword_arguments
-            dir_defn.resolve(object, dir_args, context) do
-              run_directive(object, ast_node, idx + 1, &block)
+            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
+              false, # is_non_null
+              dir_node, # ast_node
+              nil, # result_name
+              nil, # selection_result
+            )
+
+            if dir_args == HALT
+              nil
+            else
+              dir_defn.resolve(object, dir_args, context) do
+                run_directive(object, directives, idx + 1, &block)
+              end
             end
           end
         end
@@ -454,7 +815,7 @@ module GraphQL
         def directives_include?(node, graphql_object, parent_type)
           node.directives.each do |dir_node|
             dir_defn = schema.directives.fetch(dir_node.name).type_class || raise("Only class-based directives are supported (not #{dir_node.name.inspect})")
-            args = arguments(graphql_object, dir_defn, dir_node).keyword_arguments
+            args = arguments(graphql_object, dir_defn, dir_node)
             if !dir_defn.include?(graphql_object, args, context)
               return false
             end
@@ -483,9 +844,8 @@ 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, owner:, field:, path:, scoped_context:, owner_object:, arguments:, ast_node:, eager: false, trace: true, &block)
-          set_all_interpreter_context(owner_object, field, arguments, path)
-          if schema.lazy?(lazy_obj)
+        def after_lazy(lazy_obj, owner:, field:, path:, scoped_context:, 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)
               context.scoped_context = scoped_context
@@ -504,16 +864,17 @@ module GraphQL
                 rescue GraphQL::ExecutionError, GraphQL::UnauthorizedError => err
                   err
               end
-              after_lazy(inner_obj, owner: owner, field: field, path: path, ast_node: ast_node, scoped_context: context.scoped_context, owner_object: owner_object, arguments: arguments, eager: eager, trace: trace, &block)
+              yield(inner_obj)
             end
 
             if eager
               lazy.value
             else
-              write_in_response(path, lazy)
+              set_result(result, result_name, lazy)
               lazy
             end
           else
+            set_all_interpreter_context(owner_object, field, arguments, path)
             yield(lazy_obj)
           end
         end
@@ -527,85 +888,6 @@ module GraphQL
           end
         end
 
-        def write_invalid_null_in_response(path, invalid_null_error)
-          if !dead_path?(path)
-            schema.type_error(invalid_null_error, context)
-            write_in_response(path, nil)
-            add_dead_path(path)
-          end
-        end
-
-        def write_execution_errors_in_response(path, errors)
-          if !dead_path?(path)
-            errors.each do |v|
-              context.errors << v
-            end
-            write_in_response(path, nil)
-            add_dead_path(path)
-          end
-        end
-
-        def write_in_response(path, value)
-          if dead_path?(path)
-            return
-          else
-            if value.nil? && path.any? && type_at(path).non_null?
-              # This nil is invalid, try writing it at the previous spot
-              propagate_path = path[0..-2]
-              write_in_response(propagate_path, value)
-              add_dead_path(propagate_path)
-            else
-              @response.write(path, value)
-            end
-          end
-        end
-
-        def value_at(path)
-          i = 0
-          value = @response.final_value
-          while value && (part = path[i])
-            value = value[part]
-            i += 1
-          end
-          value
-        end
-
-        # To propagate nulls, we have to know what the field type was
-        # at previous parts of the response.
-        # This hash matches the response
-        def type_at(path)
-          @types_at_paths.fetch(path)
-        end
-
-        def set_type_at_path(path, type)
-          @types_at_paths[path] = type
-          nil
-        end
-
-        # Mark `path` as having been permanently nulled out.
-        # No values will be added beyond that path.
-        def add_dead_path(path)
-          dead = @dead_paths
-          path.each do |part|
-            dead = dead[part] ||= {}
-          end
-          dead[:__dead] = true
-        end
-
-        def dead_path?(path)
-          res = @dead_paths
-          path.each do |part|
-            if res
-              if res[:__dead]
-                break
-              else
-                res = res[part]
-              end
-            end
-          end
-          res && res[:__dead]
-        end
-
         # Set this pair in the Query context, but also in the interpeter namespace,
         # for compatibility.
         def set_interpreter_context(key, value)
@@ -624,7 +906,7 @@ module GraphQL
             query.resolve_type(type, value)
           end
 
-          if schema.lazy?(resolved_type)
+          if lazy?(resolved_type)
             GraphQL::Execution::Lazy.new do
               query.trace("resolve_type_lazy", trace_payload) do
                 schema.sync_lazy(resolved_type)
@@ -635,22 +917,14 @@ module GraphQL
           end
         end
 
-        def authorized_new(type, value, context, path)
-          trace_payload = { context: context, type: type, object: value, path: path }
-
-          auth_val = context.query.trace("authorized", trace_payload) do
-            type.authorized_new(value, context)
-          end
+        def authorized_new(type, value, context)
+          type.authorized_new(value, context)
+        end
 
-          if context.schema.lazy?(auth_val)
-            GraphQL::Execution::Lazy.new do
-              context.query.trace("authorized_lazy", trace_payload) do
-                context.schema.sync_lazy(auth_val)
-              end
-            end
-          else
-            auth_val
-          end
+        def lazy?(object)
+          @lazy_cache.fetch(object.class) {
+            @lazy_cache[object.class] = @schema.lazy?(object)
+          }
         end
       end
     end