graphql 2.6.5 → 2.6.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8ece536c0702c8789a3a5c79de82af4bd2ff806a3209d0ac4da88fc968629d19
-  data.tar.gz: 0063f1ea552e7782029083eb027138a0725af89a65265dc643469f2227184134
+  metadata.gz: 6a359d53729477046ffd6b51ef9345099defcdc95521579711fffe5ab79c0b5e
+  data.tar.gz: 4c88aecd90fb26e02198f21f4bdf7a73f577ec37ac9ea9eb6c840c8a2957fc7a
 SHA512:
-  metadata.gz: 2ee406b8ad164004af45d98e3b5dc70d69396f008a80cc68ef83a4bff212698c0a181644dc2b513e8bd1e71d2baf7d1ba2901ad05f497199556b171a6dfb11ab
-  data.tar.gz: 2ffd4e01742bd3b0feb207a316b1935d1edff05be8b28afb1c42e5ba47b4df916df802ee15617bb30bd45cdf6fd4f7a59c22b5d73cbabb3d8ee6658f3246d8ef
+  metadata.gz: d40bb56d8b5e77ca6f126f1528e2a074bbf679996dfb8ea5a12d646d028d547848dc36dea3a5fb73273fb7252135a5c7e904ec7d0a38790fe05164c5e81701b5
+  data.tar.gz: e486b9492693cdc69375f8d3bc662e075a71ff45642f62cb2fd741959b2a2d1f9105fa14718b992ef2d3b3a809fd0f0d94ec66abf509137b3a7af05877527c23

data/lib/generators/graphql/templates/schema.erb

@@ -26,7 +26,8 @@ class <%= schema_name %> < GraphQL::Schema
     raise(GraphQL::RequiredImplementationMissingError)
   end
 
-  # Limit the size of incoming queries:
+  # Limit the depth and size of incoming queries:
+  max_depth(15)
   max_query_string_tokens(5000)
 
   # Stop validating when it encounters this many errors:

data/lib/graphql/dashboard/application_controller.rb

@@ -22,7 +22,11 @@ module Graphql
 
       def schema_class
         @schema_class ||= begin
-          schema_param = request.query_parameters["schema"] || params[:schema]
+          configured_schemas = Array(request.path_parameters[:schema] || request.path_parameters["schema"])
+          schema_param = request.query_parameters["schema"]
+          schema_param = configured_schemas.find { |schema| schema.to_s == schema_param } if schema_param
+          schema_param ||= configured_schemas.first
+
           case schema_param
           when Class
             schema_param

data/lib/graphql/dashboard.rb

@@ -10,6 +10,9 @@ module Graphql
   # @example Mounting the Dashboard in your app
   #   mount GraphQL::Dashboard, at: "graphql_dashboard", schema: "MySchema"
   #
+  # Pass an array to allow selecting from multiple schemas with the `schema` query parameter.
+  #   mount GraphQL::Dashboard, at: "graphql_dashboard", schema: ["MySchema", "OtherSchema"]
+  #
   # @example Authenticating the Dashboard with HTTP Basic Auth
   #   # config/initializers/graphql_dashboard.rb
   #   GraphQL::Dashboard.middleware.use(Rack::Auth::Basic) do |username, password|

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(...)
@@ -19,9 +23,12 @@ module GraphQL
         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(total_fiber_limit, jobs_fiber_limit)
+        @pending_run = Run.new(self, total_fiber_limit, jobs_fiber_limit)
       end
 
       def yield(source = Fiber[:__graphql_current_dataloader_source])
@@ -29,16 +36,17 @@ module GraphQL
         run = task.graphql_async_dataloader_run
         trace = run.trace
         trace&.dataloader_fiber_yield(source)
-        run.finished_tasks.push(task)
+        run.tasks_channel.push([:paused_task, task])
         condition = task.graphql_async_dataloader_condition
         condition.wait
-        run.started_tasks.push(task)
+        run.tasks_channel.push([:resumed_task, task])
         trace&.dataloader_fiber_resume(source)
         nil
       end
 
       class Run
-        def initialize(total_fiber_limit, jobs_fiber_limit)
+        def initialize(dataloader, total_fiber_limit, jobs_fiber_limit)
+          @dataloader = dataloader
           @root_task = nil
           @trace = nil
           @jobs = []
@@ -47,12 +55,13 @@ module GraphQL
           @jobs_fiber_limit = jobs_fiber_limit
           @lazies_at_depth = Hash.new { |h, k| h[k] = [] }
 
-          @finished_tasks = nil
-          @started_tasks = nil
-          @started_count_task = nil
-          @finished_count_task = nil
-          @finished_all_tasks = nil
-          @finished_first_pass = nil
+          @running_tasks = nil
+          @tasks_channel = nil
+          @tasks_channel_task = nil
+          @activity = nil
+          @task_error = nil
+          @expected_resumes = 0
+          @mode = nil
 
           @snoozed_jobs_condition = Async::Condition.new
           @snoozed_sources_condition = Async::Condition.new
@@ -60,74 +69,76 @@ module GraphQL
 
         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
+        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
+          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
+        def sources_bandwidth?
+          running_count < current_sources_fiber_limit
         end
 
         def close_queues
-          @finished_tasks.close
-          @finished_count_task.cancel
+          @tasks_channel.close
+          @tasks_channel_task.cancel
+        end
 
-          @started_tasks.close
-          @started_count_task.cancel
+        def wait_for_activity
+          @activity.wait
         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
+        def quiesced?
+          @running_tasks.empty? && @tasks_channel.empty? && @expected_resumes == 0
         end
 
-        def wait_for_queues
-          if !@finished_first_pass.resolved?
-            @finished_first_pass.resolve(true)
-          end
+        def has_pending_work?
+          @mode == :jobs ? @jobs.any? : @dataloader.pending_sources.any?(&:pending?) # rubocop:disable Development/NoneWithoutBlockCop
+        end
 
-          @finished_all_tasks.wait
-          @finished_all_tasks = Async::Promise.new
+        def has_bandwidth?
+          @mode == :jobs ? jobs_bandwidth? : sources_bandwidth?
         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
+        # 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 check_error!
+          if (err = @task_error)
+            @task_error = nil
+            raise err
           end
+        end
 
-          @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)
+        def new_queues(mode)
+          @mode = mode
+          @tasks_channel = Async::Queue.new(parent: @root_task)
+          @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)
+              case msg
+              when :started_task
+                @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)
+              when :task_error
+                @task_error ||= data
+              else
+                raise ArgumentError, "Unknown tasks_channel action: #{msg.inspect}"
               end
+              @activity.signal
             end
           end
         end
@@ -135,6 +146,23 @@ module GraphQL
         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)
@@ -177,9 +205,10 @@ module GraphQL
         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
+            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
@@ -203,13 +232,14 @@ module GraphQL
 
             while first_pass || run.running? || !jobs.empty?
               first_pass = false
-              run_pending_steps(run)
-              run_sources(run)
+              run_queue(run, run.snoozed_jobs_condition, :jobs)
+              run_queue(run, run.snoozed_sources_condition, :sources)
 
               if !run.lazies_at_depth.empty?
                 with_trace_query_lazy(trace_query_lazy) do
-                  run_next_pending_lazies(run)
-                  run_pending_steps(run)
+                  if enqueue_next_pending_lazies(run.lazies_at_depth)
+                    run_queue(run, run.snoozed_jobs_condition, :jobs)
+                  end
                 end
               end
             end
@@ -232,129 +262,88 @@ module GraphQL
 
       private
 
-      def run_pending_steps(run)
-        run.new_queues
+      def run_queue(run, condition, mode)
+        opened_queues = false
 
-        if (unsnoozed = run.snoozed_jobs_condition.waiting?)
-          run.snoozed_jobs_condition.signal
+        if condition.waiting?
+          opened_queues = true
+          run.new_queues(mode)
+          run.expect_resumes(condition.instance_variable_get(:@ready).num_waiting)
+          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
+        loop do
+          pending_work = (mode == :jobs) ? (!run.jobs.empty? && run.jobs_bandwidth? ? run.jobs : nil) : (drain_pending_sources)
+          if pending_work
+            if opened_queues == false
+              opened_queues = true
+              run.new_queues(mode)
             end
-          ensure
-            cleanup_fiber
-            run.finished_tasks.push($! || task)
-            run.trace&.dataloader_fiber_exit
+            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.started_tasks.push(new_task)
-          new_task
-        end
-      end
-
-      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)
+          if !opened_queues
+            break
           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
+          run.check_error!
 
-        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
+          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
-      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|
-            if source.pending?
-              pending_sources ||= []
-              pending_sources << source
-            end
-          end
+      ensure
+        if opened_queues
+          run.close_queues
         end
+      end
 
-        if pending_sources
-          if num_tasks == Float::INFINITY
-            num_tasks = pending_sources.size
-          end
-          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 = run.snoozed_sources_condition
-              trace&.dataloader_spawn_source_fiber(pending_sources)
-              set_fiber_variables(fiber_vars)
-              while (source = pending_sources.shift)
+      # 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)
+            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
-              nil
-            ensure
-              run.finished_tasks.push($! || task)
-              cleanup_fiber
-              trace&.dataloader_fiber_exit
+            else
+              raise ArgumentError, "Unknown mode: #{mode.inspect}"
             end
-            run.started_tasks.push(new_task)
-            new_task
+            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
         }
@@ -106,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) }
@@ -193,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

@@ -59,6 +59,8 @@ module GraphQL
 
     def initialize(nonblocking: self.class.default_nonblocking, fiber_limit: self.class.default_fiber_limit)
       @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

@@ -130,7 +130,7 @@ module GraphQL
         highest_nulled_depth = path.size
         highest_list_depth = nil
         current_field_step = self
-        while current_field_step
+        while current_field_step && current_field_step.field_definition
           return_type = current_field_step.field_definition.type
           if propagating_null && return_type.non_null?
             highest_nulled_depth = current_field_step.path.size
@@ -147,7 +147,7 @@ module GraphQL
 
         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
+          while kill_field_step && kill_field_step.field_definition && 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

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

@@ -765,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/interpreter.rb

@@ -119,6 +119,12 @@ module GraphQL
               end
 
               results
+            rescue SystemStackError => err
+              queries.map do |query|
+                schema.query_stack_error(query, err)
+                query.result_values ||= { "errors" => query.context.errors.map(&:to_h) }
+                query.result
+              end
             rescue Exception
               # TODO rescue at a higher level so it will catch errors in analysis, too
               # Assign values here so that the query's `@executed` becomes true

data/lib/graphql/execution/runner.rb

@@ -5,7 +5,6 @@ module GraphQL
       def initialize(multiplex)
         @multiplex = multiplex
         @schema = multiplex.schema
-        @steps_queue = []
         @runtime_type_at = {}.compare_by_identity
         @static_type_at = {}.compare_by_identity
         @finalizers = nil
@@ -53,7 +52,7 @@ module GraphQL
         @dataloader.append_job(step)
       end
 
-      attr_reader :steps_queue, :schema, :variables, :dataloader, :resolves_lazies, :authorizes, :static_type_at, :runtime_type_at, :finalizers, :input_values
+      attr_reader :schema, :variables, :dataloader, :resolves_lazies, :authorizes, :static_type_at, :runtime_type_at, :finalizers, :input_values
 
       # @return [void]
       def add_finalizer(query, result_value, key, finalizer)
@@ -281,8 +280,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

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/language/block_string.rb

@@ -21,17 +21,12 @@ module GraphQL
             next
           end
           line_length = line.size
-          line_indent = if line.match?(/\A  [^ ]/)
-            2
-          elsif line.match?(/\A    [^ ]/)
-            4
-          elsif line.match?(/\A[^ ]/)
-            0
-          else
-            line[/\A */].size
+          leading = 0
+          while leading < line_length && line.getbyte(leading) == 32
+            leading += 1
           end
-          if line_indent < line_length && (common_indent.nil? || line_indent < common_indent)
-            common_indent = line_indent
+          if leading < line_length && (common_indent.nil? || leading < common_indent)
+            common_indent = leading
           end
         end
 
@@ -41,7 +36,7 @@ module GraphQL
             if idx == 0
               next
             else
-              line.slice!(0, common_indent)
+              line[0, common_indent] = ""
             end
           end
         end

data/lib/graphql/language/cache.rb

@@ -2,6 +2,9 @@
 
 require 'graphql/version'
 require 'digest/sha2'
+require 'openssl'
+require 'securerandom'
+require 'tempfile'
 
 module GraphQL
   module Language
@@ -9,7 +12,11 @@ module GraphQL
     #
     # With Rails, parser caching may enabled by setting `config.graphql.parser_cache = true` in your Rails application.
     #
-    # The cache may be manually built by assigning `GraphQL::Language::Parser.cache = GraphQL::Language::Cache.new("some_dir")`.
+    # The cache may be manually built by assigning `GraphQL::Language::Parser.cache = GraphQL::Language::Cache.new(Pathname.new("some_dir"), secret: ENV.fetch("GRAPHQL_CACHE_SECRET"))`.
+    # The `secret` should be a stable value stored outside of the cache directory.
+    # When it isn't provided, a process-local secret is generated and cache entries
+    # are rebuilt after the process restarts. Pass `secret: nil` to disable cache
+    # signing. This should only be used when the cache directory is trusted.
     # This will create a directory (`tmp/cache/graphql` by default) that stores a cache of parsed files.
     #
     # Much like [bootsnap](https://github.com/Shopify/bootsnap), the parser cache needs to be cleaned up manually.
@@ -18,32 +25,95 @@ module GraphQL
     #
     # @see GraphQL::Railtie for simple Rails integration
     class Cache
-      def initialize(path)
+      # @param path [Pathname] The directory where cache entries are stored.
+      # @param secret [String, nil] A stable secret for verifying cache entries. When omitted,
+      #   a process-local secret is generated. Pass `nil` to disable cache signing.
+      def initialize(path, secret: SecureRandom.random_bytes(32))
         @path = path
+        @secret = secret
       end
 
       DIGEST = Digest::SHA256.new << GraphQL::VERSION
+      HMAC_SIZE = OpenSSL::Digest::SHA256.new.digest_length
+      InvalidCache = Class.new(StandardError)
+      private_constant :InvalidCache
 
       def fetch(filename)
-        hash = DIGEST.dup << filename
+        cache_key = cache_key_for(filename)
+        return yield unless cache_key
+
+        cache_path = @path.join(cache_key)
+
+        begin
+          return load_cache(cache_path, cache_key) if cache_path.file?
+        rescue InvalidCache, SystemCallError
+          # Rebuild caches created by older versions or with an invalid signature.
+        end
+
+        payload = yield
         begin
-          hash << File.mtime(filename).to_i.to_s
+          write_cache(cache_path, cache_key, payload)
         rescue SystemCallError
-          return yield
+          # Parser caching is best-effort; return the parsed payload if the cache cannot be written.
         end
-        cache_path = @path.join(hash.to_s)
+        payload
+      end
+
+      private
+
+      def cache_key_for(filename)
+        content_digest = Digest::SHA256.file(filename).hexdigest
+        (DIGEST.dup << filename << content_digest).to_s
+      rescue SystemCallError
+        nil
+      end
+
+      def load_cache(cache_path, cache_key)
+        cache_data = cache_path.binread
+        return Marshal.load(cache_data) unless @secret
+
+        signature = cache_data.byteslice(0, HMAC_SIZE)
+        payload = cache_data.byteslice(HMAC_SIZE..-1)
+        raise InvalidCache unless signature && payload
 
-        if cache_path.exist?
-          Marshal.load(cache_path.read)
+        expected_signature = signature_for(cache_key, payload)
+        unless secure_compare(signature, expected_signature)
+          raise InvalidCache
+        end
+        Marshal.load(payload)
+      end
+
+      def write_cache(cache_path, cache_key, payload)
+        @path.mkpath
+        serialized_payload = Marshal.dump(payload)
+        cache_data = if @secret
+          signature_for(cache_key, serialized_payload) + serialized_payload
         else
-          payload = yield
-          tmp_path = "#{cache_path}.#{rand}"
+          serialized_payload
+        end
+
+        Tempfile.create(['graphql-cache-', '.tmp'], @path.to_s) do |tempfile|
+          tempfile.binmode
+          tempfile.write(cache_data)
+          tempfile.flush
+          tempfile.fsync
+          tempfile.close
+          File.rename(tempfile.path, cache_path.to_s)
+        end
+      end
+
+      def signature_for(cache_key, payload)
+        OpenSSL::HMAC.digest('SHA256', @secret, cache_key + payload)
+      end
+
+      def secure_compare(left, right)
+        return false unless left.bytesize == right.bytesize
 
-          @path.mkpath
-          File.binwrite(tmp_path, Marshal.dump(payload))
-          File.rename(tmp_path, cache_path.to_s)
-          payload
+        result = 0
+        left.bytes.each_with_index do |byte, index|
+          result |= byte ^ right.getbyte(index)
         end
+        result.zero?
       end
     end
   end

data/lib/graphql/language/lexer.rb

@@ -175,11 +175,14 @@ module GraphQL
       end
 
       def line_number
-        @scanner.string[0..@pos].count("\n") + 1
+        @scanner.string.byteslice(0, @pos).b.count("\n".b) + 1
       end
 
       def column_number
-        @scanner.string[0..@pos].split("\n").last.length
+        line_prefix = @scanner.string.byteslice(0, @pos)
+        line_prefix = line_prefix.b unless line_prefix.valid_encoding?
+        newline_index = line_prefix.rindex("\n")
+        newline_index ? line_prefix.length - newline_index : line_prefix.length + 1
       end
 
       def raise_parse_error(message, line = line_number, col = column_number)

data/lib/graphql/language/nodes.rb

@@ -304,7 +304,8 @@ module GraphQL
                 children_method_names.map { |m| "#{m}: NO_CHILDREN" } +
                 DEFAULT_INITIALIZE_OPTIONS
 
-              assignments = scalar_method_names.map { |m| "@#{m} = #{m}"} +
+              # Intern descriptions so identical strings across SDL documents share one frozen object.
+              assignments = scalar_method_names.map { |m| m == :description ? "@#{m} = #{m} && -#{m}" : "@#{m} = #{m}" } +
                 children_method_names.map { |m| "@#{m} = #{m}.freeze" }
 
               if name.end_with?("Definition") && name != "FragmentDefinition"

data/lib/graphql/language.rb

@@ -31,7 +31,7 @@ module GraphQL
 
         "[#{serialized_array}]"
       else
-        JSON.generate(value, quirks_mode: true)
+        JSON.generate(value)
       end
     rescue JSON::GeneratorError
       if Float::INFINITY == value

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/railtie.rb

@@ -15,7 +15,8 @@ module GraphQL
     initializer("graphql.cache") do |app|
       if config.graphql.parser_cache
         Language::Parser.cache ||= Language::Cache.new(
-          app.root.join("tmp/cache/graphql")
+          app.root.join("tmp/cache/graphql"),
+          secret: app.secret_key_base
         )
       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/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/input_object.rb

@@ -172,12 +172,12 @@ module GraphQL
           types = ctx.types
 
           if input.is_a?(Array)
-            return GraphQL::Query::InputValidationResult.from_problem(INVALID_OBJECT_MESSAGE % { object: JSON.generate(input, quirks_mode: true) })
+            return GraphQL::Query::InputValidationResult.from_problem(INVALID_OBJECT_MESSAGE % { object: JSON.generate(input) })
           end
 
           if !(input.respond_to?(:to_h) || input.respond_to?(:to_unsafe_h))
             # We're not sure it'll act like a hash, so reject it:
-            return GraphQL::Query::InputValidationResult.from_problem(INVALID_OBJECT_MESSAGE % { object: JSON.generate(input, quirks_mode: true) })
+            return GraphQL::Query::InputValidationResult.from_problem(INVALID_OBJECT_MESSAGE % { object: JSON.generate(input) })
           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/subscriptions/serialize.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require "date"
 require "set"
 module GraphQL
   class Subscriptions
@@ -10,6 +11,7 @@ module GraphQL
       SYMBOL_KEYS_KEY = "__sym_keys__"
       TIMESTAMP_KEY = "__timestamp__"
       TIMESTAMP_FORMAT = "%Y-%m-%d %H:%M:%S.%N%z" # eg '2020-01-01 23:59:59.123456789+05:00'
+      TIMESTAMP_CLASS_NAMES = ["Date", "DateTime", "Time"].freeze
       OPEN_STRUCT_KEY = "__ostruct__"
 
       module_function
@@ -24,7 +26,7 @@ module GraphQL
       # @param obj [Object] Some subscription-related data to dump
       # @return [String] The stringified object
       def dump(obj)
-        JSON.generate(dump_value(obj), quirks_mode: true)
+        JSON.generate(dump_value(obj))
       end
 
       # This is for turning objects into subscription scopes.
@@ -72,15 +74,19 @@ module GraphQL
                 value[SYMBOL_KEY].to_sym
               when TIMESTAMP_KEY
                 timestamp_class_name, *timestamp_args = value[TIMESTAMP_KEY]
-                timestamp_class = Object.const_get(timestamp_class_name)
-                if defined?(ActiveSupport::TimeWithZone) && timestamp_class <= ActiveSupport::TimeWithZone
+                timestamp_class = if TIMESTAMP_CLASS_NAMES.include?(timestamp_class_name)
+                  Object.const_get(timestamp_class_name, false)
+                end
+                if defined?(ActiveSupport::TimeWithZone) && timestamp_class_name == ActiveSupport::TimeWithZone.name
                   zone_name, timestamp_s = timestamp_args
                   zone = ActiveSupport::TimeZone[zone_name]
                   raise "Zone #{zone_name} not found, unable to deserialize" unless zone
                   zone.strptime(timestamp_s, TIMESTAMP_FORMAT)
-                else
+                elsif timestamp_class
                   timestamp_s = timestamp_args.first
                   timestamp_class.strptime(timestamp_s, TIMESTAMP_FORMAT)
+                else
+                  raise ArgumentError, "Unsupported timestamp class: #{timestamp_class_name.inspect}"
                 end
               when OPEN_STRUCT_KEY
                 ostruct_values = load_value(value[OPEN_STRUCT_KEY])

data/lib/graphql/version.rb

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.6.5
+  version: 2.6.9
 platform: ruby
 authors:
 - Robert Mosolgo
 bindir: bin
 cert_chain: []
-date: 2026-07-06 00:00:00.000000000 Z
+date: 2026-08-17 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