graphql 2.6.6 → 2.6.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3366525e188ac8b81b4dc7bdc8e34bb1839153fbec23d8e2a5faf07c02b56aa6
-  data.tar.gz: 414d8f17cee8d40adf8c5923427e83d187efdbd08871c7b9d8bbd4fa13b0e550
+  metadata.gz: 75192ceea307d33645d2d511db98530f8021c8af45af33fc75e86dcd69f53952
+  data.tar.gz: ff3ee9e77876ad45fb67491fb5076df4614ab086ecfa15e476b3d35bca2e3b22
 SHA512:
-  metadata.gz: f4423d53187dcf97e67ae1ba93cc9b5135c7db35cab04abc5533b96e97e3abd5d2c4bbbe683a64abc0117a022743a53df804d170e5fbd0fd7430a3987466531b
-  data.tar.gz: c6093a9a53e554aed992da96b80007bbe10df7ac9552c4a1dc0cce19ae8a3f33fd3e2cb0858c117c1e061c4b996a4af8a7b161b31b4f3806ff3a30a84dfaddb2
+  metadata.gz: 50bc8591ece79fc8070b4c3a6a3611f29e9a4ad84a94e6f310a5fd2c00ac0d10b6db5ebe44474e1d5f002a76615d6a25dd4dbfc2a8f56ec1c2d0d88972ce95e2
+  data.tar.gz: b28b83923ac25bb605d7fe1e9b25a64e37aa8173a64c958849287cdd0c87cc419deea25f36b4d525a6ea17088b7a02cb0a51011750c568337a6274b0373ff43b

data/lib/graphql/dataloader/async_dataloader.rb

@@ -4,6 +4,11 @@ module GraphQL
   class Dataloader
     class AsyncDataloader < Dataloader
       def self.use(...)
+        install_graphql_methods
+        super
+      end
+
+      def self.install_graphql_methods
         if !Async::Task.method_defined?(:cancel)
           Async::Task.alias_method(:cancel, :stop)
         end
@@ -11,7 +16,6 @@ module GraphQL
           Async::Task.attr_accessor(:graphql_async_dataloader_run)
           Async::Task.attr_accessor(:graphql_async_dataloader_condition)
         end
-        super
       end
 
       def initialize(...)
@@ -54,7 +58,10 @@ module GraphQL
           @running_tasks = nil
           @tasks_channel = nil
           @tasks_channel_task = nil
-          @finished_all_tasks = nil
+          @activity = nil
+          @task_error = nil
+          @expected_resumes = 0
+          @mode = nil
 
           @snoozed_jobs_condition = Async::Condition.new
           @snoozed_sources_condition = Async::Condition.new
@@ -77,20 +84,41 @@ module GraphQL
           @tasks_channel_task.cancel
         end
 
-        def wait_for_queues
-          @finished_all_tasks.wait
-          @finished_all_tasks = Async::Promise.new
+        def wait_for_activity
+          @activity.wait
+        end
+
+        def quiesced?
+          @running_tasks.empty? && @tasks_channel.empty? && @expected_resumes == 0
+        end
+
+        def has_pending_work?
+          @mode == :jobs ? @jobs.any? : @dataloader.pending_sources.any?(&:pending?) # rubocop:disable Development/NoneWithoutBlockCop
+        end
+
+        def has_bandwidth?
+          @mode == :jobs ? jobs_bandwidth? : sources_bandwidth?
+        end
+
+        # Signalled tasks don't appear in any accounting until their first slice
+        # pushes `:resumed_task`, so they have to be counted at signal time:
+        def expect_resumes(count)
+          @expected_resumes = count
         end
 
-        def wait_for_no_running_tasks
-          @no_running_tasks.wait
-          @no_running_tasks = Async::Promise.new
+        def check_error!
+          if (err = @task_error)
+            @task_error = nil
+            raise err
+          end
         end
 
         def new_queues(mode)
+          @mode = mode
           @tasks_channel = Async::Queue.new(parent: @root_task)
-          @no_running_tasks = Async::Promise.new
-          @finished_all_tasks = Async::Promise.new
+          @activity = Async::Condition.new
+          @task_error = nil
+          @expected_resumes = 0
           @running_tasks = []
           @tasks_channel_task = @root_task.async do |_t|
             while ((msg, data) = @tasks_channel.wait)
@@ -99,23 +127,18 @@ module GraphQL
                 @running_tasks.push(data)
                 data.run
               when :resumed_task
+                if @expected_resumes > 0
+                  @expected_resumes -= 1
+                end
                 @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
               when :task_error
-                @no_running_tasks.resolve(true)
-                @finished_all_tasks.reject(data)
+                @task_error ||= data
               else
                 raise ArgumentError, "Unknown tasks_channel action: #{msg.inspect}"
               end
+              @activity.signal
             end
           end
         end
@@ -240,19 +263,20 @@ module GraphQL
       private
 
       def run_queue(run, condition, mode)
-        should_wait_for_all_tasks = false
+        opened_queues = false
 
-        if (unsnoozed = condition.waiting?)
-          should_wait_for_all_tasks = true
+        if condition.waiting?
+          opened_queues = true
           run.new_queues(mode)
+          run.expect_resumes(condition.instance_variable_get(:@ready).num_waiting)
           condition.signal
         end
 
-        while (pending_work = (mode == :jobs) ? (!run.jobs.empty? && run.jobs_bandwidth? ? run.jobs : nil) : (drain_pending_sources)) || unsnoozed
-          unsnoozed = false
+        loop do
+          pending_work = (mode == :jobs) ? (!run.jobs.empty? && run.jobs_bandwidth? ? run.jobs : nil) : (drain_pending_sources)
           if pending_work
-            if should_wait_for_all_tasks == false
-              should_wait_for_all_tasks = true
+            if opened_queues == false
+              opened_queues = true
               run.new_queues(mode)
             end
             num_tasks = mode == :sources ? run.current_sources_fiber_limit : 1
@@ -262,14 +286,23 @@ module GraphQL
             spawn_tasks(run, mode, condition, pending_work, num_tasks)
           end
 
-          run.wait_for_no_running_tasks
-        end
+          if !opened_queues
+            break
+          end
+
+          run.check_error!
 
-        if should_wait_for_all_tasks
-          run.wait_for_queues
+          if run.quiesced?
+            if !run.has_pending_work? || !run.has_bandwidth?
+              break
+            end
+            # Quiesced, but more work appeared - loop around to drain it.
+          else
+            run.wait_for_activity
+          end
         end
       ensure
-        if should_wait_for_all_tasks
+        if opened_queues
           run.close_queues
         end
       end

data/lib/graphql/execution/selections_step.rb

@@ -83,12 +83,12 @@ module GraphQL
             end
           end
 
-          continue_selections.each do |frs|
-            @runner.add_step(frs)
-          end
-
           i += 2
         end
+
+        continue_selections.each do |frs|
+          @runner.add_step(frs)
+        end
       end
     end
   end

data/lib/graphql/schema/build_from_definition.rb

@@ -82,6 +82,7 @@ module GraphQL
           replace_late_bound_types_with_built_in(types)
 
           schema_extensions = nil
+          definitions_by_name = nil
           document.definitions.each do |definition|
             case definition
             when GraphQL::Language::Nodes::SchemaDefinition, GraphQL::Language::Nodes::DirectiveDefinition
@@ -101,9 +102,16 @@ module GraphQL
               if prev_type.nil? || prev_type.is_a?(Schema::LateBoundType)
                 if definition.is_a?(GraphQL::Language::Nodes::ObjectTypeDefinition) || definition.is_a?(Language::Nodes::InterfaceTypeDefinition)
                   interface_names = definition.interfaces.map(&:name)
-                  transitive_names = interface_names.map { |n| document.definitions.find { |d| d.respond_to?(:name) && d.name == n }&.interfaces&.map(&:name) }
-                  transitive_names.flatten!
-                  transitive_names.compact!
+                  if !interface_names.empty?
+                    definitions_by_name ||= document.definitions.each_with_object({}) do |d, by_name|
+                      by_name[d.name] ||= d if d.respond_to?(:name)
+                    end
+                    transitive_names = interface_names.map { |n| definitions_by_name[n]&.interfaces&.map(&:name) }
+                    transitive_names.flatten!
+                    transitive_names.compact!
+                  else
+                    transitive_names = interface_names
+                  end
                   if !(missing_transitive_interfaces = transitive_names - interface_names).empty?
                     raise GraphQL::Schema::InvalidDocumentError, "type #{definition.name} is missing one or more transitive interface names: #{missing_transitive_interfaces.join(", ")}. Add them to the type's `implements` list and try again."
                   end

data/lib/graphql/version.rb

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.6.6
+  version: 2.6.7
 platform: ruby
 authors:
 - Robert Mosolgo
 bindir: bin
 cert_chain: []
-date: 2026-07-21 00:00:00.000000000 Z
+date: 2026-07-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64