graphql 2.6.1 → 2.6.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8f525f949845c463742ad345a16e2441802ef69d89aca935fbe78dcfea419341
-  data.tar.gz: 1175b9e2ddc5cf363833b2b9ab5be79e0837d445db5e22ceb5115708c139001e
+  metadata.gz: 16abc9c2a5eda0da251dbe7e14433241bc7d038d2527926832ceb29336fb857a
+  data.tar.gz: c89bd2a4b340ca30bfa7b823f51e4671972355d54bd56fdaed598c13a415c3b3
 SHA512:
-  metadata.gz: bca56323051f3df8cc6d0ce3d91ee0ba0c125cda0b2e2ddf5deab0d18131cdca646aa7a8b3a0dfee98abd5ea6be25eee358ecd3c08ab885c31c946af8033ec05
-  data.tar.gz: d4e993d8b2a3492113bb00175ddaed842ee6d10ca948d7c53ed6550007f7bd24c784214557bf4c33a35139a73909575bc9b93a2bff41d66dfdeeb235e8b4d00f
+  metadata.gz: 6452d2a517c502b4a8934582d060885a5f6462de244a1f331433f1076dc57a879cdd081e147f70925064a99607e0794fcf6eadad7a3f4a9111a5ab979c552554
+  data.tar.gz: b6a0219606d905fc885ab2192596d1acb1d92bce407defc751bfafb1a7199e9c32275c1d3202f3246251e72b80554698b1f54920f76178f1ddc81b41d628bacd

data/lib/graphql/analysis/query_complexity.rb

@@ -9,6 +9,8 @@ module GraphQL
         super
         @skip_introspection_fields = !query.schema.max_complexity_count_introspection_fields
         @complexities_on_type_by_query = {}
+        @intersect_cache = Hash.new { |h, k| h[k] = {}.compare_by_identity }.compare_by_identity
+        @possible_types_cache = {}.compare_by_identity
       end
 
       # Override this method to use the complexity result
@@ -159,8 +161,22 @@ module GraphQL
 
       def types_intersect?(query, a, b)
         return true if a == b
-        a_types = query.types.possible_types(a)
-        query.types.possible_types(b).any? { |t| a_types.include?(t) }
+
+        if a.object_id < b.object_id
+          first_cache = @intersect_cache[a]
+          second_key = b
+        else
+          first_cache = @intersect_cache[b]
+          second_key = a
+        end
+
+        if first_cache.key?(second_key)
+          first_cache[second_key]
+        else
+          a_types = @possible_types_cache[a] ||= query.types.possible_types(a).to_set
+          b_types = @possible_types_cache[b] ||= query.types.possible_types(b).to_set
+          first_cache[second_key] = a_types.intersect?(b_types)
+        end
       end
 
       # A hook which is called whenever a field's max complexity is calculated.
@@ -175,18 +191,16 @@ module GraphQL
       # @param inner_selections [Array<Hash<String, ScopedTypeComplexity>>] Field selections for a scope
       # @return [Integer] Total complexity value for all these selections in the parent scope
       def merged_max_complexity(query, inner_selections)
-        # Aggregate a set of all unique field selection keys across all scopes.
-        # Use a hash, but ignore the values; it's just a fast way to work with the keys.
-        unique_field_keys = inner_selections.each_with_object({}) do |inner_selection, memo|
-          memo.merge!(inner_selection)
+        child_scopes_by_key = {}
+        inner_selections.each do |inner_selection|
+          inner_selection.each do |k, v|
+            scopes = child_scopes_by_key[k] ||= []
+            scopes << v
+          end
         end
-
         # Add up the total cost for each unique field name's coalesced selections
-        unique_field_keys.each_key.reduce(0) do |total, field_key|
-          # Collect all child scopes for this field key;
-          # all keys come with at least one scope.
-          child_scopes = inner_selections.filter_map { _1[field_key] }
-
+        total = 0
+        child_scopes_by_key.each do |field_key, child_scopes|
           # Compute maximum possible cost of child selections;
           # composites merge their maximums, while leaf scopes are always zero.
           # FieldsWillMerge validation assures all scopes are uniformly composite or leaf.
@@ -214,8 +228,10 @@ module GraphQL
             child_complexity: maximum_children_cost,
           )
 
-          total + maximum_cost
+          total += maximum_cost
         end
+
+        total
       end
 
       def legacy_merged_max_complexity(query, inner_selections)

data/lib/graphql/backtrace/table.rb

@@ -90,7 +90,16 @@ module GraphQL
 
           if ast_node
             field_defn = query.get_field(result.graphql_result_type, ast_node.name)
-            args = query.arguments_for(ast_node, field_defn).to_h
+            args = begin
+              if (cached_args = query.arguments_cache.cached_arguments_for(ast_node, field_defn))
+                cached_args.to_h
+              else
+                EmptyObjects::EMPTY_HASH
+              end
+            rescue StandardError => err
+              "Failed to load arguments, #{err.class}: #{err.message}"
+            end
+
             field_path = field_defn.path
             if ast_node.alias
               field_path += " as #{ast_node.alias}"

data/lib/graphql/current.rb

@@ -41,7 +41,13 @@ module GraphQL
     # @see GraphQL::Field#path for a string identifying this field
     # @return [GraphQL::Field, nil] The currently-running field, if there is one.
     def self.field
-      Fiber[:__graphql_runtime_info]&.values&.first&.current_field
+      if (interpreter_info = Fiber[:__graphql_runtime_info])
+        interpreter_info.values&.first&.current_field
+      elsif (field = Fiber[:__graphql_current_field])
+        field
+      else
+        nil
+      end
     end
 
     # @return [Class, nil] The currently-running {Dataloader::Source} class, if there is one.

data/lib/graphql/dataloader.rb

@@ -108,7 +108,7 @@ 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}.
-    if RUBY_VERSION < "3" || RUBY_ENGINE != "ruby" # truffle-ruby wasn't doing well with the implementation below
+    if (RUBY_ENGINE == "ruby" && RUBY_ENGINE < "3") || RUBY_ENGINE == "truffleruby" # truffle-ruby wasn't doing well with the implementation below
       def with(source_class, *batch_args)
         batch_key = source_class.batch_key_for(*batch_args)
         @source_cache[source_class][batch_key] ||= begin

data/lib/graphql/execution/directive_checks.rb

@@ -18,11 +18,13 @@ module GraphQL
           case name
           when SKIP
             args = query.arguments_for(directive_ast_node, directive_defn)
+            next if args.is_a?(GraphQL::ExecutionError)
             if args[:if] == true
               return false
             end
           when INCLUDE
             args = query.arguments_for(directive_ast_node, directive_defn)
+            next if args.is_a?(GraphQL::ExecutionError)
             if args[:if] == false
               return false
             end

data/lib/graphql/execution/field_resolve_step.rb

@@ -21,7 +21,7 @@ module GraphQL
         @finish_extension_idx = nil
         @was_scoped = nil
         @pending_steps = nil
-        @post_processors = @directive_finalizers = nil
+        @arguments_without_loads = @post_processors = @directive_finalizers = nil
       end
 
       attr_reader :ast_node, :key, :parent_type, :selections_step, :runner,
@@ -50,11 +50,14 @@ module GraphQL
 
       def value
         query = @selections_step.query
+        set_current_field
         query.current_trace.begin_execute_field(@field_definition, @arguments, @field_results, query)
         sync(@field_results)
         query.current_trace.end_execute_field(@field_definition, @arguments, @field_results, query, @field_results)
         @runner.add_step(self)
         true
+      ensure
+        set_current_field(nil)
       end
 
       def sync(lazy)
@@ -69,13 +72,14 @@ module GraphQL
         err
       rescue StandardError => stderr
         begin
-          @selections_step.query.handle_or_reraise(stderr)
+          @selections_step.query.handle_or_reraise(stderr, field: @field_definition, arguments: @arguments, object: nil)
         rescue GraphQL::ExecutionError => ex_err
           ex_err
         end
       end
 
       def call
+        set_current_field if @field_definition
         if @enqueued_authorization
           enqueue_next_steps
         elsif @finish_extension_idx
@@ -94,46 +98,73 @@ module GraphQL
         else
           raise
         end
+      ensure
+        set_current_field(nil)
       end
 
       def add_graphql_error(err)
         err.path = path
-        err.ast_nodes = ast_nodes
+        if err.ast_node.nil?
+          err.ast_nodes = ast_nodes
+        end
         @selections_step.query.context.add_error(err)
         err
       end
 
+      def build_errors_result(errors, single_error)
+        first_error = errors.nil? ? single_error : errors.pop
+        @field_results = error_instance_array(@selections_step.objects.size, first_error)
+        if errors
+          errors.each do |e|
+            add_graphql_error(e)
+          end
+        end
+        @results ||= @selections_step.results
+        build_results
+      end
+
       def build_arguments
         query = @selections_step.query
         field_name = @ast_node.name
-        @field_definition = query.types.field(@parent_type, field_name) || raise("Invariant: no field found for #{@parent_type.to_type_signature}.#{ast_node.name}")
-        arguments = @runner.input_values[query].argument_values(@field_definition, @ast_node.arguments, self) # rubocop:disable Development/ContextIsPassedCop
-        @arguments ||= arguments # may have already been set to an error
+        @field_definition = query.types.field(@parent_type, field_name) || raise(GraphQL::Error, "No field definition found for #{@parent_type.to_type_signature}.#{ast_node.name} (at #{@ast_node.position})")
+        set_current_field
+        @arguments, errors = @runner.input_values[query].argument_values(@field_definition, @ast_node.arguments, self) # rubocop:disable Development/ContextIsPassedCop
+        if errors
+          build_errors_result(errors, nil)
+          return
+        end
 
         if (@pending_steps.nil? || @pending_steps.size == 0) &&
             @field_results.nil? # Make sure the arguments flow didn't already call through
           execute_field
         end
+      ensure
+        set_current_field(nil)
+      end
+
+      # Used for compatibility in Schema::Subscription
+      def arguments_without_loads
+        if @arguments_without_loads.nil?
+          @arguments_without_loads, _errors = @runner.input_values[@selections_step.query].argument_values(@field_definition, ast_node.arguments, nil)
+        end
+        @arguments_without_loads
       end
 
       def execute_field
         objects = @selections_step.objects
-        @results = @selections_step.results
-        # TODO not as good because only one error?
         if @arguments.is_a?(GraphQL::RuntimeError)
-          @field_results = Array.new(objects.size, @arguments)
-          build_results
+          build_errors_result(nil, @arguments)
           return
         end
 
+        @results = @selections_step.results
         query = @selections_step.query
         ctx = query.context
         if (v = @field_definition.validators).any?  # rubocop:disable Development/NoneWithoutBlockCop
           begin
             Schema::Validator.validate!(v, nil, ctx, @arguments)
           rescue GraphQL::RuntimeError => err
-            @field_results = Array.new(objects.size, err)
-            build_results
+            build_errors_result(nil, err)
             return
           end
         end
@@ -160,25 +191,40 @@ module GraphQL
         end
 
         if @field_definition.dynamic_introspection
-          # TODO break this backwards compat somehow?
-          objects = @selections_step.graphql_objects
+          objects = @selections_step.graphql_objects.map { |o| @field_definition.owner.wrap(o, ctx) }
         end
 
-        if @runner.authorization && @runner.authorizes?(@field_definition, ctx)
+        if @runner.authorizes?(@field_definition, ctx)
           authorized_objects = []
           authorized_results = []
           l = objects.size
           i = 0
           while i < l
             o = objects[i]
-            if @field_definition.authorized?(o, @arguments, ctx)
+            err = nil
+            begin
+              field_authed = @field_definition.authorized?(o, @arguments, ctx)
+              if @runner.resolves_lazies && @runner.lazy?(field_authed)
+                # TODO batch this properly...
+                field_authed = sync(field_authed)
+              end
+            rescue GraphQL::UnauthorizedFieldError => field_auth_err
+              err = field_auth_err
+              err.field ||= @field_definition
+              field_authed = false
+            end
+
+            if field_authed
               authorized_results << @results[i]
               authorized_objects << o
             else
               begin
-                err = GraphQL::UnauthorizedFieldError.new(object: o, type: @parent_type, context: ctx, field: @field_definition)
-                authorized_objects << query.schema.unauthorized_object(err)
-                authorized_results << @results[i]
+                err ||= GraphQL::UnauthorizedFieldError.new(object: o, type: @parent_type, context: ctx, field: @field_definition)
+                new_obj = query.schema.unauthorized_field(err)
+                if !new_obj.nil?
+                  authorized_objects << new_obj
+                  authorized_results << @results[i]
+                end
               rescue GraphQL::ExecutionError => exec_err
                 add_graphql_error(exec_err)
               end
@@ -220,27 +266,37 @@ module GraphQL
           if directives
             directives.each do |dir_node|
               if (dir_defn = @runner.runtime_directives[dir_node.name])
-                # TODO: `coerce_arguments` modifies self, assuming it's field arguments. Extract to pure function for use
-                # here and with fragments.
-                dir_args = @runner.input_values[query].argument_values(dir_defn, dir_node.arguments, nil)  # rubocop:disable Development/ContextIsPassedCop
-                result = dir_defn.resolve_field(ast_nodes, @parent_type, field_definition, authorized_objects, dir_args, ctx)
-                if !result.nil?
-                  if result.is_a?(Finalizer)
-                    result.path = path
-                    @directive_finalizers ||= []
-                    @directive_finalizers << result
-                  end
-
-                  if result.is_a?(PostProcessor)
-                    @post_processors ||= []
-                    @post_processors << result
-                  end
-
-                  if result.is_a?(HaltExecution)
-                    @directive_finalizers&.each { |f|
-                      @selections_step.results.each { |r|  @runner.add_finalizer(query, r, key, f) }
-                    }
-                    return
+                dir_args, errors = @runner.input_values[query].argument_values(dir_defn, dir_node.arguments, self)  # rubocop:disable Development/ContextIsPassedCop
+                if errors
+                  @results.each { |r| r.delete(@key) }
+                  errors.each { |e| e.ast_node = dir_node }
+                  build_errors_result(errors, nil)
+                  return
+                else
+                  begin
+                    dir_defn.validate!(dir_args, query.context)
+                    if !(result = dir_defn.resolve_field(ast_nodes, @parent_type, field_definition, authorized_objects, dir_args, ctx)).nil?
+                      if result.is_a?(Finalizer)
+                        result.path = path
+                        @directive_finalizers ||= []
+                        @directive_finalizers << result
+                      end
+
+                      if result.is_a?(PostProcessor)
+                        @post_processors ||= []
+                        @post_processors << result
+                      end
+
+                      if result.is_a?(HaltExecution)
+                        @directive_finalizers&.each { |f|
+                          @selections_step.results.each { |r|  @runner.add_finalizer(query, r, key, f) }
+                        }
+                        return
+                      end
+                    end
+                  rescue GraphQL::RuntimeError => err
+                    err.ast_node = dir_node
+                    raise
                   end
                 end
               end
@@ -267,10 +323,20 @@ module GraphQL
 
         if any_lazy_results?
           @runner.dataloader.lazy_at_depth(path.size, self)
-        elsif has_extensions
-          finish_extensions
         elsif @pending_steps.nil? || @pending_steps.empty?
-          build_results
+          if has_extensions
+            finish_extensions
+          else
+            build_results
+          end
+        end
+      rescue GraphQL::ExecutionError => err
+        add_graphql_error(err)
+      rescue StandardError => stderr
+        begin
+          @selections_step.query.handle_or_reraise(stderr, field: @field_definition, arguments: @arguments, object: nil)
+        rescue GraphQL::ExecutionError => err
+          add_graphql_error(err)
         end
       end
 
@@ -312,6 +378,8 @@ module GraphQL
                 conn.was_authorized_by_scope_items = @was_scoped
               end
               conn
+            rescue GraphQL::RuntimeError => err
+              err
             end
           when Schema::Field::ScopeExtension
             if @was_scoped.nil?
@@ -390,9 +458,16 @@ module GraphQL
       end
 
       def finish_leaf_result(result_h, key, field_result, return_type, ctx)
-        final_field_result = if field_result.nil?
+        final_field_result = build_leaf_result(field_result, return_type, ctx, false)
+
+        @directive_finalizers&.each { |f| @runner.add_finalizer(ctx.query, result_h, key, f) }
+        result_h[@key] = final_field_result
+      end
+
+      def build_leaf_result(field_result, return_type, ctx, is_from_array)
+        if field_result.nil?
           if return_type.non_null?
-            add_non_null_error(false)
+            add_non_null_error(is_from_array)
           else
             nil
           end
@@ -403,13 +478,16 @@ module GraphQL
             field_result.path = path
             @runner.add_finalizer(ctx.query, result_h, key, field_result)
           end
+        elsif return_type.list?
+          if return_type.non_null?
+            return_type = return_type.of_type
+          end
+
+          inner_type = return_type.of_type
+          field_result.map { |item| build_leaf_result(item, inner_type, ctx, true) }
         else
-          # TODO `nil`s in [T!] types aren't handled
           return_type.coerce_result(field_result, ctx)
         end
-
-        @directive_finalizers&.each { |f| @runner.add_finalizer(ctx.query, result_h, key, f) }
-        result_h[@key] = final_field_result
       end
 
       def enqueue_next_steps
@@ -427,7 +505,17 @@ module GraphQL
               if (object_type = @runner.runtime_type_at[result])
                 # OK
               else
-                object_type = @runner.resolve_type(@static_type, next_object, query)
+                query.current_trace.begin_resolve_type(@static_type, next_object, query.context)
+                object_type = ResolveTypeStep.resolve_type(@static_type, next_object, query)
+                if object_type.is_a?(Array)
+                  object_type, next_object = object_type
+                end
+                if @runner.resolves_lazies && @runner.lazy?(object_type)
+                  # TODO batch this
+                  object_type, next_object = sync(object_type)
+                end
+                ResolveTypeStep.assert_valid_resolved_type(@static_type, object_type, next_object, self)
+                query.current_trace.end_resolve_type(@static_type, next_object, query.context, object_type)
                 @runner.runtime_type_at[result] = object_type
               end
               next_objects_by_type[object_type] << next_object
@@ -469,10 +557,14 @@ module GraphQL
       end
 
       def add_non_null_error(is_from_array)
-        err = InvalidNullError.new(@parent_type, @field_definition, ast_nodes, is_from_array: is_from_array, path: path)
+        err = @parent_type::InvalidNullError.new(@parent_type, @field_definition, ast_nodes, is_from_array: is_from_array, path: path)
         @runner.schema.type_error(err, @selections_step.query.context)
       end
 
+      def set_current_field(new_value = @field_definition)
+        Fiber[:__graphql_current_field] = new_value
+      end
+
       private
 
       def build_graphql_result(graphql_result, key, field_result, return_type, is_nn, is_list, is_from_array) # rubocop:disable Metrics/ParameterLists
@@ -507,13 +599,13 @@ module GraphQL
             i += 1
           end
         elsif @runner.resolves_lazies || (
-                @runner.authorization && (
-                    @static_type.kind.object? ?
-                      @runner.authorizes?(@static_type, @selections_step.query.context) :
-                      (
-                        (runtime_type = (@runner.runtime_type_at[graphql_result] = @runner.resolve_type(@static_type, field_result, @selections_step.query))) &&
-                        @runner.authorizes?(runtime_type, @selections_step.query.context)
-                      )))
+                @static_type.kind.object? ?
+                  @runner.authorizes?(@static_type, @selections_step.query.context) :
+                  (
+                    (runtime_type, _ignored_new_value = ResolveTypeStep.resolve_type(@static_type, field_result, @selections_step.query)) &&
+                    (@runner.runtime_type_at[graphql_result] = runtime_type) &&
+                    @runner.authorizes?(runtime_type, @selections_step.query.context)
+                  ))
           obj_step = PrepareObjectStep.new(
             object: field_result,
             runner: @runner,
@@ -539,26 +631,46 @@ module GraphQL
       end
 
       def resolve_batch(objects, context, args_hash)
-        method_receiver = @field_definition.dynamic_introspection ? @field_definition.owner : @parent_type
+        dyn_ins = @field_definition.dynamic_introspection
+        method_receiver = dyn_ins ? @field_definition.owner : @parent_type
         case @field_definition.execution_mode
         when :resolve_batch
           begin
             method_receiver.public_send(@field_definition.execution_mode_key, objects, context, **args_hash)
           rescue GraphQL::ExecutionError => exec_err
-            Array.new(objects.size, exec_err)
+            error_instance_array(objects.size, exec_err)
+          rescue StandardError => stderr
+            begin
+              context.query.handle_or_reraise(stderr, field: @field_definition, arguments: @arguments, object: nil)
+            rescue GraphQL::ExecutionError => exec_err
+              error_instance_array(objects.size, exec_err)
+            end
           end
         when :resolve_static
           result = begin
             method_receiver.public_send(@field_definition.execution_mode_key, context, **args_hash)
           rescue GraphQL::ExecutionError => err
             err
+          rescue StandardError => stderr
+            begin
+              context.query.handle_or_reraise(stderr, field: @field_definition, arguments: @arguments, object: nil)
+            rescue GraphQL::ExecutionError => err
+              err
+            end
           end
           Array.new(objects.size, result)
         when :resolve_each
           objects.map do |o|
-            method_receiver.public_send(@field_definition.execution_mode_key, o, context, **args_hash)
+            passed_in_obj = dyn_ins ? o.object : o
+            method_receiver.public_send(@field_definition.execution_mode_key, passed_in_obj, context, **args_hash)
           rescue GraphQL::ExecutionError => err
             err
+          rescue StandardError => stderr
+            begin
+              context.query.handle_or_reraise(stderr, field: @field_definition, arguments: @arguments, object: o)
+            rescue GraphQL::ExecutionError => err
+              err
+            end
           end
         when :hash_key
           k = @field_definition.execution_mode_key
@@ -571,7 +683,7 @@ module GraphQL
             err
           rescue StandardError => stderr
             begin
-              @selections_step.query.handle_or_reraise(stderr)
+              @selections_step.query.handle_or_reraise(stderr, object: o, field: @field_definition, arguments: args_hash)
             rescue GraphQL::ExecutionError => ex_err
               ex_err
             end
@@ -615,9 +727,6 @@ module GraphQL
           results
         when :resolve_legacy_instance_method
           @selections_step.graphql_objects.map do |obj_inst|
-            if @field_definition.dynamic_introspection
-              obj_inst = @owner.wrap(obj_inst, context)
-            end
             obj_inst.public_send(@field_definition.execution_mode_key, **args_hash)
           rescue GraphQL::ExecutionError => exec_err
             exec_err
@@ -626,6 +735,10 @@ module GraphQL
           raise "Batching execution for #{path} not implemented (execution_mode: #{@execution_mode.inspect}); provide `resolve_static:`, `resolve_batch:`, `hash_key:`, `method:`, or use a compatibility plug-in"
         end
       end
+
+      def error_instance_array(size, err_prototype)
+        Array.new(size) { err_prototype.dup }
+      end
     end
   end
 end

data/lib/graphql/execution/finalize.rb

@@ -117,7 +117,7 @@ module GraphQL
               @current_exec_path << key
               @current_result_path << key
 
-              field_defn = @query.context.types.field(parent_type, ast_selection.name) || raise("Invariant: No field found for #{static_type.to_type_signature}.#{ast_selection.name}")
+              field_defn = @query.context.types.field(parent_type, ast_selection.name) || raise("Invariant: No field found for #{parent_type.to_type_signature}.#{ast_selection.name}")
               result_type = field_defn.type
               if (result_type_non_null = result_type.non_null?)
                 result_type = result_type.of_type
@@ -154,12 +154,14 @@ module GraphQL
                 @runner.type_condition_applies?(@query.context, static_type_at_result, t.name)
               )
               result_h = check_object_result(result_h, parent_type, ast_selection.selections)
+              return nil if result_h.nil?
             end
           when Language::Nodes::FragmentSpread
             fragment_defn = @query.document.definitions.find { |defn| defn.is_a?(Language::Nodes::FragmentDefinition) && defn.name == ast_selection.name }
             static_type_at_result = @static_type_at[result_h]
             if static_type_at_result && @runner.type_condition_applies?(@query.context, static_type_at_result, fragment_defn.type.name)
               result_h = check_object_result(result_h, parent_type, fragment_defn.selections)
+              return nil if result_h.nil?
             end
           end
         end
@@ -181,11 +183,20 @@ module GraphQL
           return result_arr if @finalizers_count == 0
         end
 
-        result_arr.each_with_index do |result_item, idx|
-          @current_result_path << idx
-          new_result = if (f = finalizers(result_arr, idx))
-            run_finalizers(@current_result_path.dup, f, result_arr, idx)
-            result_arr[idx]
+        effective_idx = -1
+        result_arr.each_with_index do |result_item, before_idx|
+          effective_idx += 1
+          @current_result_path << before_idx
+          new_result = if (f = finalizers(result_arr, before_idx))
+            before_size = result_arr.size
+            run_finalizers(@current_result_path.dup, f, result_arr, effective_idx)
+            after_size = result_arr.size
+            if after_size < before_size
+              effective_idx -= 1
+              :unassigned
+            else
+              result_arr[effective_idx]
+            end
           elsif inner_type.list? && result_item
             check_list_result(result_item, inner_type.of_type, ast_selections)
           elsif !inner_type.kind.leaf? && result_item
@@ -196,10 +207,12 @@ module GraphQL
 
           if new_result.nil? && inner_type_non_null
             new_invalid_null = true
-            result_arr[idx] = nil
+            result_arr[effective_idx] = nil
+            break if @finalizers_count == 0
+          elsif :unassigned.equal?(new_result)
             break if @finalizers_count == 0
           elsif !new_result.equal?(result_item)
-            result_arr[idx] = new_result
+            result_arr[effective_idx] = new_result
             break if @finalizers_count == 0
           end
         ensure