graphql 2.6.3 → 2.6.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 16abc9c2a5eda0da251dbe7e14433241bc7d038d2527926832ceb29336fb857a
-  data.tar.gz: c89bd2a4b340ca30bfa7b823f51e4671972355d54bd56fdaed598c13a415c3b3
+  metadata.gz: 8ece536c0702c8789a3a5c79de82af4bd2ff806a3209d0ac4da88fc968629d19
+  data.tar.gz: 0063f1ea552e7782029083eb027138a0725af89a65265dc643469f2227184134
 SHA512:
-  metadata.gz: 6452d2a517c502b4a8934582d060885a5f6462de244a1f331433f1076dc57a879cdd081e147f70925064a99607e0794fcf6eadad7a3f4a9111a5ab979c552554
-  data.tar.gz: b6a0219606d905fc885ab2192596d1acb1d92bce407defc751bfafb1a7199e9c32275c1d3202f3246251e72b80554698b1f54920f76178f1ddc81b41d628bacd
+  metadata.gz: 2ee406b8ad164004af45d98e3b5dc70d69396f008a80cc68ef83a4bff212698c0a181644dc2b513e8bd1e71d2baf7d1ba2901ad05f497199556b171a6dfb11ab
+  data.tar.gz: 2ffd4e01742bd3b0feb207a316b1935d1edff05be8b28afb1c42e5ba47b4df916df802ee15617bb30bd45cdf6fd4f7a59c22b5d73cbabb3d8ee6658f3246d8ef

data/lib/generators/graphql/field_extractor.rb

@@ -6,7 +6,23 @@ module Graphql
     module FieldExtractor
       def fields
         columns = []
-        columns += (klass&.columns&.map { |c| generate_column_string(c) }  || [])
+        if (model_columns = klass&.columns)
+          filter = if defined?(ActiveSupport::ParameterFilter)
+            fp = if defined?(Rails) && Rails.application && (app_config = Rails.application.config.filter_parameters).present? && !app_config.empty?
+              app_config
+            elsif ActiveSupport.respond_to?(:filter_parameters)
+              ActiveSupport.filter_parameters
+            else
+              []
+            end
+            ActiveSupport::ParameterFilter.new(fp, mask: nil)
+          else
+            nil
+          end
+          columns += model_columns
+            .select { |c| filter ? filter.filter_param(c.name, c.name) : true }
+            .map { |c| generate_column_string(c) }
+        end
         columns + custom_fields
       end
 

data/lib/graphql/analysis/query_complexity.rb

@@ -29,14 +29,14 @@ module GraphQL
             future_complexity
           end
         when nil
-          subject.logger.warn <<~GRAPHQL
+          subject.logger.warn <<~MESSAGE
             GraphQL-Ruby's complexity cost system is getting some "breaking fixes" in a future version. See the migration notes at https://graphql-ruby.org/api-doc/#{GraphQL::VERSION}/GraphQL/Schema.html#complexity_cost_calculation_mode_for-class_method
 
             To opt into the future behavior, configure your schema (#{subject.schema.name ? subject.schema.name : subject.schema.ancestors}) with:
 
               complexity_cost_calculation_mode(:future) # or `:legacy`, `:compare`
 
-          GRAPHQL
+          MESSAGE
           max_possible_complexity(mode: :legacy)
         else
           raise ArgumentError, "Expected `:future`, `:legacy`, `:compare`, or `nil` from `#{query.schema}.complexity_cost_calculation_mode_for` but got: #{query.schema.complexity_cost_calculation_mode.inspect}"

data/lib/graphql/dataloader/async_dataloader.rb

@@ -1,86 +1,324 @@
 # frozen_string_literal: true
+
 module GraphQL
   class Dataloader
     class AsyncDataloader < Dataloader
+      def self.use(...)
+        if !Async::Task.method_defined?(:cancel)
+          Async::Task.alias_method(:cancel, :stop)
+        end
+        if !Async::Task.method_defined?(:graphql_async_dataloader_run)
+          Async::Task.attr_accessor(:graphql_async_dataloader_run)
+          Async::Task.attr_accessor(:graphql_async_dataloader_condition)
+        end
+        super
+      end
+
+      def initialize(...)
+        super
+        create_pending_run
+      end
+
+      def create_pending_run
+        jobs_fiber_limit, total_fiber_limit = calculate_fiber_limit
+        @pending_run = Run.new(total_fiber_limit, jobs_fiber_limit)
+      end
+
       def yield(source = Fiber[:__graphql_current_dataloader_source])
-        trace = Fiber[:__graphql_current_multiplex]&.current_trace
+        task = Async::Task.current
+        run = task.graphql_async_dataloader_run
+        trace = run.trace
         trace&.dataloader_fiber_yield(source)
-        if (condition = Fiber[:graphql_dataloader_next_tick])
-          condition.wait
-        else
-          Fiber.yield
-        end
+        run.finished_tasks.push(task)
+        condition = task.graphql_async_dataloader_condition
+        condition.wait
+        run.started_tasks.push(task)
         trace&.dataloader_fiber_resume(source)
         nil
       end
 
-      def run(trace_query_lazy: nil)
-        trace = Fiber[:__graphql_current_multiplex]&.current_trace
-        jobs_fiber_limit, total_fiber_limit = calculate_fiber_limit
-        job_fibers = []
-        next_job_fibers = []
-        source_tasks = []
-        next_source_tasks = []
-        first_pass = true
-        sources_condition = Async::Condition.new
-        manager = spawn_fiber do
-          trace&.begin_dataloader(self)
-          while first_pass || !job_fibers.empty?
-            first_pass = false
-            fiber_vars = get_fiber_variables
+      class Run
+        def initialize(total_fiber_limit, jobs_fiber_limit)
+          @root_task = nil
+          @trace = nil
+          @jobs = []
 
-            run_pending_steps(job_fibers, next_job_fibers, source_tasks, jobs_fiber_limit, trace)
+          @total_fiber_limit = total_fiber_limit
+          @jobs_fiber_limit = jobs_fiber_limit
+          @lazies_at_depth = Hash.new { |h, k| h[k] = [] }
 
-            Sync do |root_task|
-              set_fiber_variables(fiber_vars)
-              while !source_tasks.empty? || @source_cache.each_value.any? { |group_sources| group_sources.each_value.any?(&:pending?) }
-                while (task = (source_tasks.shift || (((job_fibers.size + next_job_fibers.size + source_tasks.size + next_source_tasks.size) < total_fiber_limit) && spawn_source_task(root_task, sources_condition, trace))))
-                  if task.alive?
-                    root_task.yield # give the source task a chance to run
-                    next_source_tasks << task
-                  end
-                end
-                sources_condition.signal
-                source_tasks.concat(next_source_tasks)
-                next_source_tasks.clear
+          @finished_tasks = nil
+          @started_tasks = nil
+          @started_count_task = nil
+          @finished_count_task = nil
+          @finished_all_tasks = nil
+          @finished_first_pass = nil
+
+          @snoozed_jobs_condition = Async::Condition.new
+          @snoozed_sources_condition = Async::Condition.new
+        end
+
+        attr_accessor :trace, :root_task
+
+        attr_reader :jobs, :lazies_at_depth, :jobs_fiber_limit, :total_fiber_limit, :finished_tasks, :started_tasks, :snoozed_jobs_condition, :snoozed_sources_condition
+
+        def jobs_bandwidth?
+          running_count < jobs_fiber_limit
+        end
+
+        def allowed_sources_tasks
+          within_limit = total_fiber_limit - running_count
+          if within_limit < 1
+            1
+          else
+            within_limit
+          end
+        end
+
+        def close_queues
+          @finished_tasks.close
+          @finished_count_task.cancel
+
+          @started_tasks.close
+          @started_count_task.cancel
+        end
+
+        def running_count
+          @snoozed_jobs_condition.instance_variable_get(:@ready).num_waiting +
+            @snoozed_sources_condition.instance_variable_get(:@ready).num_waiting +
+            @started_count +
+            @started_tasks.size -
+            @finished_count
+        end
+
+        def wait_for_queues
+          if !@finished_first_pass.resolved?
+            @finished_first_pass.resolve(true)
+          end
+
+          @finished_all_tasks.wait
+          @finished_all_tasks = Async::Promise.new
+        end
+
+        def new_queues
+          @finished_tasks = Async::Queue.new
+          @finished_count = 0
+          @started_tasks = Async::Queue.new
+          @started_count = 0
+          @finished_first_pass = Async::Promise.new
+          @finished_all_tasks = Async::Promise.new
+
+          @started_count_task = @root_task.async do |task|
+            @finished_first_pass.wait
+            while task = @started_tasks.wait
+              @started_count += 1
+              if task.status == :initialized # could also be resumed after waiting
+                task.run
               end
             end
+          end
 
-            if !@lazies_at_depth.empty?
-              with_trace_query_lazy(trace_query_lazy) do
-                run_next_pending_lazies(job_fibers, trace)
-                run_pending_steps(job_fibers, next_job_fibers, source_tasks, jobs_fiber_limit, trace)
+          @finished_count_task = @root_task.async do |task|
+            while t_or_err = @finished_tasks.wait
+              if t_or_err.is_a?(StandardError)
+                @finished_all_tasks.reject(t_or_err)
+              else
+                @finished_count += 1
+                if @finished_count == @started_count
+                  @finished_all_tasks.resolve(true)
+                end
               end
             end
           end
-          trace&.end_dataloader(self)
         end
 
-        manager.resume
-        if manager.alive?
-          raise "Invariant: Manager didn't terminate successfully: #{manager}"
+        def running?
+          @snoozed_jobs_condition.waiting? || @snoozed_sources_condition.waiting?
         end
+      end
+
+      def append_job(callable = nil, &block)
+        active_run.jobs.push(callable || block)
+        nil
+      end
+
+      def lazy_at_depth(depth, lazy)
+        active_run.lazies_at_depth[depth] << lazy
+      end
+
+      def active_run
+        @pending_run || Async::Task.current?&.graphql_async_dataloader_run || raise(GraphQL::Error, "No available Run to append to, GraphQL-Ruby bug")
+      end
 
+      def run_isolated
+        previous_run = Async::Task.current?&.graphql_async_dataloader_run
+        prev_pending_keys = {}
+        # Clear pending loads but keep already-cached records
+        # in case they are useful to the given block.
+        @source_cache.each do |source_class, batched_sources|
+          batched_sources.each do |batch_args, batched_source_instance|
+            if batched_source_instance.pending?
+              prev_pending_keys[batched_source_instance] = batched_source_instance.pending.dup
+              batched_source_instance.pending.clear
+            end
+          end
+        end
+
+        res = nil
+        create_pending_run
+        @pending_run.jobs << -> { res = yield }
+        run
+        res
+      ensure
+        if previous_run
+          Async::Task.current.graphql_async_dataloader_run = previous_run
+          # clear the one created in #run:
+          @pending_run = nil
+        end
+        prev_pending_keys.each do |source_instance, pending|
+          pending.each do |key, value|
+            if !source_instance.results.key?(key)
+              source_instance.pending[key] = value
+            end
+          end
+        end
+      end
+
+      def run(trace_query_lazy: nil)
+        trace = Fiber[:__graphql_current_multiplex]&.current_trace
+        run = @pending_run || Async::Task.current?&.graphql_async_dataloader_run || raise(GraphQL::Error, "No available Run, GraphQL-Ruby internal bug")
+        @pending_run = nil
+        run.trace = trace
+        first_pass = true
+        trace&.begin_dataloader(self)
+        fiber_vars = get_fiber_variables
+        raised_error = nil
+        jobs = run.jobs
+        Sync do |_maybe_new_task|
+          # Make sure there's a new task instance to hold `.graphql_...` state:
+          task = Async::Task.new do |root_task|
+            run.root_task = root_task
+            root_task.graphql_async_dataloader_run = run
+            set_fiber_variables(fiber_vars)
+
+            while first_pass || run.running? || !jobs.empty?
+              first_pass = false
+              run_pending_steps(run)
+              run_sources(run)
+
+              if !run.lazies_at_depth.empty?
+                with_trace_query_lazy(trace_query_lazy) do
+                  run_next_pending_lazies(run)
+                  run_pending_steps(run)
+                end
+              end
+            end
+          rescue StandardError => err
+            raised_error = err
+            root_task.cancel
+          end
+
+          task.run
+          task.wait
+        end
+        create_pending_run
+        if raised_error
+          raise raised_error
+        end
+        trace&.end_dataloader(self)
       rescue UncaughtThrowError => e
         throw e.tag, e.value
       end
 
       private
 
-      def run_pending_steps(job_fibers, next_job_fibers, source_tasks, jobs_fiber_limit, trace)
-        while (f = (job_fibers.shift || (((job_fibers.size + next_job_fibers.size + source_tasks.size) < jobs_fiber_limit) && spawn_job_fiber(trace))))
-          if f.alive?
-            finished = run_fiber(f)
-            if !finished
-              next_job_fibers << f
+      def run_pending_steps(run)
+        run.new_queues
+
+        if (unsnoozed = run.snoozed_jobs_condition.waiting?)
+          run.snoozed_jobs_condition.signal
+        end
+        pending_jobs = run.jobs
+        while (!pending_jobs.empty? && (has_limit = run.jobs_bandwidth?)) || (unsnoozed)
+          unsnoozed = false
+          if has_limit
+            spawn_job_task(run)
+          end
+          run.wait_for_queues
+        end
+      ensure
+        run.close_queues
+      end
+
+      def spawn_job_task(run)
+        pending_jobs = run.jobs
+        if !pending_jobs.empty?
+          fiber_vars = get_fiber_variables
+          new_task = Async::Task.new(run.root_task) do |task|
+            run.trace&.dataloader_spawn_execution_fiber(pending_jobs)
+            task.graphql_async_dataloader_run = run
+            task.graphql_async_dataloader_condition = run.snoozed_jobs_condition
+            set_fiber_variables(fiber_vars)
+            while job = pending_jobs.shift
+              job.call
             end
+          ensure
+            cleanup_fiber
+            run.finished_tasks.push($! || task)
+            run.trace&.dataloader_fiber_exit
           end
+          run.started_tasks.push(new_task)
+          new_task
         end
-        job_fibers.concat(next_job_fibers)
-        next_job_fibers.clear
       end
 
-      def spawn_source_task(parent_task, condition, trace)
+      def run_sources(run)
+        run.new_queues
+
+        if (unsnoozed = run.snoozed_sources_condition.waiting?)
+          run.snoozed_sources_condition.signal
+        end
+
+        allowed_tasks = run.allowed_sources_tasks
+        while (has_pending = @source_cache.each_value.any? { |group_sources| group_sources.each_value.any?(&:pending?) } ) || unsnoozed
+          unsnoozed = false
+          if has_pending
+            spawn_source_task(run, allowed_tasks)
+          end
+          run.wait_for_queues
+        end
+      ensure
+        run.close_queues
+      end
+
+      #### TODO DRY  Had to duplicate to remove spawn_job_fiber
+      def run_next_pending_lazies(run)
+        smallest_depth = nil
+        run.lazies_at_depth.each_key do |depth_key|
+          smallest_depth ||= depth_key
+          if depth_key < smallest_depth
+            smallest_depth = depth_key
+          end
+        end
+
+        if smallest_depth
+          lazies = run.lazies_at_depth.delete(smallest_depth)
+          if !lazies.empty?
+            begin
+              run.new_queues
+              lazies.each_with_index do |l, idx|
+                append_job { l.value }
+              end
+              spawn_job_task(run) # Todo what was the last `true` condition?
+              run.wait_for_queues
+            ensure
+              run.close_queues
+            end
+          end
+        end
+      end
+
+      def spawn_source_task(run, num_tasks)
         pending_sources = nil
         @source_cache.each_value do |source_by_batch_params|
           source_by_batch_params.each_value do |source|
@@ -92,18 +330,30 @@ module GraphQL
         end
 
         if pending_sources
+          if num_tasks == Float::INFINITY
+            num_tasks = pending_sources.size
+          end
           fiber_vars = get_fiber_variables
-          parent_task.async do
-            trace&.dataloader_spawn_source_fiber(pending_sources)
-            set_fiber_variables(fiber_vars)
-            Fiber[:graphql_dataloader_next_tick] = condition
-            pending_sources.each do |s|
-              trace&.begin_dataloader_source(s)
-              s.run_pending_keys
-              trace&.end_dataloader_source(s)
+          trace = run.trace
+          num_tasks.times do
+            new_task = Async::Task.new(run.root_task) do |task|
+              task.graphql_async_dataloader_run = run
+              task.graphql_async_dataloader_condition = run.snoozed_sources_condition
+              trace&.dataloader_spawn_source_fiber(pending_sources)
+              set_fiber_variables(fiber_vars)
+              while (source = pending_sources.shift)
+                trace&.begin_dataloader_source(source)
+                source.run_pending_keys
+                trace&.end_dataloader_source(source)
+              end
+              nil
+            ensure
+              run.finished_tasks.push($! || task)
+              cleanup_fiber
+              trace&.dataloader_fiber_exit
             end
-            cleanup_fiber
-            trace&.dataloader_fiber_exit
+            run.started_tasks.push(new_task)
+            new_task
           end
         end
       end

data/lib/graphql/dataloader/source.rb

@@ -89,7 +89,8 @@ module GraphQL
           sync(pending_keys)
         end
 
-        result_keys.map { |k| result_for(k) }
+        result_keys.map! { |k| result_for(k) }
+        result_keys
       end
 
       # Subclasses must implement this method to return a value for each of `keys`
@@ -138,22 +139,25 @@ module GraphQL
       # @api private
       # @return [void]
       def run_pending_keys
-        if !@fetching.empty?
-          @fetching.each_key { |k| @pending.delete(k) }
-        end
+        @fetching.each_key { |k| @pending.delete(k) }
         return if @pending.empty?
         fetch_h = @pending
-        @pending = {}
         @fetching.merge!(fetch_h)
+        @pending = {}
         results = fetch(fetch_h.values)
-        fetch_h.each_with_index do |(key, _value), idx|
+        idx = 0
+
+        fetch_h.each_key do |key|
           @results[key] = results[idx]
+          @fetching.delete(key)
+          idx += 1
         end
         nil
       rescue StandardError => error
-        fetch_h.each_key { |key| @results[key] = error }
-      ensure
-        fetch_h && fetch_h.each_key { |k| @fetching.delete(k) }
+        fetch_h.each_key { |key|
+          @results[key] = error
+          @fetching.delete(key)
+        }
       end
 
       # These arguments are given to `dataloader.with(source_class, ...)`. The object
@@ -171,7 +175,11 @@ module GraphQL
       # @param batch_kwargs [Hash]
       # @return [Object]
       def self.batch_key_for(*batch_args, **batch_kwargs)
-        [*batch_args, **batch_kwargs]
+        if batch_kwargs.any? # rubocop:disable Development/NoneWithoutBlockCop
+          [*batch_args, **batch_kwargs]
+        else
+          batch_args
+        end
       end
 
       # Clear any already-loaded objects for this source

data/lib/graphql/dataloader.rb

@@ -58,7 +58,7 @@ module GraphQL
     end
 
     def initialize(nonblocking: self.class.default_nonblocking, fiber_limit: self.class.default_fiber_limit)
-      @source_cache = Hash.new { |h, k| h[k] = {} }
+      @source_cache = Hash.new { |h, k| h[k] = {} }.compare_by_identity
       @pending_jobs = []
       if !nonblocking.nil?
         @nonblocking = nonblocking

data/lib/graphql/execution/field_resolve_step.rb

@@ -49,11 +49,12 @@ module GraphQL
       end
 
       def value
+        return nil if @selections_step.killed
         query = @selections_step.query
         set_current_field
-        query.current_trace.begin_execute_field(@field_definition, @arguments, @field_results, query)
+        query.current_trace.begin_execute_field(@field_definition, @field_results, @arguments, query)
         sync(@field_results)
-        query.current_trace.end_execute_field(@field_definition, @arguments, @field_results, query, @field_results)
+        query.current_trace.end_execute_field(@field_definition, @field_results, @arguments, query, @field_results)
         @runner.add_step(self)
         true
       ensure
@@ -79,7 +80,9 @@ module GraphQL
       end
 
       def call
+        return nil if @selections_step.killed
         set_current_field if @field_definition
+
         if @enqueued_authorization
           enqueue_next_steps
         elsif @finish_extension_idx
@@ -102,24 +105,64 @@ module GraphQL
         set_current_field(nil)
       end
 
-      def add_graphql_error(err)
+      def add_graphql_error(result, key, err, return_type: @field_definition.type)
         err.path = path
         if err.ast_node.nil?
           err.ast_nodes = ast_nodes
         end
-        @selections_step.query.context.add_error(err)
+        @runner.add_finalizer(@selections_step.query, result, key, err)
+        if !err.is_a?(GraphQL::Execution::Skip)
+          field_type = return_type
+          should_propagate_null = field_type.non_null?
+          while (should_propagate_null == false && field_type.kind.wraps?)
+            field_type = field_type.of_type
+            should_propagate_null = field_type.non_null?
+          end
+          if should_propagate_null
+            propagate_nulls
+          end
+        end
         err
       end
 
+      def propagate_nulls
+        propagating_null = true
+        highest_nulled_depth = path.size
+        highest_list_depth = nil
+        current_field_step = self
+        while current_field_step
+          return_type = current_field_step.field_definition.type
+          if propagating_null && return_type.non_null?
+            highest_nulled_depth = current_field_step.path.size
+          else
+            propagating_null = false
+          end
+
+          if return_type.list?
+            highest_list_depth = current_field_step.path.size
+          end
+
+          current_field_step = current_field_step.selections_step.field_resolve_step
+        end
+
+        if highest_list_depth.nil? || highest_nulled_depth <= highest_list_depth
+          kill_field_step = self
+          while kill_field_step && highest_nulled_depth <= kill_field_step.path.size
+            kill_field_step.selections_step.killed = true
+            kill_field_step = kill_field_step.selections_step.field_resolve_step
+          end
+        end
+      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)
+        @field_results = [first_error]
+        @results = [@selections_step.results.first]
         if errors
           errors.each do |e|
-            add_graphql_error(e)
+            add_graphql_error(@results.first, key, e)
           end
         end
-        @results ||= @selections_step.results
         build_results
       end
 
@@ -226,7 +269,7 @@ module GraphQL
                   authorized_results << @results[i]
                 end
               rescue GraphQL::ExecutionError => exec_err
-                add_graphql_error(exec_err)
+                add_graphql_error(@results[i], key, exec_err)
               end
             end
             i += 1
@@ -244,7 +287,7 @@ module GraphQL
           @was_scoped = true
         end
 
-        query.current_trace.begin_execute_field(@field_definition, @arguments, authorized_objects, query)
+        query.current_trace.begin_execute_field(@field_definition, authorized_objects, @arguments, query)
 
         if @runner.uses_runtime_directives
           if @ast_nodes.nil? || @ast_nodes.size == 1
@@ -319,7 +362,7 @@ module GraphQL
           @field_results = resolve_batch(authorized_objects, ctx, @arguments)
         end
 
-        query.current_trace.end_execute_field(@field_definition, @arguments, authorized_objects, query, @field_results)
+        query.current_trace.end_execute_field(@field_definition, authorized_objects, @arguments, query, @field_results)
 
         if any_lazy_results?
           @runner.dataloader.lazy_at_depth(path.size, self)
@@ -331,12 +374,12 @@ module GraphQL
           end
         end
       rescue GraphQL::ExecutionError => err
-        add_graphql_error(err)
+        build_errors_result(nil, 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)
+          add_graphql_error(@results[0], key, err)
         end
       end
 
@@ -458,13 +501,13 @@ module GraphQL
       end
 
       def finish_leaf_result(result_h, key, field_result, return_type, ctx)
-        final_field_result = build_leaf_result(field_result, return_type, ctx, false)
+        final_field_result = build_leaf_result(result_h, key, 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)
+      def build_leaf_result(result_h, result_key, field_result, return_type, ctx, is_from_array)
         if field_result.nil?
           if return_type.non_null?
             add_non_null_error(is_from_array)
@@ -473,7 +516,7 @@ module GraphQL
           end
         elsif field_result.is_a?(Finalizer)
           if field_result.is_a?(GraphQL::RuntimeError)
-            add_graphql_error(field_result)
+            add_graphql_error(result_h, result_key, field_result, return_type: return_type)
           else
             field_result.path = path
             @runner.add_finalizer(ctx.query, result_h, key, field_result)
@@ -484,7 +527,11 @@ module GraphQL
           end
 
           inner_type = return_type.of_type
-          field_result.map { |item| build_leaf_result(item, inner_type, ctx, true) }
+          result_a = Array.new(field_result.size)
+          field_result.each_with_index do |item, idx|
+            result_a[idx] = build_leaf_result(result_a, idx, item, inner_type, ctx, true)
+          end
+          result_a
         else
           return_type.coerce_result(field_result, ctx)
         end
@@ -526,6 +573,7 @@ module GraphQL
               query.current_trace.objects(obj_type, next_objects, ctx)
               @runner.add_step(SelectionsStep.new(
                 path: path,
+                field_resolve_step: self,
                 parent_type: obj_type,
                 selections: @next_selections,
                 objects: next_objects,
@@ -538,6 +586,7 @@ module GraphQL
             query.current_trace.objects(@static_type, @all_next_objects, ctx)
             @runner.add_step(SelectionsStep.new(
               path: path,
+              field_resolve_step: self,
               parent_type: @static_type,
               selections: @next_selections,
               objects: @all_next_objects,
@@ -558,7 +607,11 @@ module GraphQL
 
       def add_non_null_error(is_from_array)
         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)
+        nn_result = @runner.schema.type_error(err, @selections_step.query.context)
+        if nn_result.nil?
+          propagate_nulls
+        end
+        nn_result
       end
 
       def set_current_field(new_value = @field_definition)
@@ -576,7 +629,7 @@ module GraphQL
           end
         elsif field_result.is_a?(Finalizer)
           graphql_result[key] = if field_result.is_a?(GraphQL::RuntimeError)
-            add_graphql_error(field_result)
+            add_graphql_error(graphql_result, key, field_result)
           else
             field_result.path = path
             @runner.add_finalizer(@selections_step.query, graphql_result, key, field_result)

data/lib/graphql/execution/finalize.rb

@@ -33,14 +33,15 @@ module GraphQL
 
           targets.each_with_index do |target, idx|
             if target.is_a?(Hash)
-              if target[key].equal?(err)
+              value_at_key = target[key]
+              if value_at_key.equal?(err)
                 tf = @finalizers[target] ||= {}.compare_by_identity
                 tf[key] = err
                 @finalizers_count += 1
-              elsif (arr = target[key]).is_a?(Array)
-                arr.each_with_index do |el, idx|
+              elsif value_at_key.is_a?(Array)
+                value_at_key.each_with_index do |el, idx|
                   if el.equal?(err)
-                    tf = @finalizers[arr] ||= {}.compare_by_identity
+                    tf = @finalizers[value_at_key] ||= {}.compare_by_identity
                     tf[idx] = err
                     @finalizers_count += 1
                   end
@@ -150,7 +151,7 @@ module GraphQL
           when Language::Nodes::InlineFragment
             static_type_at_result = @static_type_at[result_h]
             if static_type_at_result && (
-                (t = ast_selection.type).nil? ||
+              (t = ast_selection.type).nil? ||
                 @runner.type_condition_applies?(@query.context, static_type_at_result, t.name)
               )
               result_h = check_object_result(result_h, parent_type, ast_selection.selections)
@@ -170,9 +171,7 @@ module GraphQL
       end
 
       def check_list_result(result_arr, inner_type, ast_selections)
-        inner_type_non_null = false
-        if inner_type.non_null?
-          inner_type_non_null = true
+        if (inner_type_non_null = inner_type.non_null?)
           inner_type = inner_type.of_type
         end
 

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

@@ -492,12 +492,6 @@ module GraphQL
               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 selection_result.graphql_is_eager
-            @dataloader.run
-          end
         end
 
         def set_result(selection_result, result_name, value, is_child_result, is_non_null)

data/lib/graphql/execution/prepare_object_step.rb

@@ -73,6 +73,10 @@ module GraphQL
         @field_resolve_step.set_current_field(nil)
       end
 
+      def add_field_error(err)
+        @field_resolve_step.add_graphql_error(@graphql_result, @key, err)
+      end
+
       def authorize
         if @field_resolve_step.was_scoped && !@resolved_type.reauthorize_scoped_objects
           @authorized_value = @object
@@ -96,13 +100,13 @@ module GraphQL
           create_result
         end
       rescue GraphQL::RuntimeError => err
-        @graphql_result[@key] = @field_resolve_step.add_graphql_error(err)
+        @graphql_result[@key] = add_field_error(err)
       rescue StandardError => err
         query ||= @field_resolve_step.selections_step.query
         begin
           query.handle_or_reraise(err, field: @field_resolve_step.field_definition, arguments: @field_resolve_step.arguments, object: @object) # rubocop:disable Development/ContextIsPassedCop
         rescue GraphQL::RuntimeError => err
-          @graphql_result[@key] = @field_resolve_step.add_graphql_error(err)
+          @graphql_result[@key] = add_field_error(err)
         end
       end
 
@@ -120,13 +124,13 @@ module GraphQL
             elsif @is_non_null
               @graphql_result[@key] = @field_resolve_step.add_non_null_error(@is_from_array)
             else
-              @graphql_result[@key] = @field_resolve_step.add_graphql_error(@authorization_error)
+              @graphql_result[@key] = add_field_error(@authorization_error)
             end
           rescue GraphQL::RuntimeError => err
             if @is_non_null
               @graphql_result[@key] = @field_resolve_step.add_non_null_error(@is_from_array)
             else
-              @graphql_result[@key] = @field_resolve_step.add_graphql_error(err)
+              @graphql_result[@key] = add_field_error(err)
             end
           end
         end

data/lib/graphql/execution/runner.rb

@@ -298,6 +298,7 @@ module GraphQL
           if query.query?
             isolated_steps[0] << SelectionsStep.new(
               parent_type: root_type,
+              field_resolve_step: nil,
               selections: selected_operation.selections,
               objects: objects,
               results: [data],
@@ -317,6 +318,7 @@ module GraphQL
               isolated_steps << [SelectionsStep.new(
                 clobber: false, # `data` is being shared among several selections steps
                 parent_type: root_type,
+                field_resolve_step: field_resolve_step,
                 selections: field_resolve_step.ast_nodes || Array(field_resolve_step.ast_node),
                 objects: objects,
                 results: [data],
@@ -332,6 +334,7 @@ module GraphQL
             end
             isolated_steps[0] << SelectionsStep.new(
               parent_type: root_type,
+              field_resolve_step: nil,
               selections: selected_operation.selections,
               objects: objects,
               results: [data],
@@ -355,6 +358,7 @@ module GraphQL
           results << { "data" => data }
           isolated_steps[0] << SelectionsStep.new(
             parent_type: resolved_type,
+            field_resolve_step: nil,
             selections: selected_operation.selections,
             objects: objects,
             results: [data],
@@ -372,6 +376,7 @@ module GraphQL
             results << { "data" => list_result }
             isolated_steps[0] << SelectionsStep.new(
               parent_type: inner_type,
+              field_resolve_step: nil,
               selections: selected_operation.selections,
               objects: root_value,
               results: list_result,
@@ -420,6 +425,7 @@ module GraphQL
         selections = partial.ast_nodes
         dummy_ss = SelectionsStep.new(
           parent_type: nil,
+          field_resolve_step: nil,
           selections: selections,
           objects: nil,
           results: nil,

data/lib/graphql/execution/selections_step.rb

@@ -2,8 +2,9 @@
 module GraphQL
   module Execution
     class SelectionsStep
-      def initialize(parent_type:, selections:, objects:, results:, runner:, query:, path:, clobber: true)
+      def initialize(parent_type:, field_resolve_step:, selections:, objects:, results:, runner:, query:, path:, clobber: true)
         @path = path
+        @field_resolve_step = field_resolve_step
         @parent_type = parent_type
         @selections = selections
         @runner = runner
@@ -12,10 +13,13 @@ module GraphQL
         @query = query
         @graphql_objects = nil
         @all_selections = nil
+        @killed = false
         @clobber = clobber
       end
 
-      attr_reader :path, :query, :objects, :results
+      attr_reader :path, :query, :objects, :results, :field_resolve_step
+
+      attr_accessor :killed
 
       def graphql_objects
         @graphql_objects ||= @objects.map do |obj|

data/lib/graphql/execution_error.rb

@@ -26,6 +26,10 @@ module GraphQL
     end
 
     def finalize_graphql_result(query, result_data, key)
+      add_this_error = !query.context.errors.any? { |e| e.eql?(self) }
+      if add_this_error
+        query.context.add_error(self)
+      end
       if ast_node.is_a?(GraphQL::Language::Nodes::Directive)
         # This is for backwards compatibility ... what does the spec say?
         result_data.delete(key)

data/lib/graphql/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module GraphQL
-  VERSION = "2.6.3"
+  VERSION = "2.6.5"
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.6.3
+  version: 2.6.5
 platform: ruby
 authors:
 - Robert Mosolgo
 bindir: bin
 cert_chain: []
-date: 2026-05-26 00:00:00.000000000 Z
+date: 2026-07-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64