graphql 2.6.3 → 2.6.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 16abc9c2a5eda0da251dbe7e14433241bc7d038d2527926832ceb29336fb857a
-  data.tar.gz: c89bd2a4b340ca30bfa7b823f51e4671972355d54bd56fdaed598c13a415c3b3
+  metadata.gz: 3366525e188ac8b81b4dc7bdc8e34bb1839153fbec23d8e2a5faf07c02b56aa6
+  data.tar.gz: 414d8f17cee8d40adf8c5923427e83d187efdbd08871c7b9d8bbd4fa13b0e550
 SHA512:
-  metadata.gz: 6452d2a517c502b4a8934582d060885a5f6462de244a1f331433f1076dc57a879cdd081e147f70925064a99607e0794fcf6eadad7a3f4a9111a5ab979c552554
-  data.tar.gz: b6a0219606d905fc885ab2192596d1acb1d92bce407defc751bfafb1a7199e9c32275c1d3202f3246251e72b80554698b1f54920f76178f1ddc81b41d628bacd
+  metadata.gz: f4423d53187dcf97e67ae1ba93cc9b5135c7db35cab04abc5533b96e97e3abd5d2c4bbbe683a64abc0117a022743a53df804d170e5fbd0fd7430a3987466531b
+  data.tar.gz: c6093a9a53e554aed992da96b80007bbe10df7ac9552c4a1dc0cce19ae8a3f33fd3e2cb0858c117c1e061c4b996a4af8a7b161b31b4f3806ff3a30a84dfaddb2

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,110 +1,316 @@
 # 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
+
+      # @api private
+      attr_reader :pending_sources
+
+      def create_pending_run
+        jobs_fiber_limit, total_fiber_limit = calculate_fiber_limit
+        @pending_run = Run.new(self, 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.tasks_channel.push([:paused_task, task])
+        condition = task.graphql_async_dataloader_condition
+        condition.wait
+        run.tasks_channel.push([:resumed_task, 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
-
-            run_pending_steps(job_fibers, next_job_fibers, source_tasks, jobs_fiber_limit, trace)
-
-            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
+      class Run
+        def initialize(dataloader, total_fiber_limit, jobs_fiber_limit)
+          @dataloader = dataloader
+          @root_task = nil
+          @trace = nil
+          @jobs = []
+
+          @total_fiber_limit = total_fiber_limit
+          @jobs_fiber_limit = jobs_fiber_limit
+          @lazies_at_depth = Hash.new { |h, k| h[k] = [] }
+
+          @running_tasks = nil
+          @tasks_channel = nil
+          @tasks_channel_task = nil
+          @finished_all_tasks = 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,  :snoozed_jobs_condition, :snoozed_sources_condition, :tasks_channel
+
+        def jobs_bandwidth?
+          running_count < @jobs_fiber_limit
+        end
+
+        def sources_bandwidth?
+          running_count < current_sources_fiber_limit
+        end
+
+        def close_queues
+          @tasks_channel.close
+          @tasks_channel_task.cancel
+        end
+
+        def wait_for_queues
+          @finished_all_tasks.wait
+          @finished_all_tasks = Async::Promise.new
+        end
+
+        def wait_for_no_running_tasks
+          @no_running_tasks.wait
+          @no_running_tasks = Async::Promise.new
+        end
+
+        def new_queues(mode)
+          @tasks_channel = Async::Queue.new(parent: @root_task)
+          @no_running_tasks = Async::Promise.new
+          @finished_all_tasks = Async::Promise.new
+          @running_tasks = []
+          @tasks_channel_task = @root_task.async do |_t|
+            while ((msg, data) = @tasks_channel.wait)
+              case msg
+              when :started_task
+                @running_tasks.push(data)
+                data.run
+              when :resumed_task
+                @running_tasks.push(data)
+              when :finished_task, :paused_task
+                @running_tasks.delete(data)
+                has_pending_work = mode == :jobs ? @jobs.any? : @dataloader.pending_sources.any?(&:pending?) # rubocop:disable Development/NoneWithoutBlockCop
+                if @running_tasks.empty?
+                  @no_running_tasks.resolve(true)
+                  has_bandwidth = mode == :jobs ? jobs_bandwidth? : sources_bandwidth?
+                  if (!has_pending_work) || (!has_bandwidth)
+                    @finished_all_tasks.resolve(true)
                   end
                 end
-                sources_condition.signal
-                source_tasks.concat(next_source_tasks)
-                next_source_tasks.clear
+              when :task_error
+                @no_running_tasks.resolve(true)
+                @finished_all_tasks.reject(data)
+              else
+                raise ArgumentError, "Unknown tasks_channel action: #{msg.inspect}"
               end
             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)
-              end
+        def running?
+          @snoozed_jobs_condition.waiting? || @snoozed_sources_condition.waiting?
+        end
+
+        def current_sources_fiber_limit
+          within_limit = @total_fiber_limit - running_count
+          if within_limit < 1
+            1
+          else
+            within_limit
+          end
+        end
+
+        private
+
+        def running_count
+          @snoozed_jobs_condition.instance_variable_get(:@ready).num_waiting +
+            @snoozed_sources_condition.instance_variable_get(:@ready).num_waiting +
+            (@running_tasks&.size || 0)
+        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
-          trace&.end_dataloader(self)
         end
 
-        manager.resume
-        if manager.alive?
-          raise "Invariant: Manager didn't terminate successfully: #{manager}"
+        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|
+            next if source_instance.results.key?(key)
 
-      rescue UncaughtThrowError => e
-        throw e.tag, e.value
+            queue_pending_source(source_instance) if source_instance.pending.empty?
+            source_instance.pending[key] = value
+          end
+        end
       end
 
-      private
+      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_queue(run, run.snoozed_jobs_condition, :jobs)
+              run_queue(run, run.snoozed_sources_condition, :sources)
 
-      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
+              if !run.lazies_at_depth.empty?
+                with_trace_query_lazy(trace_query_lazy) do
+                  if enqueue_next_pending_lazies(run.lazies_at_depth)
+                    run_queue(run, run.snoozed_jobs_condition, :jobs)
+                  end
+                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
-        job_fibers.concat(next_job_fibers)
-        next_job_fibers.clear
+        trace&.end_dataloader(self)
+      rescue UncaughtThrowError => e
+        throw e.tag, e.value
       end
 
-      def spawn_source_task(parent_task, condition, trace)
-        pending_sources = nil
-        @source_cache.each_value do |source_by_batch_params|
-          source_by_batch_params.each_value do |source|
-            if source.pending?
-              pending_sources ||= []
-              pending_sources << source
+      private
+
+      def run_queue(run, condition, mode)
+        should_wait_for_all_tasks = false
+
+        if (unsnoozed = condition.waiting?)
+          should_wait_for_all_tasks = true
+          run.new_queues(mode)
+          condition.signal
+        end
+
+        while (pending_work = (mode == :jobs) ? (!run.jobs.empty? && run.jobs_bandwidth? ? run.jobs : nil) : (drain_pending_sources)) || unsnoozed
+          unsnoozed = false
+          if pending_work
+            if should_wait_for_all_tasks == false
+              should_wait_for_all_tasks = true
+              run.new_queues(mode)
+            end
+            num_tasks = mode == :sources ? run.current_sources_fiber_limit : 1
+            if num_tasks > pending_work.size
+              num_tasks = pending_work.size
             end
+            spawn_tasks(run, mode, condition, pending_work, num_tasks)
           end
+
+          run.wait_for_no_running_tasks
+        end
+
+        if should_wait_for_all_tasks
+          run.wait_for_queues
+        end
+      ensure
+        if should_wait_for_all_tasks
+          run.close_queues
         end
+      end
 
-        if pending_sources
-          fiber_vars = get_fiber_variables
-          parent_task.async do
-            trace&.dataloader_spawn_source_fiber(pending_sources)
+      # Use a separate method for this so that the outer loop's reassignment of `pending_work`
+      # doesn't affect already-running tasks which (would) close over that variable
+      def spawn_tasks(run, mode, condition, pending_work, num_tasks)
+        fiber_vars = get_fiber_variables
+        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 = condition
             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)
+            case mode
+            when :jobs
+              trace&.dataloader_spawn_execution_fiber(pending_work)
+              while job = pending_work.shift
+                job.call
+              end
+            when :sources
+              trace&.dataloader_spawn_source_fiber(pending_work)
+              while (source = pending_work.shift)
+                Fiber[:__graphql_current_dataloader_source] = source
+                trace&.begin_dataloader_source(source)
+                source.run_pending_keys
+                trace&.end_dataloader_source(source)
+              end
+            else
+              raise ArgumentError, "Unknown mode: #{mode.inspect}"
             end
+            nil
+          rescue StandardError => err
+            run.tasks_channel.push([:task_error, err])
+          else
+            run.tasks_channel.push([:finished_task, task])
+          ensure
             cleanup_fiber
             trace&.dataloader_fiber_exit
           end
+          run.tasks_channel.push([:started_task, new_task])
         end
       end
     end

data/lib/graphql/dataloader/source.rb

@@ -20,9 +20,7 @@ module GraphQL
       # @return [Dataloader::Request] a pending request for a value from `key`. Call `.load` on that object to wait for the result.
       def request(value)
         res_key = result_key_for(value)
-        if !@results.key?(res_key)
-          @pending[res_key] ||= normalize_fetch_key(value)
-        end
+        add_pending_key(res_key, value)
         Dataloader::Request.new(self, value)
       end
 
@@ -51,9 +49,7 @@ module GraphQL
       def request_all(values)
         values.each do |v|
           res_key = result_key_for(v)
-          if !@results.key?(res_key)
-            @pending[res_key] ||= normalize_fetch_key(v)
-          end
+          add_pending_key(res_key, v)
         end
         Dataloader::RequestAll.new(self, values)
       end
@@ -65,7 +61,7 @@ module GraphQL
         if @results.key?(result_key)
           result_for(result_key)
         else
-          @pending[result_key] ||= normalize_fetch_key(value)
+          add_pending_key(result_key, value)
           sync([result_key])
           result_for(result_key)
         end
@@ -79,8 +75,7 @@ module GraphQL
         values.each { |v|
           k = result_key_for(v)
           result_keys << k
-          if !@results.key?(k)
-            @pending[k] ||= normalize_fetch_key(v)
+          if add_pending_key(k, v)
             pending_keys << k
           end
         }
@@ -89,7 +84,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`
@@ -105,6 +101,7 @@ module GraphQL
       # Then run the batch and update the cache.
       # @return [void]
       def sync(pending_result_keys)
+        @dataloader.queue_pending_source(self) if pending?
         @dataloader.yield(self)
         iterations = 0
         while pending_result_keys.any? { |key| !@results.key?(key) }
@@ -138,22 +135,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 +171,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
@@ -185,6 +189,15 @@ module GraphQL
 
       private
 
+      def add_pending_key(result_key, value)
+        return false if @results.key?(result_key)
+
+        was_empty = @pending.empty?
+        @pending[result_key] ||= normalize_fetch_key(value)
+        @dataloader.queue_pending_source(self) if was_empty
+        true
+      end
+
       # Reads and returns the result for the key from the internal cache, or raises an error if the result was an error
       # @param key [Object] key passed to {#load} or {#load_all}
       # @return [Object] The result from {#fetch} for `key`.

data/lib/graphql/dataloader.rb

@@ -58,7 +58,9 @@ 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_source_set = Set.new.compare_by_identity
+      @pending_sources = []
       @pending_jobs = []
       if !nonblocking.nil?
         @nonblocking = nonblocking
@@ -108,7 +110,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_ENGINE == "ruby" && RUBY_ENGINE < "3") || RUBY_ENGINE == "truffleruby" # truffle-ruby wasn't doing well with the implementation below
+    if (RUBY_ENGINE == "ruby" && RUBY_VERSION < "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
@@ -148,6 +150,14 @@ module GraphQL
       nil
     end
 
+    # @api private
+    def queue_pending_source(source)
+      if @pending_source_set.add?(source)
+        @pending_sources << source
+      end
+      nil
+    end
+
     # Clear any already-loaded objects from {Source} caches
     # @return [void]
     def clear_cache
@@ -187,9 +197,10 @@ module GraphQL
       @lazies_at_depth = prev_lazies_at_depth
       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
+          next if source_instance.results.key?(key)
+
+          queue_pending_source(source_instance) if source_instance.pending.empty?
+          source_instance.pending[key] = value
         end
       end
     end
@@ -212,8 +223,10 @@ module GraphQL
 
           if !@lazies_at_depth.empty?
             with_trace_query_lazy(trace_query_lazy) do
-              run_next_pending_lazies(job_fibers, trace)
-              run_pending_steps(trace, job_fibers, next_job_fibers, jobs_fiber_limit, source_fibers, next_source_fibers, total_fiber_limit)
+              if enqueue_next_pending_lazies(@lazies_at_depth)
+                job_fibers.unshift(spawn_job_fiber(trace))
+                run_pending_steps(trace, job_fibers, next_job_fibers, jobs_fiber_limit, source_fibers, next_source_fibers, total_fiber_limit)
+              end
             end
           end
         end
@@ -274,24 +287,19 @@ module GraphQL
 
     private
 
-    def run_next_pending_lazies(job_fibers, trace)
-      smallest_depth = nil
-      @lazies_at_depth.each_key do |depth_key|
-        smallest_depth ||= depth_key
-        if depth_key < smallest_depth
-          smallest_depth = depth_key
-        end
-      end
+    # Returns true if anything was actually enqueued
+    def enqueue_next_pending_lazies(lazies_at_depth)
+      smallest_depth = lazies_at_depth.each_key.min
+      return false if smallest_depth.nil?
 
-      if smallest_depth
-        lazies = @lazies_at_depth.delete(smallest_depth)
-        if !lazies.empty?
-          lazies.each_with_index do |l, idx|
-            append_job { l.value }
-          end
-          job_fibers.unshift(spawn_job_fiber(trace))
-        end
+      lazies = lazies_at_depth.delete(smallest_depth)
+      return false if lazies.empty?
+
+      lazies.each do |lazy|
+        append_job { lazy.value }
       end
+
+      true
     end
 
     def run_pending_steps(trace, job_fibers, next_job_fibers, jobs_fiber_limit, source_fibers, next_source_fibers, total_fiber_limit)
@@ -305,7 +313,7 @@ module GraphQL
       end
       join_queues(job_fibers, next_job_fibers)
 
-      while (!source_fibers.empty? || @source_cache.each_value.any? { |group_sources| group_sources.each_value.any?(&:pending?) })
+      while (!source_fibers.empty? || !@pending_sources.empty?)
         while (f = source_fibers.shift || (((job_fibers.size + source_fibers.size + next_source_fibers.size + next_job_fibers.size) < total_fiber_limit) && spawn_source_fiber(trace)))
           if f.alive?
             finished = run_fiber(f)
@@ -356,21 +364,29 @@ module GraphQL
       end
     end
 
-    def spawn_source_fiber(trace)
-      pending_sources = nil
-      @source_cache.each_value do |source_by_batch_params|
-        source_by_batch_params.each_value do |source|
-          if source.pending?
-            pending_sources ||= []
-            pending_sources << source
-          end
-        end
+    def drain_pending_sources
+      pending_sources = @pending_sources
+      @pending_sources = []
+      @pending_source_set.clear
+
+      pending_sources.select!(&:pending?)
+      pending_sources.empty? ? nil : pending_sources
+    end
+
+    def dequeue_pending_source
+      while (source = @pending_sources.shift)
+        @pending_source_set.delete(source)
+        return source if source.pending?
       end
+    end
 
-      if pending_sources
+    def spawn_source_fiber(trace)
+      if !@pending_sources.empty?
         spawn_fiber do
-          trace&.dataloader_spawn_source_fiber(pending_sources)
-          pending_sources.each do |source|
+          trace&.dataloader_spawn_source_fiber(@pending_sources)
+          # This will find sources which were enqueued during `#fetch`:
+          while (source = dequeue_pending_source)
+            next if !source.pending?
             Fiber[:__graphql_current_dataloader_source] = source
             trace&.begin_dataloader_source(source)
             source.run_pending_keys

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)
@@ -771,8 +765,7 @@ module GraphQL
 
                 response_list
               rescue NoMethodError => err
-                # Ruby 2.2 doesn't have NoMethodError#receiver, can't check that one in this case. (It's been EOL since 2017.)
-                if err.name == :each && (err.respond_to?(:receiver) ? err.receiver == value : true)
+                if err.name == :each && err.receiver == value
                   # This happens when the GraphQL schema doesn't match the implementation. Help the dev debug.
                   raise ListResultFailedError.new(value: value, field: field, path: current_path)
                 else

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

@@ -281,8 +281,8 @@ module GraphQL
               end
               result = dir_defn.resolve_operation(selected_operation, query, objects, dir_args, query.context)
               if result.is_a?(Finalizer)
-                result.path = path
-                add_finalizer(query, result, nil, data)
+                result.path = beginning_path
+                add_finalizer(query, data, nil, result)
                 if result.is_a?(HaltExecution)
                   continue_execution = false
                   break
@@ -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/query/variables.rb

@@ -19,7 +19,7 @@ module GraphQL
         @storage = ast_variables.each_with_object({}) do |ast_variable, memo|
           if schema.validate_max_errors && schema.validate_max_errors <= @errors.count
             add_max_errors_reached_message
-            break
+            break memo
           end
           # Find the right value for this variable:
           # - First, use the value provided at runtime

data/lib/graphql/schema/directive.rb

@@ -168,6 +168,9 @@ module GraphQL
               # Let validation handle this
               value
             end
+          elsif arg_defn.default_value?
+            value = arg_defn.default_value
+            graphql_value = arg_type.coerce_isolated_result(value) unless value.nil?
           else
             value = graphql_value = nil
           end

data/lib/graphql/schema/resolver.rb

@@ -83,7 +83,7 @@ module GraphQL
             is_authed, new_return_value = authorized?(**@prepared_arguments)
           rescue GraphQL::UnauthorizedError  => err
             new_return_value = q.schema.unauthorized_object(err)
-            is_authed = true # the error was handled
+            is_authed = false
           end
         end
 

data/lib/graphql/schema/wrapper.rb

@@ -25,6 +25,10 @@ module GraphQL
       def ==(other)
         self.class == other.class && of_type == other.of_type
       end
+
+      def deconstruct_keys(_keys)
+        { of_type: of_type }
+      end
     end
   end
 end

data/lib/graphql/schema.rb

@@ -665,8 +665,8 @@ module GraphQL
           inherited_um = find_inherited_value(:union_memberships, EMPTY_HASH).fetch(type.graphql_name, EMPTY_ARRAY)
           own_um + inherited_um
         else
-          joined_um = own_union_memberships.dup
-          find_inherited_value(:union_memberhips, EMPTY_HASH).each do |k, v|
+          joined_um = own_union_memberships.transform_values(&:dup)
+          find_inherited_value(:union_memberships, EMPTY_HASH).each do |k, v|
             um = joined_um[k] ||= []
             um.concat(v)
           end
@@ -860,7 +860,7 @@ module GraphQL
       # @return [Array<GraphQL::StaticValidation::Error >]
       def validate(string_or_document, rules: nil, context: nil)
         doc = if string_or_document.is_a?(String)
-          GraphQL.parse(string_or_document)
+          GraphQL.parse(string_or_document, max_tokens: max_query_string_tokens)
         else
           string_or_document
         end

data/lib/graphql/version.rb

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.6.3
+  version: 2.6.6
 platform: ruby
 authors:
 - Robert Mosolgo
 bindir: bin
 cert_chain: []
-date: 2026-05-26 00:00:00.000000000 Z
+date: 2026-07-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -261,34 +261,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: jekyll
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: jekyll-sass-converter
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.2'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.2'
 - !ruby/object:Gem::Dependency
   name: yard
   requirement: !ruby/object:Gem::Requirement
@@ -303,34 +275,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: jekyll-algolia
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: jekyll-redirect-from
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: m
   requirement: !ruby/object:Gem::Requirement