graphql 2.6.9 → 2.6.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6a359d53729477046ffd6b51ef9345099defcdc95521579711fffe5ab79c0b5e
-  data.tar.gz: 4c88aecd90fb26e02198f21f4bdf7a73f577ec37ac9ea9eb6c840c8a2957fc7a
+  metadata.gz: f449cab829c8314cf4cd1b51e225e70603f5dc16dfcb221d3204aa39bd9fe2cd
+  data.tar.gz: 6fb74ee40392f0663b728c76e72239596fc82271d2222e2d9170d8ad06579f6c
 SHA512:
-  metadata.gz: d40bb56d8b5e77ca6f126f1528e2a074bbf679996dfb8ea5a12d646d028d547848dc36dea3a5fb73273fb7252135a5c7e904ec7d0a38790fe05164c5e81701b5
-  data.tar.gz: e486b9492693cdc69375f8d3bc662e075a71ff45642f62cb2fd741959b2a2d1f9105fa14718b992ef2d3b3a809fd0f0d94ec66abf509137b3a7af05877527c23
+  metadata.gz: 2820887a516c9a015774633ac126924642ceb778b523d0563af9ba766f6a3bfa5fa89ad0420c9ea3ee5208fe8fcdd58101aff1777b44de98c8c12b01fd64be0d
+  data.tar.gz: 90856cb6b43ac1be362d3358820857c1c8cc038f19def34a119677a6924c7b1441eca628c9e26a2134ae52aaab7507cea3521e36cad2763614909c10d8a79577

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

@@ -262,11 +262,12 @@ module GraphQL
 
     def spawn_fiber
       fiber_vars = get_fiber_variables
-      Fiber.new(blocking: !@nonblocking) {
+      Fiber.new(blocking: !@nonblocking) do
         set_fiber_variables(fiber_vars)
         yield
+      ensure
         cleanup_fiber
-      }
+      end
     end
 
     # Pre-warm the Dataloader cache with ActiveRecord objects which were loaded elsewhere.
@@ -359,6 +360,7 @@ module GraphQL
           while job = @pending_jobs.shift
             job.call
           end
+        ensure
           trace&.dataloader_fiber_exit
         end
       end
@@ -392,6 +394,7 @@ module GraphQL
             source.run_pending_keys
             trace&.end_dataloader_source(source)
           end
+        ensure
           trace&.dataloader_fiber_exit
         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
@@ -86,10 +87,10 @@ module GraphQL
           @schema.analysis_engine.analyze_multiplex(@multiplex, multiplex_analyzers)
           trace.end_analyze_multiplex(@multiplex, multiplex_analyzers)
 
-          results = []
+          results = {}.compare_by_identity
           queries.each do |query|
             if query.validate && !query.valid?
-              results << {
+              results[query] = {
                 "errors" => query.static_errors.map(&:to_h)
               }
               next
@@ -124,8 +125,8 @@ module GraphQL
             end
           end
 
-          queries.each_with_index.map do |query, idx|
-            result = results[idx]
+          queries.map do |query|
+            result = results[query]
 
             fin_result = if (!@finalizers&.key?(query) && query.context.errors.empty?) || !query.valid?
               result
@@ -154,9 +155,19 @@ module GraphQL
             end
             query.result
           end
+        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
+          # Assign values here so that the query's `@executed` becomes true
+          queries.map { |q| q.result_values ||= {} }
+          raise
         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:)
@@ -255,12 +266,12 @@ module GraphQL
             end
 
             if !auth_check
-              results << {}
+              results[query] = {}
               return
             end
           end
 
-          results << { "data" => data }
+          results[query] = { "data" => data }
           objects = [root_value]
           query.current_trace.objects(root_type, objects, query.context)
 
@@ -354,7 +365,7 @@ module GraphQL
           objects = [root_value]
           query.current_trace.objects(resolved_type, objects, query.context)
           runtime_type_at[data] = resolved_type
-          results << { "data" => data }
+          results[query] = { "data" => data }
           isolated_steps[0] << SelectionsStep.new(
             parent_type: resolved_type,
             field_resolve_step: nil,
@@ -369,10 +380,10 @@ module GraphQL
           inner_type = root_type.unwrap
           case inner_type.kind.name
           when "SCALAR", "ENUM"
-            results << run_isolated_scalar(root_type, query)
+            results[query] = run_isolated_scalar(root_type, query)
           else
             list_result = Array.new(root_value.size) { Hash.new.compare_by_identity }
-            results << { "data" => list_result }
+            results[query] = { "data" => list_result }
             isolated_steps[0] << SelectionsStep.new(
               parent_type: inner_type,
               field_resolve_step: nil,
@@ -385,7 +396,7 @@ module GraphQL
             )
           end
         when "SCALAR", "ENUM"
-          results << run_isolated_scalar(root_type, query)
+          results[query] = run_isolated_scalar(root_type, query)
         else
           raise "Unhandled root type kind: #{root_type.kind.name.inspect}"
         end
@@ -418,7 +429,7 @@ module GraphQL
         key = dummy_path.pop
         is_from_array = key.is_a?(Integer)
 
-        if lazy?(value)
+        if resolves_lazies && lazy?(value)
           value = @schema.sync_lazy(value)
         end
         selections = partial.ast_nodes

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

@@ -27,7 +27,11 @@ module GraphQL
       private
 
       def index_from_cursor(cursor)
-        decode(cursor).to_i
+        index = Integer(decode(cursor), 10, exception: false)
+        if index.nil? || index <= 0
+          raise GraphQL::ExecutionError, "Invalid cursor: #{cursor.inspect}"
+        end
+        [index, items.length + 1].min
       end
 
       # Populate all the pagination info _once_,

data/lib/graphql/pagination/relation_connection.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 require "graphql/pagination/connection"
+require "monitor"
 
 module GraphQL
   module Pagination
@@ -178,6 +179,17 @@ module GraphQL
       # Apply `first` and `last` to `sliced_nodes`,
       # returning a new relation
       def limited_nodes
+        return @limited_nodes if @limited_nodes
+        if async_dataloader?
+          (@load_monitor ||= Monitor.new).synchronize do
+            build_limited_nodes
+          end
+        else
+          build_limited_nodes
+        end
+      end
+
+      def build_limited_nodes
         @limited_nodes ||= begin
           calculate_sliced_nodes_parameters
           if @sliced_nodes_null_relation
@@ -217,11 +229,24 @@ module GraphQL
         end
       end
 
+      def async_dataloader?
+        @context&.[](:dataloader).is_a?(GraphQL::Dataloader::AsyncDataloader)
+      end
+
       # Load nodes after applying first/last/before/after,
       # 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 async_dataloader?
+          # `AsyncDataloader` may resolve sibling fields (eg, `edges` and `pageInfo`)
+          # in separate Fibers, so several callers can get here before `@nodes` is set.
+          (@load_monitor ||= Monitor.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/query.rb

@@ -287,7 +287,8 @@ module GraphQL
     # @return [GraphQL::Query::Result] A Hash-like GraphQL response, with `"data"` and/or `"errors"` keys
     def result
       if !@executed
-        Execution::Interpreter.run_all(@schema, [self], context: @context)
+        execution_engine = @schema.default_execution_next ? Execution::Next : Execution::Interpreter
+        execution_engine.run_all(@schema, [self], context: @context)
       end
       @result ||= Query::Result.new(query: self, values: @result_values)
     end

data/lib/graphql/schema/directive.rb

@@ -84,6 +84,11 @@ module GraphQL
           yield
         end
 
+        def resolve_field(...); end
+        def resolve_fragment_spread(...); end
+        def resolve_inline_fragment(...); end
+        def resolve_operation(...); end
+
         def validate!(arguments, context)
           Schema::Validator.validate!(validators, self, context, arguments)
         end

data/lib/graphql/schema/member/has_arguments.rb

@@ -397,7 +397,7 @@ module GraphQL
                       # This union/interface is used in `loads:` but not otherwise visible to this query
                       context.types.loadable_possible_types(arg_loads_type, context).include?(application_object_type)
                     else
-                      true
+                      arg_loads_type == application_object_type
                     end
                   else
                     context.types.possible_types(arg_loads_type).include?(application_object_type)

data/lib/graphql/schema/visibility/profile.rb

@@ -287,8 +287,12 @@ module GraphQL
               end
             elsif type_defn.kind.enum?
               enum_values(type_defn)
+            elsif type_defn.kind.union?
+              loadable_possible_types(type_defn, @context)
+            elsif type_defn.kind.object? || type_defn.kind.interface?
+              interfaces(type_defn)
             end
-            # Lots more to do here
+            possible_types(type_defn)
           end
           if @schema.query
             @schema.introspection_system.entry_points.each do |f|
@@ -304,6 +308,11 @@ module GraphQL
             end
           end
 
+          directives.each do |directive|
+            arguments(directive).each do |directive_argument|
+              argument(directive, directive_argument.graphql_name)
+            end
+          end
         end
 
         private

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/subscriptions/serialize.rb

@@ -13,6 +13,8 @@ module GraphQL
       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__"
+      HASH_KEY = "__graphql_hash__"
+      RESERVED_KEYS = [GLOBALID_KEY, SYMBOL_KEY, SYMBOL_KEYS_KEY, TIMESTAMP_KEY, OPEN_STRUCT_KEY, HASH_KEY].freeze
 
       module_function
 
@@ -57,7 +59,7 @@ module GraphQL
         # @return [Object] An object that load Global::Identification recursive
         def load_value(value)
           if value.is_a?(Array)
-            is_gids = (v1 = value[0]).is_a?(Hash) && v1.size == 1 && v1[GLOBALID_KEY]
+            is_gids = !value.empty? && value.all? { |v| v.is_a?(Hash) && v.size == 1 && v[GLOBALID_KEY] }
             if is_gids
               # Assume it's an array of global IDs
               ids = value.map { |v| v[GLOBALID_KEY] }
@@ -91,6 +93,10 @@ module GraphQL
               when OPEN_STRUCT_KEY
                 ostruct_values = load_value(value[OPEN_STRUCT_KEY])
                 OpenStruct.new(ostruct_values)
+              when HASH_KEY
+                value[HASH_KEY].each_with_object({}) do |(k, v), loaded_h|
+                  loaded_h[load_value(k)] = load_value(v)
+                end
               else
                 key = value.keys.first
                 { key => load_value(value[key]) }
@@ -98,15 +104,21 @@ module GraphQL
             else
               loaded_h = {}
               sym_keys = value.fetch(SYMBOL_KEYS_KEY, [])
+              symbol_key_values = sym_keys.is_a?(Hash) ? sym_keys : nil
               value.each do |k, v|
                 if k == SYMBOL_KEYS_KEY
                   next
                 end
-                if sym_keys.include?(k)
+                if !symbol_key_values && sym_keys.include?(k)
                   k = k.to_sym
                 end
                 loaded_h[k] = load_value(v)
               end
+              if symbol_key_values
+                symbol_key_values.each do |k, v|
+                  loaded_h[k.to_sym] = load_value(v)
+                end
+              end
               loaded_h
             end
           else
@@ -120,16 +132,31 @@ module GraphQL
           if obj.is_a?(Array)
             obj.map{|item| dump_value(item)}
           elsif obj.is_a?(Hash)
+            has_colliding_symbol_key = obj.any? { |k, _v| k.is_a?(Symbol) && obj.key?(k.to_s) }
+            if obj.any? { |k, _v| RESERVED_KEYS.include?(k.to_s) }
+              return {
+                HASH_KEY => obj.map { |k, v| [dump_value(k.is_a?(Symbol) ? k : k.to_s), dump_value(v)] },
+              }
+            end
             symbol_keys = nil
+            symbol_key_values = nil
             dumped_h = {}
             obj.each do |k, v|
-              dumped_h[k.to_s] = dump_value(v)
-              if k.is_a?(Symbol)
+              dumped_v = dump_value(v)
+              if has_colliding_symbol_key && k.is_a?(Symbol)
+                symbol_key_values ||= {}
+                symbol_key_values[k.to_s] = dumped_v
+              else
+                dumped_h[k.to_s] = dumped_v
+              end
+              if !has_colliding_symbol_key && k.is_a?(Symbol)
                 symbol_keys ||= Set.new
                 symbol_keys << k.to_s
               end
             end
-            if symbol_keys
+            if symbol_key_values
+              dumped_h[SYMBOL_KEYS_KEY] = symbol_key_values
+            elsif symbol_keys
               dumped_h[SYMBOL_KEYS_KEY] = symbol_keys.to_a
             end
             dumped_h

data/lib/graphql/tracing/sentry_trace.rb

@@ -37,13 +37,18 @@ module GraphQL
                     scope.set_transaction_name(transaction_name(query))
                   end
                 end
-                span.set_data('graphql.document', query.query_string)
+                if graphql_data_collection.nil? || graphql_data_collection.document
+                  span.set_data('graphql.document', query.query_string)
+                end
                 if query.selected_operation_name
                   span.set_data('graphql.operation.name', query.selected_operation_name)
                 end
                 if query.selected_operation
                   span.set_data('graphql.operation.type', query.selected_operation.operation_type)
                 end
+                if graphql_data_collection&.variables && !query.provided_variables.empty?
+                  span.set_data('graphql.variables', query.provided_variables)
+                end
               end
             end
 
@@ -55,6 +60,13 @@ module GraphQL
 
         private
 
+        def graphql_data_collection
+          @graphql_data_collection ||= if Sentry.respond_to?(:configuration)
+            configuration = Sentry.configuration
+            configuration.data_collection.graphql if configuration.respond_to?(:data_collection)
+          end
+        end
+
         def operation_name(query)
           selected_op = query.selected_operation
           if selected_op

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.11"
 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.11
 platform: ruby
 authors:
 - Robert Mosolgo
 bindir: bin
 cert_chain: []
-date: 2026-08-17 00:00:00.000000000 Z
+date: 2026-09-21 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