graphql 2.6.9 → 2.6.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6a359d53729477046ffd6b51ef9345099defcdc95521579711fffe5ab79c0b5e
-  data.tar.gz: 4c88aecd90fb26e02198f21f4bdf7a73f577ec37ac9ea9eb6c840c8a2957fc7a
+  metadata.gz: a6c191887acba06a4030f962822e9106e9d3aa9d5550c8cd25ea76f343927f1b
+  data.tar.gz: b984ad9a61a391b4b8a42ade3bb9c63dc79ab2b3ee987845d655dc7038df1255
 SHA512:
-  metadata.gz: d40bb56d8b5e77ca6f126f1528e2a074bbf679996dfb8ea5a12d646d028d547848dc36dea3a5fb73273fb7252135a5c7e904ec7d0a38790fe05164c5e81701b5
-  data.tar.gz: e486b9492693cdc69375f8d3bc662e075a71ff45642f62cb2fd741959b2a2d1f9105fa14718b992ef2d3b3a809fd0f0d94ec66abf509137b3a7af05877527c23
+  metadata.gz: 7deac13ce0bbc579609e28575a309caa46086196f1381cfc5fbd6a5770b2059e123cb047cc835c573ad76be1df264a3b0d52d8692dbf161ad0d0248f8cfed2a3
+  data.tar.gz: 1362c0867ad8bbbe086b1999c710f447de6ea16b53b8a05a83dc39cba6c7b7d8d5cccdc388a3dff2f42c1b5135ff59a4c78dd2d53badd34b28718a73aa331b92

data/lib/graphql/dataloader/async_dataloader.rb

@@ -36,10 +36,14 @@ module GraphQL
         run = task.graphql_async_dataloader_run
         trace = run.trace
         trace&.dataloader_fiber_yield(source)
-        run.tasks_channel.push([:paused_task, task])
+        if !run.push_task_message(:paused_task, task)
+          task.stop
+        end
         condition = task.graphql_async_dataloader_condition
         condition.wait
-        run.tasks_channel.push([:resumed_task, task])
+        if !run.push_task_message(:resumed_task, task)
+          task.stop
+        end
         trace&.dataloader_fiber_resume(source)
         nil
       end
@@ -69,7 +73,7 @@ module GraphQL
 
         attr_accessor :trace, :root_task
 
-        attr_reader :jobs, :lazies_at_depth, :jobs_fiber_limit,  :snoozed_jobs_condition, :snoozed_sources_condition, :tasks_channel
+        attr_reader :dataloader, :jobs, :lazies_at_depth, :jobs_fiber_limit,  :snoozed_jobs_condition, :snoozed_sources_condition
 
         def jobs_bandwidth?
           running_count < @jobs_fiber_limit
@@ -84,6 +88,20 @@ module GraphQL
           @tasks_channel_task.cancel
         end
 
+        # Push to the tasks_channel, tolerating a closed channel: on the error path, `run_queue`
+        # closes the channel while sibling tasks can still run one more slice before
+        # `root_task.cancel` reaches them. Record `:task_error` payloads so they aren't lost, and
+        # return false so the caller can stop the task instead of raising `ClosedError` into user code.
+        def push_task_message(msg, data)
+          @tasks_channel.push([msg, data])
+          true
+        rescue Async::Queue::ClosedError
+          if msg == :task_error
+            @task_error ||= data
+          end
+          false
+        end
+
         def wait_for_activity
           @activity.wait
         end
@@ -175,11 +193,19 @@ module GraphQL
       end
 
       def active_run
-        @pending_run || Async::Task.current?&.graphql_async_dataloader_run || raise(GraphQL::Error, "No available Run to append to, GraphQL-Ruby bug")
+        @pending_run || current_task_run || raise(GraphQL::Error, "No available Run to append to, GraphQL-Ruby bug")
+      end
+
+      # The current task's run, but only if it belongs to this dataloader. A different
+      # dataloader may be running inside one of our tasks (or vice versa), e.g. a query
+      # executed from a resolver or a subscription trigger; its run must not be reused.
+      def current_task_run
+        run = Async::Task.current?&.graphql_async_dataloader_run
+        run if run&.dataloader.equal?(self)
       end
 
       def run_isolated
-        previous_run = Async::Task.current?&.graphql_async_dataloader_run
+        previous_run = current_task_run
         prev_pending_keys = {}
         # Clear pending loads but keep already-cached records
         # in case they are useful to the given block.
@@ -215,7 +241,7 @@ module GraphQL
 
       def run(trace_query_lazy: nil)
         trace = Fiber[:__graphql_current_multiplex]&.current_trace
-        run = @pending_run || Async::Task.current?&.graphql_async_dataloader_run || raise(GraphQL::Error, "No available Run, GraphQL-Ruby internal bug")
+        run = @pending_run || current_task_run || raise(GraphQL::Error, "No available Run, GraphQL-Ruby internal bug")
         @pending_run = nil
         run.trace = trace
         first_pass = true
@@ -336,14 +362,14 @@ module GraphQL
             end
             nil
           rescue StandardError => err
-            run.tasks_channel.push([:task_error, err])
+            run.push_task_message(:task_error, err)
           else
-            run.tasks_channel.push([:finished_task, task])
+            run.push_task_message(:finished_task, task)
           ensure
             cleanup_fiber
             trace&.dataloader_fiber_exit
           end
-          run.tasks_channel.push([:started_task, new_task])
+          run.push_task_message(:started_task, new_task)
         end
       end
     end

data/lib/graphql/execution/field_resolve_step.rb

@@ -744,7 +744,8 @@ module GraphQL
         when :dig
           objects.map { |o| o.dig(*@field_definition.execution_mode_key) }
         when :dataload
-          if (k = @field_definition.execution_mode_key).is_a?(Class)
+          k = @field_definition.execution_mode_key
+          results = if k.is_a?(Class)
             context.dataload_all(k, objects)
           elsif (source_class = k[:with])
             if (batch_args = k[:by])
@@ -764,6 +765,12 @@ module GraphQL
           else
             raise ArgumentError, "Unexpected `dataload: ...` configuration: #{k.inspect}"
           end
+          method = k.is_a?(Hash) ? k[:method] : nil
+          if method
+            results.map { |r| r&.public_send(method) }
+          else
+            results
+          end
         when :resolver_class
           results = Array.new(objects.size, nil)
           ps = @pending_steps ||= []

data/lib/graphql/execution/interpreter.rb

@@ -22,6 +22,7 @@ module GraphQL
         # @param max_complexity [Integer, nil]
         # @return [Array<GraphQL::Query::Result>] One result per query
         def run_all(schema, query_options, context: {}, max_complexity: schema.max_complexity)
+          previous_multiplex = Fiber[:__graphql_current_multiplex]
           queries = query_options.map do |opts|
             query = case opts
             when Hash
@@ -131,7 +132,6 @@ module GraphQL
               queries.map { |q| q.result_values ||= {} }
               raise
             ensure
-              Fiber[:__graphql_current_multiplex] = nil
               queries.map { |query|
                 runtime = query.context.namespace(:interpreter_runtime)[:runtime]
                 if runtime
@@ -140,6 +140,8 @@ module GraphQL
               }
             end
           end
+        ensure
+          Fiber[:__graphql_current_multiplex] = previous_multiplex
         end
       end
 

data/lib/graphql/execution/runner.rb

@@ -72,6 +72,7 @@ module GraphQL
       end
 
       def execute
+        previous_multiplex = Fiber[:__graphql_current_multiplex]
         Fiber[:__graphql_current_multiplex] = @multiplex
         isolated_steps = [[]]
         trace = @multiplex.current_trace
@@ -155,8 +156,14 @@ module GraphQL
             query.result
           end
         end
+      rescue SystemStackError => err
+        @multiplex.queries.map do |query|
+          @schema.query_stack_error(query, err)
+          query.result_values ||= { "errors" => query.context.errors.map(&:to_h) }
+          query.result
+        end
       ensure
-        Fiber[:__graphql_current_multiplex] = nil
+        Fiber[:__graphql_current_multiplex] = previous_multiplex
       end
 
       def gather_selections(type_defn, ast_selections, selections_step, query, all_selections, prototype_result, into:)

data/lib/graphql/float_decoding_error.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+module GraphQL
+  # This error is raised when `Types::Float` is given a non-finite input value.
+  class FloatDecodingError < GraphQL::RuntimeTypeError
+    # The value which couldn't be decoded
+    attr_reader :float_value
+
+    def initialize(value)
+      @float_value = value
+      super("Float is not finite: #{value.inspect}.")
+    end
+  end
+end

data/lib/graphql/float_encoding_error.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+module GraphQL
+  # This error is raised when `Types::Float` is asked to return a non-finite value.
+  class FloatEncodingError < GraphQL::RuntimeTypeError
+    # The value which couldn't be encoded
+    attr_reader :float_value
+
+    # @return [GraphQL::Schema::Field] The field that returned a non-finite float
+    attr_reader :field
+
+    # @return [Array<String, Integer>] Where the field appeared in the GraphQL response
+    attr_reader :path
+
+    def initialize(value, context:)
+      @float_value = value
+      @field = context[:current_field]
+      @path = context[:current_path]
+      message = "Float is not finite: #{value.inspect}".dup
+      if @path
+        message << " @ #{@path.join(".")}"
+      end
+      if @field
+        message << " (#{@field.path})"
+      end
+      super("#{message}.")
+    end
+  end
+end

data/lib/graphql/language/lexer.rb

@@ -9,6 +9,9 @@ module GraphQL
         end
         @string = graphql_str
         @filename = filename
+        if !@string.valid_encoding?
+          raise_parse_error("Parse error on bad Unicode escape sequence", nil, nil)
+        end
         @scanner = StringScanner.new(graphql_str)
         @pos = nil
         @max_tokens = max_tokens || Float::INFINITY
@@ -110,10 +113,6 @@ module GraphQL
           @scanner.pos += 1
           :UNKNOWN_CHAR
         end
-      rescue ArgumentError => err
-        if err.message == "invalid byte sequence in UTF-8"
-          raise_parse_error("Parse error on bad Unicode escape sequence", nil, nil)
-        end
       end
 
       def token_value
@@ -147,7 +146,7 @@ module GraphQL
         "\\r" => "\r",
         "\\t" => "\t",
       }
-      UTF_8 = /\\u(?:([\dAa-f]{4})|\{([\da-f]{4,})\})(?:\\u([\dAa-f]{4}))?/i
+      UTF_8 = /\\u(?:([\da-f]{4})|\{([\da-f]+)\})(?:\\u([\da-f]{4}))?/i
       VALID_STRING = /\A(?:[^\\]|#{ESCAPES}|#{UTF_8})*\z/o
       ESCAPED = /(?:#{ESCAPES}|#{UTF_8})/o
 
@@ -163,7 +162,11 @@ module GraphQL
           if !str.valid_encoding? || !str.match?(VALID_STRING)
             raise_parse_error("Bad unicode escape in #{str.inspect}")
           else
-            Lexer.replace_escaped_characters_in_place(str)
+            begin
+              Lexer.replace_escaped_characters_in_place(str)
+            rescue RangeError
+              raise_parse_error("Bad unicode escape in #{str.inspect}")
+            end
 
             if !str.valid_encoding?
               raise_parse_error("Bad unicode escape in #{str.inspect}")
@@ -289,7 +292,7 @@ module GraphQL
       QUOTE =         '"'
       UNICODE_DIGIT = /[0-9A-Za-z]/
       FOUR_DIGIT_UNICODE = /#{UNICODE_DIGIT}{4}/
-      N_DIGIT_UNICODE = %r{#{Punctuation::LCURLY}#{UNICODE_DIGIT}{4,}#{Punctuation::RCURLY}}x
+      N_DIGIT_UNICODE = %r{#{Punctuation::LCURLY}#{UNICODE_DIGIT}+#{Punctuation::RCURLY}}x
       UNICODE_ESCAPE = %r{\\u(?:#{FOUR_DIGIT_UNICODE}|#{N_DIGIT_UNICODE})}
       STRING_ESCAPE = %r{[\\][\\/bfnrt]}
       BLOCK_QUOTE =   '"""'

data/lib/graphql/language.rb

@@ -34,8 +34,8 @@ module GraphQL
         JSON.generate(value)
       end
     rescue JSON::GeneratorError
-      if Float::INFINITY == value
-        "Infinity"
+      if value.is_a?(Float) && !value.finite?
+        value.to_s
       else
         raise
       end

data/lib/graphql/pagination/relation_connection.rb

@@ -221,7 +221,16 @@ module GraphQL
       # returns an array of nodes
       def load_nodes
         # Return an array so we can consistently use `.index(node)` on it
-        @nodes ||= limited_nodes.to_a
+        return @nodes if @nodes
+        if (@context[:dataloader].is_a?(GraphQL::Dataloader::AsyncDataloader))
+          # `AsyncDataloader` may resolve sibling fields (eg, `edges` and `pageInfo`)
+          # in separate Fibers, so several callers can get here before `@nodes` is set.
+          (@load_lock ||= Mutex.new).synchronize do
+            @nodes ||= limited_nodes.to_a
+          end
+        else
+          @nodes = limited_nodes.to_a
+        end
       end
     end
   end

data/lib/graphql/query/variable_validation_error.rb

@@ -22,7 +22,7 @@ module GraphQL
         # It is possible there are other extension items in this error, so handle
         # a one level deep merge explicitly. However beyond that only show the
         # latest value and problems.
-        super.merge({ "extensions" => { "value" => value, "problems" => validation_result.problems }}) do |key, oldValue, newValue|
+        super.merge({ "extensions" => { "value" => value_for_extensions, "problems" => validation_result.problems }}) do |key, oldValue, newValue|
           if oldValue.respond_to?(:merge)
             oldValue.merge(newValue)
           else
@@ -33,6 +33,21 @@ module GraphQL
 
       private
 
+      def value_for_extensions(value = @value)
+        case value
+        when Array
+          value.map { |item| value_for_extensions(item) }
+        when Hash
+          value.each_with_object({}) do |(key, item), result|
+            result[key] = value_for_extensions(item)
+          end
+        when Float
+          value.finite? ? value : value.to_s
+        else
+          value
+        end
+      end
+
       def problem_fields
         @problem_fields ||= @validation_result
           .problems

data/lib/graphql/schema.rb

@@ -1338,9 +1338,9 @@ module GraphQL
 
           context.errors << execution_error
           execution_error
-        when GraphQL::UnresolvedTypeError, GraphQL::StringEncodingError, GraphQL::IntegerEncodingError
+        when GraphQL::UnresolvedTypeError, GraphQL::StringEncodingError, GraphQL::FloatEncodingError, GraphQL::IntegerEncodingError
           raise type_error
-        when GraphQL::IntegerDecodingError
+        when GraphQL::FloatDecodingError, GraphQL::IntegerDecodingError
           nil
         end
       end

data/lib/graphql/static_validation/rules/fields_will_merge.rb

@@ -15,6 +15,8 @@ module GraphQL
       # separately (which leads to exponential recursion through nested fragments),
       # we flatten all fragment spreads into a single field map and compare within it.
       NO_ARGS = GraphQL::EmptyObjects::EMPTY_HASH
+      EXCLUSIVE_COMPARISON = 1
+      NONEXCLUSIVE_COMPARISON = 2
 
       class Field
         attr_reader :node, :definition, :owner_type, :parents
@@ -33,6 +35,10 @@ module GraphQL
         def unwrapped_return_type
           @unwrapped_return_type ||= return_type&.unwrap
         end
+
+        def comparison_key
+          @comparison_key ||= [@node, @parents]
+        end
       end
 
       def initialize(*)
@@ -43,6 +49,9 @@ module GraphQL
         # Track which sub-selection node pairs have been compared to prevent
         # infinite recursion with cyclic fragments
         @compared_sub_selections = {}.compare_by_identity
+        @compared_field_groups = {}
+        @field_group_signatures = {}.compare_by_identity
+        @field_selection_signatures = {}.compare_by_identity
         # Cache mutually_exclusive? results for type pairs
         @mutually_exclusive_cache = {}.compare_by_identity
         # Cache collect_fields results for sub-selection comparison
@@ -215,21 +224,7 @@ module GraphQL
             end
 
             if all_same
-              # All fields share a signature, so they can only conflict on
-              # sub-selections. Deduplicate by AST node identity — fields from
-              # the same node always have identical sub-selections.
-              unique_nodes = fields.uniq { |f| f.node.object_id }
-              i = 0
-              while i < unique_nodes.size
-                j = i + 1
-                while j < unique_nodes.size
-                  if unique_nodes[i].node.selections.size > 0 || unique_nodes[j].node.selections.size > 0
-                    find_conflict(key, unique_nodes[i], unique_nodes[j])
-                  end
-                  j += 1
-                end
-                i += 1
-              end
+              find_conflicts_between_selection_groups(key, fields)
             else
               groups = fields.group_by { |f| field_signature(f) }
               unique_groups = groups.values
@@ -243,22 +238,10 @@ module GraphQL
                   gj += 1
                 end
 
-                # Within same group, deduplicate by AST node and compare all
-                # pairs for sub-selection conflicts
+                # Within the same group, fields can only conflict on sub-selections.
                 group = unique_groups[gi]
                 if group.size >= 2
-                  unique_in_group = group.uniq { |f| f.node.object_id }
-                  ui = 0
-                  while ui < unique_in_group.size
-                    uj = ui + 1
-                    while uj < unique_in_group.size
-                      if unique_in_group[ui].node.selections.size > 0 || unique_in_group[uj].node.selections.size > 0
-                        find_conflict(key, unique_in_group[ui], unique_in_group[uj])
-                      end
-                      uj += 1
-                    end
-                    ui += 1
-                  end
+                  find_conflicts_between_selection_groups(key, group)
                 end
 
                 gi += 1
@@ -279,6 +262,29 @@ module GraphQL
         end
       end
 
+      def find_conflicts_between_selection_groups(response_key, fields)
+        fields_by_selection = {}
+        fields.each do |field|
+          fields_by_selection[field_selection_signature(field)] ||= field
+        end
+
+        representatives = fields_by_selection.values
+        i = 0
+        while i < representatives.size
+          j = i + 1
+          while j < representatives.size
+            find_conflict(response_key, representatives[i], representatives[j])
+            j += 1
+          end
+          i += 1
+        end
+      end
+
+      def field_selection_signature(field)
+        node = field.node
+        @field_selection_signatures[node] ||= node.selections.map(&:to_query_string)
+      end
+
       def fields_same_signature?(f1, f2)
         n1 = f1.node
         n2 = f2.node
@@ -458,6 +464,7 @@ module GraphQL
         response_keys.each do |key, fields|
           fields2 = response_keys2[key]
           next unless fields2
+          next if field_groups_already_compared?(fields, fields2, mutually_exclusive)
 
           fields_arr = fields.is_a?(Field) ? [fields] : fields
           fields2_arr = fields2.is_a?(Field) ? [fields2] : fields2
@@ -475,6 +482,36 @@ module GraphQL
         end
       end
 
+      def field_groups_already_compared?(fields, fields2, mutually_exclusive)
+        signature1 = field_group_signature(fields)
+        signature2 = field_group_signature(fields2)
+        previous_comparisons = @compared_field_groups[signature1]
+        comparison_state = previous_comparisons && previous_comparisons[signature2]
+
+        if mutually_exclusive
+          return true if comparison_state
+          new_state = EXCLUSIVE_COMPARISON
+        else
+          return true if comparison_state == NONEXCLUSIVE_COMPARISON
+          new_state = NONEXCLUSIVE_COMPARISON
+        end
+
+        previous_comparisons ||= (@compared_field_groups[signature1] = {})
+        previous_comparisons[signature2] = new_state
+
+        reverse_comparisons = @compared_field_groups[signature2] ||= {}
+        reverse_comparisons[signature1] = new_state
+        false
+      end
+
+      def field_group_signature(fields)
+        if fields.is_a?(Field)
+          fields.comparison_key
+        else
+          @field_group_signatures[fields] ||= fields.map(&:comparison_key)
+        end
+      end
+
       def same_arguments?(field1, field2)
         arguments1 = field1.arguments
         arguments2 = field2.arguments

data/lib/graphql/types/float.rb

@@ -5,12 +5,26 @@ module GraphQL
     class Float < GraphQL::Schema::Scalar
       description "Represents signed double-precision fractional values as specified by [IEEE 754](https://en.wikipedia.org/wiki/IEEE_floating_point)."
 
-      def self.coerce_input(value, _ctx)
-        value.is_a?(Numeric) ? value.to_f : nil
+      def self.coerce_input(value, ctx)
+        return if !value.is_a?(Numeric)
+
+        value = value.to_f
+        if value.finite?
+          value
+        else
+          err = GraphQL::FloatDecodingError.new(value)
+          ctx.schema.type_error(err, ctx)
+        end
       end
 
-      def self.coerce_result(value, _ctx)
-        value.to_f
+      def self.coerce_result(value, ctx)
+        value = value.to_f
+        if value.finite?
+          value
+        else
+          err = GraphQL::FloatEncodingError.new(value, context: ctx)
+          ctx.schema.type_error(err, ctx)
+        end
       end
 
       default_scalar true

data/lib/graphql/version.rb

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

data/lib/graphql.rb

@@ -93,6 +93,8 @@ This is probably a bug in GraphQL-Ruby, please report this error on GitHub: http
   autoload :AnalysisError, "graphql/analysis_error"
   autoload :CoercionError, "graphql/coercion_error"
   autoload :InvalidNameError, "graphql/invalid_name_error"
+  autoload :FloatDecodingError, "graphql/float_decoding_error"
+  autoload :FloatEncodingError, "graphql/float_encoding_error"
   autoload :IntegerDecodingError, "graphql/integer_decoding_error"
   autoload :IntegerEncodingError, "graphql/integer_encoding_error"
   autoload :StringEncodingError, "graphql/string_encoding_error"

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.6.9
+  version: 2.6.10
 platform: ruby
 authors:
 - Robert Mosolgo
 bindir: bin
 cert_chain: []
-date: 2026-08-17 00:00:00.000000000 Z
+date: 2026-08-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -460,6 +460,8 @@ files:
 - lib/graphql/execution/runner.rb
 - lib/graphql/execution/selections_step.rb
 - lib/graphql/execution_error.rb
+- lib/graphql/float_decoding_error.rb
+- lib/graphql/float_encoding_error.rb
 - lib/graphql/integer_decoding_error.rb
 - lib/graphql/integer_encoding_error.rb
 - lib/graphql/introspection.rb