graphql 2.6.5 → 2.6.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8ece536c0702c8789a3a5c79de82af4bd2ff806a3209d0ac4da88fc968629d19
-  data.tar.gz: 0063f1ea552e7782029083eb027138a0725af89a65265dc643469f2227184134
+  metadata.gz: 3366525e188ac8b81b4dc7bdc8e34bb1839153fbec23d8e2a5faf07c02b56aa6
+  data.tar.gz: 414d8f17cee8d40adf8c5923427e83d187efdbd08871c7b9d8bbd4fa13b0e550
 SHA512:
-  metadata.gz: 2ee406b8ad164004af45d98e3b5dc70d69396f008a80cc68ef83a4bff212698c0a181644dc2b513e8bd1e71d2baf7d1ba2901ad05f497199556b171a6dfb11ab
-  data.tar.gz: 2ffd4e01742bd3b0feb207a316b1935d1edff05be8b28afb1c42e5ba47b4df916df802ee15617bb30bd45cdf6fd4f7a59c22b5d73cbabb3d8ee6658f3246d8ef
+  metadata.gz: f4423d53187dcf97e67ae1ba93cc9b5135c7db35cab04abc5533b96e97e3abd5d2c4bbbe683a64abc0117a022743a53df804d170e5fbd0fd7430a3987466531b
+  data.tar.gz: c6093a9a53e554aed992da96b80007bbe10df7ac9552c4a1dc0cce19ae8a3f33fd3e2cb0858c117c1e061c4b996a4af8a7b161b31b4f3806ff3a30a84dfaddb2

data/lib/graphql/dataloader/async_dataloader.rb

@@ -19,9 +19,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 +32,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 +51,10 @@ 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
+          @running_tasks = nil
+          @tasks_channel = nil
+          @tasks_channel_task = nil
           @finished_all_tasks = nil
-          @finished_first_pass = nil
 
           @snoozed_jobs_condition = Async::Condition.new
           @snoozed_sources_condition = Async::Condition.new
@@ -60,73 +62,59 @@ 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
-
-          @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
+          @tasks_channel.close
+          @tasks_channel_task.cancel
         end
 
         def wait_for_queues
-          if !@finished_first_pass.resolved?
-            @finished_first_pass.resolve(true)
-          end
-
           @finished_all_tasks.wait
           @finished_all_tasks = Async::Promise.new
         end
 
-        def new_queues
-          @finished_tasks = Async::Queue.new
-          @finished_count = 0
-          @started_tasks = Async::Queue.new
-          @started_count = 0
-          @finished_first_pass = Async::Promise.new
-          @finished_all_tasks = Async::Promise.new
-
-          @started_count_task = @root_task.async do |task|
-            @finished_first_pass.wait
-            while task = @started_tasks.wait
-              @started_count += 1
-              if task.status == :initialized # could also be resumed after waiting
-                task.run
-              end
-            end
-          end
+        def wait_for_no_running_tasks
+          @no_running_tasks.wait
+          @no_running_tasks = Async::Promise.new
+        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)
+          @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
+              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
@@ -135,6 +123,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 +182,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 +209,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 +239,78 @@ module GraphQL
 
       private
 
-      def run_pending_steps(run)
-        run.new_queues
+      def run_queue(run, condition, mode)
+        should_wait_for_all_tasks = false
 
-        if (unsnoozed = run.snoozed_jobs_condition.waiting?)
-          run.snoozed_jobs_condition.signal
+        if (unsnoozed = condition.waiting?)
+          should_wait_for_all_tasks = true
+          run.new_queues(mode)
+          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
+        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
-          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
+          run.wait_for_no_running_tasks
         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
+        if should_wait_for_all_tasks
           run.wait_for_queues
         end
       ensure
-        run.close_queues
-      end
-
-      #### TODO DRY  Had to duplicate to remove spawn_job_fiber
-      def run_next_pending_lazies(run)
-        smallest_depth = nil
-        run.lazies_at_depth.each_key do |depth_key|
-          smallest_depth ||= depth_key
-          if depth_key < smallest_depth
-            smallest_depth = depth_key
-          end
-        end
-
-        if smallest_depth
-          lazies = run.lazies_at_depth.delete(smallest_depth)
-          if !lazies.empty?
-            begin
-              run.new_queues
-              lazies.each_with_index do |l, idx|
-                append_job { l.value }
-              end
-              spawn_job_task(run) # Todo what was the last `true` condition?
-              run.wait_for_queues
-            ensure
-              run.close_queues
-            end
-          end
+        if should_wait_for_all_tasks
+          run.close_queues
         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
-        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/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/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

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.5"
+  VERSION = "2.6.6"
 end

metadata

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