graphql 2.6.10 → 2.6.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a6c191887acba06a4030f962822e9106e9d3aa9d5550c8cd25ea76f343927f1b
-  data.tar.gz: b984ad9a61a391b4b8a42ade3bb9c63dc79ab2b3ee987845d655dc7038df1255
+  metadata.gz: 24a0e699fe2f72dd869173b2bc6aa96ec8d40e738a293bc56b9176debca03861
+  data.tar.gz: 18b16bf0c467f5f8dc0c00ea2bcf2fbaf53283edc9f09a3789918523090a97ce
 SHA512:
-  metadata.gz: 7deac13ce0bbc579609e28575a309caa46086196f1381cfc5fbd6a5770b2059e123cb047cc835c573ad76be1df264a3b0d52d8692dbf161ad0d0248f8cfed2a3
-  data.tar.gz: 1362c0867ad8bbbe086b1999c710f447de6ea16b53b8a05a83dc39cba6c7b7d8d5cccdc388a3dff2f42c1b5135ff59a4c78dd2d53badd34b28718a73aa331b92
+  metadata.gz: 74a34839ced3a300d20ca370cb37a7c88c56345ecb056e9b9caa7a424fdb7573c5a014b80a32772cc2a5eb40d83e568c5d0875d93b029b1663dda9547fc06ba1
+  data.tar.gz: 65dcfea9802c9fb682e6595ef2d2d224a256c0650ff24fa57774eac420b27e594b3c432a104d76c8e033c659a608940661ea4503e0737f63d7839ff36f5f4405

data/lib/graphql/dataloader/async_dataloader.rb

@@ -254,6 +254,8 @@ module GraphQL
           task = Async::Task.new do |root_task|
             run.root_task = root_task
             root_task.graphql_async_dataloader_run = run
+            # Tasks inherit the spawning fiber's storage; give this run its own execution state.
+            Fiber[:__graphql_runtime_info] = nil
             set_fiber_variables(fiber_vars)
 
             while first_pass || run.running? || !jobs.empty?

data/lib/graphql/dataloader.rb

@@ -262,11 +262,14 @@ module GraphQL
 
     def spawn_fiber
       fiber_vars = get_fiber_variables
-      Fiber.new(blocking: !@nonblocking) {
+      Fiber.new(blocking: !@nonblocking) do
+        # Fibers inherit the spawning fiber's storage; give each one its own execution state.
+        Fiber[:__graphql_runtime_info] = nil
         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 +362,7 @@ module GraphQL
           while job = @pending_jobs.shift
             job.call
           end
+        ensure
           trace&.dataloader_fiber_exit
         end
       end
@@ -392,6 +396,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

@@ -2,6 +2,10 @@
 module GraphQL
   module Execution
     class FieldResolveStep
+      # Only these built-in fields on Relay connection and edge types return already-scoped items.
+      # Custom fields on those types must still be authorized normally.
+      SCOPED_RELAY_FIELD_NAMES = [:node, :nodes, :edges].freeze
+
       def initialize(parent_type:, runner:, key:, selections_step:)
         @selections_step = selections_step
         @key = key
@@ -283,7 +287,7 @@ module GraphQL
           authorized_objects = objects
         end
 
-        if @parent_type.default_relay? && authorized_objects.all? { |o| o.respond_to?(:was_authorized_by_scope_items?) && o.was_authorized_by_scope_items? }
+        if @parent_type.default_relay? && SCOPED_RELAY_FIELD_NAMES.include?(@field_definition.original_name) && authorized_objects.all? { |o| o.respond_to?(:was_authorized_by_scope_items?) && o.was_authorized_by_scope_items? }
           @was_scoped = true
         end
 
@@ -527,7 +531,7 @@ module GraphQL
           end
 
           inner_type = return_type.of_type
-          result_a = Array.new(field_result.size)
+          result_a = field_result.is_a?(Array) ? Array.new(field_result.size) : []
           field_result.each_with_index do |item, idx|
             result_a[idx] = build_leaf_result(result_a, idx, item, inner_type, ctx, true)
           end
@@ -645,11 +649,18 @@ module GraphQL
           list_result = graphql_result[key] = []
           @directive_finalizers&.each { |f| @runner.add_finalizer(@selections_step.query, list_result, nil, f) }
           i = 0
-          s = field_result.size
-          while i < s
-            inner_f_r = field_result[i]
-            build_graphql_result(list_result, i, inner_f_r, inner_type, inner_type_nn, inner_type_l, true)
-            i += 1
+          if field_result.is_a?(Array)
+            s = field_result.size
+            while i < s
+              inner_f_r = field_result[i]
+              build_graphql_result(list_result, i, inner_f_r, inner_type, inner_type_nn, inner_type_l, true)
+              i += 1
+            end
+          else
+            field_result.each do |inner_f_r|
+              build_graphql_result(list_result, i, inner_f_r, inner_type, inner_type_nn, inner_type_l, true)
+              i += 1
+            end
           end
         elsif @runner.resolves_lazies || (
                 @static_type.kind.object? ?

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

@@ -619,7 +619,9 @@ module GraphQL
           when Array
             # It's an array full of execution errors; add them all.
             if !value.empty? && value.all?(GraphQL::ExecutionError)
-              list_type_at_all = (field && (field.type.list?))
+              list_type = field && field.type
+              list_type = list_type.of_type if list_type && list_type.non_null?
+              list_type_at_all = list_type && list_type.list?
               if selection_result.nil? || !selection_result.graphql_dead
                 value.each_with_index do |error, index|
                   error.ast_node ||= ast_node
@@ -627,7 +629,7 @@ module GraphQL
                   context.errors << error
                 end
                 if selection_result
-                  if list_type_at_all
+                  if list_type_at_all && !list_type.of_type.non_null?
                     result_without_errors = value.map { |v| v.is_a?(GraphQL::ExecutionError) ? nil : v }
                     set_result(selection_result, result_name, result_without_errors, false, is_non_null)
                   else
@@ -798,6 +800,8 @@ module GraphQL
 
         def resolve_list_item(inner_value, inner_type, inner_type_non_null, ast_node, field, owner_object, arguments, this_idx, response_list, owner_type, was_scoped, runtime_state) # rubocop:disable Metrics/ParameterLists
           runtime_state ||= get_current_runtime_state
+          runtime_state.current_field = field
+          runtime_state.current_arguments = arguments
           runtime_state.current_result_name = this_idx
           runtime_state.current_result = response_list
           call_method_on_directives(:resolve_each, owner_object, ast_node.directives) do

data/lib/graphql/execution/runner.rb

@@ -87,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
@@ -125,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
@@ -155,12 +155,16 @@ module GraphQL
             end
             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
+        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] = previous_multiplex
@@ -262,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)
 
@@ -361,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,
@@ -376,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,
@@ -392,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
@@ -425,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/language/parser.rb

@@ -65,24 +65,25 @@ module GraphQL
       end
 
       def column_at(pos)
-        next_line_idx = lines_at.bsearch_index { |l| l >= pos } || 0
-        if next_line_idx > 0
-          line_pos = @lines_at[next_line_idx - 1]
-          pos - line_pos
+        next_line_idx = lines_at.bsearch_index { |l| l >= pos } || @lines_at.size
+        line_start = next_line_idx == 0 ? 0 : @lines_at[next_line_idx - 1] + 1
+        if @graphql_str.ascii_only?
+          pos - line_start + 1
         else
-          pos + 1
+          @graphql_str.byteslice(line_start, pos - line_start).force_encoding(Encoding::UTF_8).length + 1
         end
       end
 
       private
 
-      # @return [Array<Integer>] Positions of each line break in the original string
+      # @return [Array<Integer>] Byte offsets of each line break in the original string
       def lines_at
         @lines_at ||= begin
+          graphql_str = @graphql_str.b
           la = []
           idx = 0
           while idx
-            idx = @graphql_str.index("\n", idx)
+            idx = graphql_str.index("\n", idx)
             if idx
               la << idx
               idx += 1

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
@@ -87,7 +88,11 @@ module GraphQL
 
       # @return [Integer]
       def offset_from_cursor(cursor)
-        decode(cursor).to_i
+        offset = Integer(decode(cursor), 10, exception: false)
+        if offset.nil? || offset <= 0
+          raise GraphQL::ExecutionError, "Invalid cursor: #{cursor.inspect}"
+        end
+        offset
       end
 
       # Abstract this operation so we can always ignore inputs less than zero.
@@ -178,6 +183,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,15 +233,19 @@ 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
         return @nodes if @nodes
-        if (@context[:dataloader].is_a?(GraphQL::Dataloader::AsyncDataloader))
+        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_lock ||= Mutex.new).synchronize do
+          (@load_monitor ||= Monitor.new).synchronize do
             @nodes ||= limited_nodes.to_a
           end
         else

data/lib/graphql/query/variables.rb

@@ -35,7 +35,11 @@ module GraphQL
             value_was_provided =  @provided_variables.key?(variable_name)
             max_errors = schema.validate_max_errors - @errors.count if schema.validate_max_errors
             begin
-              validation_result = variable_type.validate_input(provided_value, ctx, max_errors: max_errors)
+              validation_result = if value_was_provided || default_value.nil?
+                variable_type.validate_input(provided_value, ctx, max_errors: max_errors)
+              else
+                GraphQL::Query::InputValidationResult::VALID
+              end
               if validation_result.valid?
                 if value_was_provided
                   # Add the variable if a value was provided

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

@@ -33,30 +33,49 @@ module GraphQL
 
         def freeze
           @cached_visible.default_proc = nil
+          @cached_visible.freeze
           @cached_visible_fields.default_proc = nil
           @cached_visible_fields.each do |type, fields|
             fields.default_proc = nil
+            fields.freeze
           end
+          @cached_visible_fields.freeze
           @cached_visible_arguments.default_proc = nil
           @cached_visible_arguments.each do |type, fields|
             fields.default_proc = nil
+            fields.freeze
           end
+          @cached_visible_arguments.freeze
           @cached_parent_fields.default_proc = nil
           @cached_parent_fields.each do |type, fields|
             fields.default_proc = nil
+            fields.freeze
           end
+          @cached_parent_fields.freeze
           @cached_parent_arguments.default_proc = nil
           @cached_parent_arguments.each do |type, args|
             args.default_proc = nil
+            args.freeze
           end
+          @cached_parent_arguments.freeze
           @cached_possible_types.default_proc = nil
+          @cached_possible_types.freeze
           @cached_enum_values.default_proc = nil
+          @cached_enum_values.freeze
           @cached_fields.default_proc = nil
+          @cached_fields.freeze
           @cached_arguments.default_proc = nil
+          @cached_arguments.freeze
           @loadable_possible_types.default_proc = nil
+          @loadable_possible_types.freeze
           @cached_field_result.default_proc = nil
-          @cached_field_result.each { |_, h| h.default_proc = nil }
+          @cached_field_result.each do |_, h|
+            h.default_proc = nil
+            h.freeze
+          end
+          @cached_field_result.freeze
           @cached_type_result.default_proc = nil
+          @cached_type_result.freeze
           super
         end
 
@@ -277,18 +296,31 @@ module GraphQL
                 arguments(f).each do |arg|
                   argument(f, arg.graphql_name)
                 end
+
+                resolver_class = f.resolver
+                if resolver_class
+                  arguments(resolver_class).each do |arg|
+                    argument(resolver_class, arg.graphql_name)
+                  end
+                end
               end
               @schema.introspection_system.dynamic_fields.each do |f|
                 field(type_defn, f.graphql_name)
               end
+              interfaces(type_defn)
             elsif type_defn.kind.input_object?
               arguments(type_defn).each do |arg|
                 argument(type_defn, arg.graphql_name)
               end
             elsif type_defn.kind.enum?
               enum_values(type_defn)
+            elsif type_defn.kind.union?
+              loadable_possible_types(type_defn, @context)
+              @schema.introspection_system.dynamic_fields.each do |f|
+                field(type_defn, f.graphql_name)
+              end
             end
-            # Lots more to do here
+            possible_types(type_defn)
           end
           if @schema.query
             @schema.introspection_system.entry_points.each do |f|
@@ -304,6 +336,25 @@ module GraphQL
             end
           end
 
+          directives.each do |directive|
+            arguments(directive).each do |directive_argument|
+              argument(directive, directive_argument.graphql_name)
+            end
+          end
+
+          @cached_arguments.each do |owner, args|
+            @cached_parent_arguments[owner]
+
+            args.each do |arg|
+              if (loads_type = arg.loads)
+                loadable?(loads_type, @context)
+                possible_types(loads_type)
+                if loads_type.kind.union?
+                  loadable_possible_types(loads_type, @context)
+                end
+              end
+            end
+          end
         end
 
         private

data/lib/graphql/static_validation/base_visitor.rb

@@ -16,6 +16,7 @@ module GraphQL
         @schema = context.schema
         @inline_fragment_paths = {}
         @field_unwrapped_types = {}.compare_by_identity
+        @child_positions = {}.compare_by_identity
         super(document)
       end
 
@@ -159,6 +160,7 @@ module GraphQL
           @current_argument_definition = @parent_argument_definition
           @parent_argument_definition = prev_parent
           @path_depth -= 1
+          @child_positions.delete(node)
         end
 
         def on_fragment_spread(node, parent)
@@ -171,7 +173,7 @@ module GraphQL
         def on_input_object(node, parent)
           arg_defn = @current_argument_definition
           if arg_defn && arg_defn.type.list?
-            @path[@path_depth] = parent.children.index(node)
+            @path[@path_depth] = child_positions(parent)[node]
             @path_depth += 1
             super
             @path_depth -= 1
@@ -180,6 +182,14 @@ module GraphQL
           end
         end
 
+        def child_positions(parent)
+          @child_positions[parent] ||= begin
+            positions = {}.compare_by_identity
+            parent.children.each_with_index { |child, index| positions[child] ||= index }
+            positions
+          end
+        end
+
         # @return [GraphQL::BaseType] The current object type
         def type_definition
           @current_object_type

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

@@ -9,18 +9,53 @@ module GraphQL
               'Schema is not configured for subscriptions',
               nodes: node
             ))
-          elsif node.selections.size != 1
-            add_error(GraphQL::StaticValidation::NotSingleSubscriptionError.new(
-              'A subscription operation may only have one selection',
-              nodes: node,
-            ))
           else
+            root_fields = subscription_root_fields(node)
+            if root_fields.map { |field| field.alias || field.name }.uniq.size != 1
+              add_error(GraphQL::StaticValidation::NotSingleSubscriptionError.new(
+                'A subscription operation may only have one selection',
+                nodes: node,
+              ))
+            elsif root_fields.any? { |field| field.name.start_with?("__") }
+              add_error(GraphQL::StaticValidation::NotSingleSubscriptionError.new(
+                'A subscription operation may not select an introspection field',
+                nodes: node,
+              ))
+            end
             super
           end
         else
           super
         end
       end
+
+      private
+
+      def subscription_root_fields(node)
+        root_type = context.types.subscription_root
+        fields = []
+        selections = node.selections.dup
+        visited_fragments = {}
+
+        while (selection = selections.pop)
+          case selection
+          when GraphQL::Language::Nodes::Field
+            fields << selection
+          when GraphQL::Language::Nodes::FragmentSpread
+            next if visited_fragments[selection.name]
+            visited_fragments[selection.name] = true
+            fragment = context.fragments[selection.name]
+            selections << fragment if fragment
+          when GraphQL::Language::Nodes::InlineFragment, GraphQL::Language::Nodes::FragmentDefinition
+            fragment_type = selection.type ? @types.type(selection.type.name) : root_type
+            if fragment_type && fragment_type.kind.composite? && @types.possible_types(fragment_type).include?(root_type)
+              selections.concat(selection.selections)
+            end
+          end
+        end
+
+        fields
+      end
     end
   end
 end

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

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.6.10
+  version: 2.6.12
 platform: ruby
 authors:
 - Robert Mosolgo
 bindir: bin
 cert_chain: []
-date: 2026-08-27 00:00:00.000000000 Z
+date: 2026-10-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64