graphql 2.6.3 → 2.6.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 16abc9c2a5eda0da251dbe7e14433241bc7d038d2527926832ceb29336fb857a
-  data.tar.gz: c89bd2a4b340ca30bfa7b823f51e4671972355d54bd56fdaed598c13a415c3b3
+  metadata.gz: 9f149d55f546745aa90807691e6ad3bc31528f341e6055ffc2146a06df033175
+  data.tar.gz: 4c153cc3bdd4ec208dbcf4e98de46834e8abd19bd338d553034245a452b84546
 SHA512:
-  metadata.gz: 6452d2a517c502b4a8934582d060885a5f6462de244a1f331433f1076dc57a879cdd081e147f70925064a99607e0794fcf6eadad7a3f4a9111a5ab979c552554
-  data.tar.gz: b6a0219606d905fc885ab2192596d1acb1d92bce407defc751bfafb1a7199e9c32275c1d3202f3246251e72b80554698b1f54920f76178f1ddc81b41d628bacd
+  metadata.gz: 6f663ca7de9f4943173238e3bde41d06d9cd36cf1fbdeabffd8096e19bdd00fd62ec1a6d4aa4f3938297e94d090d0b1f1013931def778c77f7519ae598bcd431
+  data.tar.gz: 2d76f7eff773781453598832e119c16f589ac8f8644cba892fa137fbaf4aa29545eed4f1606f731192dce4af1ff065101cf00a436eb257da4864a687e4b644ac

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,234 @@
 # frozen_string_literal: true
+
 module GraphQL
   class Dataloader
     class AsyncDataloader < Dataloader
       def yield(source = Fiber[:__graphql_current_dataloader_source])
-        trace = Fiber[:__graphql_current_multiplex]&.current_trace
+        run = Fiber[:__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
+        task = Async::Task.current
+        run.finished_tasks.push(task)
+        condition = Fiber[:__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(root_task, trace, total_fiber_limit, jobs_fiber_limit)
+          @root_task = root_task
+          @trace = trace
+          @total_fiber_limit = total_fiber_limit
+          @jobs_fiber_limit = jobs_fiber_limit
 
-            run_pending_steps(job_fibers, next_job_fibers, source_tasks, jobs_fiber_limit, trace)
+          @finished_tasks = nil
+          @started_tasks = nil
+          @started_count_task = nil
+          @finished_count_task = nil
+          @finished_all_tasks = nil
+          @finished_first_pass = nil
 
-            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
+          @snoozed_jobs_condition = Async::Condition.new
+          @snoozed_sources_condition = Async::Condition.new
+        end
+
+        attr_reader :root_task, :trace, :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
+            @finished_first_pass.wait
+            while _t = @started_tasks.wait
+              @started_count += 1
+              if @finished_count == @started_count
+                @finished_all_tasks.resolve(true)
+              end
+            end
+          end
+
+          @finished_count_task = @root_task.async do
+            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
-                sources_condition.signal
-                source_tasks.concat(next_source_tasks)
-                next_source_tasks.clear
               end
             end
+          end
+        end
+
+        def running?
+          @snoozed_jobs_condition.waiting? || @snoozed_sources_condition.waiting?
+        end
+      end
+
+      def run(trace_query_lazy: nil)
+        trace = Fiber[:__graphql_current_multiplex]&.current_trace
+        jobs_fiber_limit, total_fiber_limit = calculate_fiber_limit
+        first_pass = true
+        trace&.begin_dataloader(self)
+        fiber_vars = get_fiber_variables
+        raised_error = nil
+        Sync do |root_task|
+          run = Run.new(root_task, trace, total_fiber_limit, jobs_fiber_limit)
+          set_fiber_variables(fiber_vars)
+
+          while first_pass || run.running? || !@pending_jobs.empty?
+            first_pass = false
+            run_pending_steps(run)
+            run_sources(run)
 
             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)
+                run_next_pending_lazies(run)
+                run_pending_steps(run)
               end
             end
           end
-          trace&.end_dataloader(self)
+        rescue StandardError => err
+          raised_error = err
+          root_task.cancel
         end
 
-        manager.resume
-        if manager.alive?
-          raise "Invariant: Manager didn't terminate successfully: #{manager}"
+        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
+
+        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)
+        if !@pending_jobs.empty?
+          fiber_vars = get_fiber_variables
+          run.root_task.async do |task|
+            run.trace&.dataloader_spawn_execution_fiber(@pending_jobs)
+            Fiber[:__graphql_async_dataloader_run] = run
+            Fiber[:__graphql_async_dataloader_condition] = run.snoozed_jobs_condition
+            set_fiber_variables(fiber_vars)
+            run.started_tasks.push(task)
+            while job = @pending_jobs.shift
+              job.call
             end
+          ensure
+            cleanup_fiber
+            run.finished_tasks.push($! || task)
+            run.trace&.dataloader_fiber_exit
           end
         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
+        @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 = @lazies_at_depth.delete(smallest_depth)
+          if !lazies.empty?
+            lazies.each_with_index do |l, idx|
+              append_job { l.value }
+            end
+            spawn_job_task(run) # Todo what was the last `true` condition?
+          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 +240,29 @@ 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
+            run.root_task.async do |task|
+              Fiber[:__graphql_async_dataloader_run] = run
+              Fiber[:__graphql_async_dataloader_condition] = run.snoozed_sources_condition
+              trace&.dataloader_spawn_source_fiber(pending_sources)
+              set_fiber_variables(fiber_vars)
+              run.started_tasks.push(task)
+              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
           end
         end
       end

data/lib/graphql/execution/field_resolve_step.rb

@@ -51,9 +51,9 @@ module GraphQL
       def value
         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
@@ -244,7 +244,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 +319,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)

data/lib/graphql/version.rb

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

metadata

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