graphql 2.4.8 → 2.4.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 386222d0dc13d35729460ee8f3cd9fa30f90db9cb7dc2b2392489c9e0bc8939b
-  data.tar.gz: 5229e7ee84d4c4e0a0c8afd10ef2b0185b0eedfc611a8db38047171d9c04a6e2
+  metadata.gz: 687da1733554d6abed2daad506c7f9d55d9126e373274572af5b255c3d7b4918
+  data.tar.gz: c2d2f58175df62c91ab31c3216b970a0bc09d1752250fc8192d1faa958cf1fe9
 SHA512:
-  metadata.gz: 4cb91383b995e8714915d2c99d8c2d4fa15eaad91f0069766d7e8d379cae15c2aae6eb7a3961e440d62a961837a044aed604802960f199e8670ecf973c991fb2
-  data.tar.gz: 8cd21fd942892100a0647bf9897e6e7d8651d184aee76a2988633fa3e9dc505163f330bb1f0ca3f4819cbb3248cd88e9ac252f516449ae169c1a3f47a982e11c
+  metadata.gz: f4001700112f8ed43e78b4c739daac90973f08035bef426d5611d91248dd60d4d0070f8fff7042ac57b0549ddac62ac1111262fe0a47c10a83cd3c7a9a0612b8
+  data.tar.gz: a6a1aaacf19bba38d2e0ee55ac9cdfa0d46b915706557c2dbac533d8fc58319d7c4ff8509019789fb39c46d6c01767f6cd27a02917fc7a3a7bdc30fc81eca5e4

data/lib/graphql/backtrace/table.rb

@@ -36,7 +36,70 @@ module GraphQL
       private
 
       def rows
-        @rows ||= build_rows(@context, rows: [HEADERS], top: true)
+        @rows ||= begin
+          query = @context.query
+          query_ctx = @context
+          runtime_inst = query_ctx.namespace(:interpreter_runtime)[:runtime]
+          result = runtime_inst.instance_variable_get(:@response)
+          rows = []
+          result_path = []
+          last_part = nil
+          path = @context.current_path
+          path.each do |path_part|
+            value = value_at(runtime_inst, result_path)
+
+            if result_path.empty?
+              name = query.selected_operation.operation_type || "query"
+              if (n = query.selected_operation_name)
+                name += " #{n}"
+              end
+              args = query.variables
+            else
+              name = result.graphql_field.path
+              args = result.graphql_arguments
+            end
+
+            object = result.graphql_parent ? result.graphql_parent.graphql_application_value : result.graphql_application_value
+            object = object.object.inspect
+
+            rows << [
+              result.ast_node.position.join(":"),
+              name,
+              "#{object}",
+              args.to_h.inspect,
+              inspect_result(value),
+            ]
+
+            result_path << path_part
+            if path_part == path.last
+              last_part = path_part
+            else
+              result = result[path_part]
+            end
+          end
+
+
+          object = result.graphql_application_value.object.inspect
+          ast_node = result.graphql_selections.find { |s| s.alias == last_part || s.name == last_part }
+          field_defn = query.get_field(result.graphql_result_type, ast_node.name)
+          args = query.arguments_for(ast_node, field_defn).to_h
+          field_path = field_defn.path
+          if ast_node.alias
+            field_path += " as #{ast_node.alias}"
+          end
+
+          rows << [
+            ast_node.position.join(":"),
+            field_path,
+            "#{object}",
+            args.inspect,
+            inspect_result(@override_value)
+          ]
+
+          rows << HEADERS
+          rows.reverse!
+          rows
+        end
       end
 
       # @return [String]
@@ -75,67 +138,44 @@ module GraphQL
         table
       end
 
-      # @return [Array] 5 items for a backtrace table (not `key`)
-      def build_rows(context_entry, rows:, top: false)
-        case context_entry
-        when Backtrace::Frame
-          field_alias = context_entry.ast_node.respond_to?(:alias) && context_entry.ast_node.alias
-          value = if top && @override_value
-            @override_value
-          else
-            value_at(@context.query.context.namespace(:interpreter_runtime)[:runtime], context_entry.path)
-          end
-          rows << [
-            "#{context_entry.ast_node ? context_entry.ast_node.position.join(":") : ""}",
-            "#{context_entry.field.path}#{field_alias ? " as #{field_alias}" : ""}",
-            "#{context_entry.object.object.inspect}",
-            context_entry.arguments.to_h.inspect, # rubocop:disable Development/ContextIsPassedCop -- unrelated method
-            Backtrace::InspectResult.inspect_result(value),
-          ]
-          if (parent = context_entry.parent_frame)
-            build_rows(parent, rows: rows)
-          else
-            rows
-          end
-        when GraphQL::Query::Context
-          query = context_entry.query
-          op = query.selected_operation
-          if op
-            op_type = op.operation_type
-            position = "#{op.line}:#{op.col}"
-          else
-            op_type = "query"
-            position = "?:?"
-          end
-          op_name = query.selected_operation_name
-          object = query.root_value
-          if object.is_a?(GraphQL::Schema::Object)
-            object = object.object
-          end
-          value = value_at(context_entry.namespace(:interpreter_runtime)[:runtime], [])
-          rows << [
-            "#{position}",
-            "#{op_type}#{op_name ? " #{op_name}" : ""}",
-            "#{object.inspect}",
-            query.variables.to_h.inspect,
-            Backtrace::InspectResult.inspect_result(value),
-          ]
-        else
-          raise "Unexpected get_rows subject #{context_entry.class} (#{context_entry.inspect})"
-        end
-      end
 
       def value_at(runtime, path)
         response = runtime.final_result
         path.each do |key|
-          if response && (response = response[key])
-            next
-          else
-            break
-          end
+          response && (response = response[key])
         end
         response
       end
+
+      def inspect_result(obj)
+        case obj
+        when Hash
+          "{" +
+            obj.map do |key, val|
+              "#{key}: #{inspect_truncated(val)}"
+            end.join(", ") +
+            "}"
+        when Array
+          "[" +
+            obj.map { |v| inspect_truncated(v) }.join(", ") +
+            "]"
+        else
+          inspect_truncated(obj)
+        end
+      end
+
+      def inspect_truncated(obj)
+        case obj
+        when Hash
+          "{...}"
+        when Array
+          "[...]"
+        when GraphQL::Execution::Lazy
+          "(unresolved)"
+        else
+          "#{obj.inspect}"
+        end
+      end
     end
   end
 end

data/lib/graphql/backtrace.rb

@@ -1,9 +1,6 @@
 # frozen_string_literal: true
-require "graphql/backtrace/inspect_result"
 require "graphql/backtrace/table"
 require "graphql/backtrace/traced_error"
-require "graphql/backtrace/tracer"
-require "graphql/backtrace/trace"
 module GraphQL
   # Wrap unhandled errors with {TracedError}.
   #
@@ -24,7 +21,7 @@ module GraphQL
     def_delegators :to_a, :each, :[]
 
     def self.use(schema_defn)
-      schema_defn.trace_with(self::Trace)
+      schema_defn.using_backtrace = true
     end
 
     def initialize(context, value: nil)
@@ -40,20 +37,5 @@ module GraphQL
     def to_a
       @table.to_backtrace
     end
-
-    # Used for internal bookkeeping
-    # @api private
-    class Frame
-      attr_reader :path, :query, :ast_node, :object, :field, :arguments, :parent_frame
-      def initialize(path:, query:, ast_node:, object:, field:, arguments:, parent_frame:)
-        @path = path
-        @query = query
-        @ast_node = ast_node
-        @field = field
-        @object = object
-        @arguments = arguments
-        @parent_frame = parent_frame
-      end
-    end
   end
 end

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

@@ -5,7 +5,10 @@ module GraphQL
     class Interpreter
       class Runtime
         module GraphQLResult
-          def initialize(result_name, result_type, application_value, parent_result, is_non_null_in_parent, selections, is_eager)
+          def initialize(result_name, result_type, application_value, parent_result, is_non_null_in_parent, selections, is_eager, ast_node, graphql_arguments, graphql_field) # rubocop:disable Metrics/ParameterLists
+            @ast_node = ast_node
+            @graphql_arguments = graphql_arguments
+            @graphql_field = graphql_field
             @graphql_parent = parent_result
             @graphql_application_value = application_value
             @graphql_result_type = result_type
@@ -31,14 +34,14 @@ module GraphQL
 
           attr_accessor :graphql_dead
           attr_reader :graphql_parent, :graphql_result_name, :graphql_is_non_null_in_parent,
-            :graphql_application_value, :graphql_result_type, :graphql_selections, :graphql_is_eager
+            :graphql_application_value, :graphql_result_type, :graphql_selections, :graphql_is_eager, :ast_node, :graphql_arguments, :graphql_field
 
           # @return [Hash] Plain-Ruby result data (`@graphql_metadata` contains Result wrapper objects)
           attr_accessor :graphql_result_data
         end
 
         class GraphQLResultHash
-          def initialize(_result_name, _result_type, _application_value, _parent_result, _is_non_null_in_parent, _selections, _is_eager)
+          def initialize(_result_name, _result_type, _application_value, _parent_result, _is_non_null_in_parent, _selections, _is_eager, _ast_node, _graphql_arguments, graphql_field) # rubocop:disable Metrics/ParameterLists
             super
             @graphql_result_data = {}
           end
@@ -126,7 +129,7 @@ module GraphQL
         class GraphQLResultArray
           include GraphQLResult
 
-          def initialize(_result_name, _result_type, _application_value, _parent_result, _is_non_null_in_parent, _selections, _is_eager)
+          def initialize(_result_name, _result_type, _application_value, _parent_result, _is_non_null_in_parent, _selections, _is_eager, _ast_node, _graphql_arguments, graphql_field) # rubocop:disable Metrics/ParameterLists
             super
             @graphql_result_data = []
           end
@@ -168,6 +171,10 @@ module GraphQL
           def values
             (@graphql_metadata || @graphql_result_data)
           end
+
+          def [](idx)
+            (@graphql_metadata || @graphql_result_data)[idx]
+          end
         end
       end
     end

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

@@ -74,7 +74,7 @@ module GraphQL
           runtime_object = root_type.wrap(query.root_value, context)
           runtime_object = schema.sync_lazy(runtime_object)
           is_eager = root_op_type == "mutation"
-          @response = GraphQLResultHash.new(nil, root_type, runtime_object, nil, false, root_operation.selections, is_eager)
+          @response = GraphQLResultHash.new(nil, root_type, runtime_object, nil, false, root_operation.selections, is_eager, root_operation, nil, nil)
           st = get_current_runtime_state
           st.current_result = @response
 
@@ -85,7 +85,7 @@ module GraphQL
             call_method_on_directives(:resolve, runtime_object, root_operation.directives) do # execute query level directives
               each_gathered_selections(@response) do |selections, is_selection_array|
                 if is_selection_array
-                  selection_response = GraphQLResultHash.new(nil, root_type, runtime_object, nil, false, selections, is_eager)
+                  selection_response = GraphQLResultHash.new(nil, root_type, runtime_object, nil, false, selections, is_eager, root_operation, nil, nil)
                   final_response = @response
                 else
                   selection_response = @response
@@ -574,7 +574,7 @@ module GraphQL
             r = begin
               current_type.coerce_result(value, context)
             rescue StandardError => err
-              schema.handle_or_reraise(context, err)
+              query.handle_or_reraise(err)
             end
             set_result(selection_result, result_name, r, false, is_non_null)
             r
@@ -609,11 +609,11 @@ module GraphQL
             after_lazy(object_proxy, ast_node: ast_node, field: field, owner_object: owner_object, arguments: arguments, trace: false, result_name: result_name, result: selection_result, runtime_state: runtime_state) do |inner_object, runtime_state|
               continue_value = continue_value(inner_object, field, is_non_null, ast_node, result_name, selection_result)
               if HALT != continue_value
-                response_hash = GraphQLResultHash.new(result_name, current_type, continue_value, selection_result, is_non_null, next_selections, false)
+                response_hash = GraphQLResultHash.new(result_name, current_type, continue_value, selection_result, is_non_null, next_selections, false, ast_node, arguments, field)
                 set_result(selection_result, result_name, response_hash, true, is_non_null)
                 each_gathered_selections(response_hash) do |selections, is_selection_array|
                   if is_selection_array
-                    this_result = GraphQLResultHash.new(result_name, current_type, continue_value, selection_result, is_non_null, selections, false)
+                    this_result = GraphQLResultHash.new(result_name, current_type, continue_value, selection_result, is_non_null, selections, false, ast_node, arguments, field)
                     final_result = response_hash
                   else
                     this_result = response_hash
@@ -634,35 +634,43 @@ module GraphQL
             # This is true for objects, unions, and interfaces
             use_dataloader_job = !inner_type.unwrap.kind.input?
             inner_type_non_null = inner_type.non_null?
-            response_list = GraphQLResultArray.new(result_name, current_type, owner_object, selection_result, is_non_null, next_selections, false)
+            response_list = GraphQLResultArray.new(result_name, current_type, owner_object, selection_result, is_non_null, next_selections, false, ast_node, arguments, field)
             set_result(selection_result, result_name, response_list, true, is_non_null)
             idx = nil
             list_value = begin
-              value.each do |inner_value|
-                idx ||= 0
-                this_idx = idx
-                idx += 1
-                if use_dataloader_job
-                  @dataloader.append_job do
+              begin
+                value.each do |inner_value|
+                  idx ||= 0
+                  this_idx = idx
+                  idx += 1
+                  if use_dataloader_job
+                    @dataloader.append_job do
+                      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)
+                    end
+                  else
                     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)
                   end
-                else
-                  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)
                 end
-              end
 
-              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)
-                # 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
-                # This was some other NoMethodError -- let it bubble to reveal the real error.
-                raise
+                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)
+                  # 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
+                  # This was some other NoMethodError -- let it bubble to reveal the real error.
+                  raise
+                end
+              rescue GraphQL::ExecutionError, GraphQL::UnauthorizedError => ex_err
+                ex_err
+              rescue StandardError => err
+                begin
+                  query.handle_or_reraise(err)
+                rescue GraphQL::ExecutionError => ex_err
+                  ex_err
+                end
               end
-            rescue GraphQL::ExecutionError, GraphQL::UnauthorizedError => ex_err
-              ex_err
             rescue StandardError => err
               begin
                 query.handle_or_reraise(err)

data/lib/graphql/execution/multiplex.rb

@@ -35,10 +35,6 @@ module GraphQL
         @current_trace = @context[:trace] || schema.new_trace(multiplex: self)
         @dataloader = @context[:dataloader] ||= @schema.dataloader_class.new
         @tracers = schema.tracers + (context[:tracers] || [])
-        # Support `context: {backtrace: true}`
-        if context[:backtrace] && !@tracers.include?(GraphQL::Backtrace::Tracer)
-          @tracers << GraphQL::Backtrace::Tracer
-        end
         @max_complexity = max_complexity
       end
     end

data/lib/graphql/introspection/directive_location_enum.rb

@@ -7,7 +7,7 @@ module GraphQL
                   "a __DirectiveLocation describes one such possible adjacencies."
 
       GraphQL::Schema::Directive::LOCATIONS.each do |location|
-        value(location.to_s, GraphQL::Schema::Directive::LOCATION_DESCRIPTIONS[location], value: location)
+        value(location.to_s, GraphQL::Schema::Directive::LOCATION_DESCRIPTIONS[location], value: location, value_method: false)
       end
       introspection true
     end

data/lib/graphql/query.rb

@@ -127,14 +127,6 @@ module GraphQL
       context_tracers = (context ? context.fetch(:tracers, []) : [])
       @tracers = schema.tracers + context_tracers
 
-      # Support `ctx[:backtrace] = true` for wrapping backtraces
-      if context && context[:backtrace] && !@tracers.include?(GraphQL::Backtrace::Tracer)
-        if schema.trace_class <= GraphQL::Tracing::CallLegacyTracers
-          context_tracers += [GraphQL::Backtrace::Tracer]
-          @tracers << GraphQL::Backtrace::Tracer
-        end
-      end
-
       if !context_tracers.empty? && !(schema.trace_class <= GraphQL::Tracing::CallLegacyTracers)
         raise ArgumentError, "context[:tracers] are not supported without `trace_with(GraphQL::Tracing::CallLegacyTracers)` in the schema configuration, please add it."
       end

data/lib/graphql/schema/build_from_definition.rb

@@ -298,6 +298,7 @@ module GraphQL
                 description: enum_value_definition.description,
                 directives: builder.prepare_directives(enum_value_definition, type_resolver),
                 ast_node: enum_value_definition,
+                value_method: GraphQL::Schema::Enum.respond_to?(enum_value_definition.name.downcase) ? false : nil,
               )
             end
           end

data/lib/graphql/schema/enum.rb

@@ -61,12 +61,17 @@ module GraphQL
         # @option kwargs [String] :description, the GraphQL description for this value, present in documentation
         # @option kwargs [String] :comment, the GraphQL comment for this value, present in documentation
         # @option kwargs [::Object] :value the translated Ruby value for this object (defaults to `graphql_name`)
+        # @option kwargs [::Object] :value_method, the method name to fetch `graphql_name` (defaults to `graphql_name.downcase`)
         # @option kwargs [String] :deprecation_reason if this object is deprecated, include a message here
+        # @param value_method [Symbol, false] A method to generate for this value, or `false` to skip generation
         # @return [void]
         # @see {Schema::EnumValue} which handles these inputs by default
-        def value(*args, **kwargs, &block)
+        def value(*args, value_method: nil, **kwargs, &block)
           kwargs[:owner] = self
           value = enum_value_class.new(*args, **kwargs, &block)
+
+          generate_value_method(value, value_method)
+
           key = value.graphql_name
           prev_value = own_values[key]
           case prev_value
@@ -223,6 +228,21 @@ module GraphQL
         def own_values
           @own_values ||= {}
         end
+
+        def generate_value_method(value, configured_value_method)
+          return if configured_value_method == false
+
+          value_method_name = configured_value_method || value.graphql_name.downcase
+
+          if respond_to?(value_method_name.to_sym)
+            warn "Failed to define value method for :#{value_method_name}, because " \
+              "#{value.owner.name || value.owner.graphql_name} already responds to that method. Use `value_method:` to override the method name " \
+              "or `value_method: false` to disable Enum value method generation."
+            return
+          end
+
+          instance_eval("def #{value_method_name}; #{value.graphql_name.inspect}; end;")
+        end
       end
 
       enum_value_class(GraphQL::Schema::EnumValue)

data/lib/graphql/schema/resolver.rb

@@ -22,6 +22,7 @@ module GraphQL
       include Schema::Member::GraphQLTypeNames
       # Really we only need description & comment from here, but:
       extend Schema::Member::BaseDSLMethods
+      extend Member::BaseDSLMethods::ConfigurationExtension
       extend GraphQL::Schema::Member::HasArguments
       extend GraphQL::Schema::Member::HasValidators
       include Schema::Member::HasPath

data/lib/graphql/schema/validator/required_validator.rb

@@ -51,19 +51,36 @@ module GraphQL
         end
 
         def validate(_object, context, value)
-          matched_conditions = 0
+          fully_matched_conditions = 0
+          partially_matched_conditions = 0
 
           if !value.nil?
             @one_of.each do |one_of_condition|
               case one_of_condition
               when Symbol
                 if value.key?(one_of_condition)
-                  matched_conditions += 1
+                  fully_matched_conditions += 1
                 end
               when Array
-                if one_of_condition.all? { |k| value.key?(k) }
-                  matched_conditions += 1
-                  break
+                any_match = false
+                full_match = true
+
+                one_of_condition.each do |k|
+                  if value.key?(k)
+                    any_match = true
+                  else
+                    full_match = false
+                  end
+                end
+
+                partial_match = !full_match && any_match
+
+                if full_match
+                  fully_matched_conditions += 1
+                end
+
+                if partial_match
+                  partially_matched_conditions += 1
                 end
               else
                 raise ArgumentError, "Unknown one_of condition: #{one_of_condition.inspect}"
@@ -71,7 +88,7 @@ module GraphQL
             end
           end
 
-          if matched_conditions == 1
+          if fully_matched_conditions == 1 && partially_matched_conditions == 0
             nil # OK
           else
             @message || build_message(context)

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

@@ -159,7 +159,7 @@ module GraphQL
                 end
               end
             end
-            visible_f.ensure_loaded
+            visible_f&.ensure_loaded
           elsif f && @cached_visible_fields[owner][f.ensure_loaded]
             f
           else

data/lib/graphql/schema.rb

@@ -167,9 +167,6 @@ module GraphQL
           mods.each { |mod| new_class.include(mod) }
           new_class.include(DefaultTraceClass)
           trace_mode(:default, new_class)
-          backtrace_class = Class.new(new_class)
-          backtrace_class.include(GraphQL::Backtrace::Trace)
-          trace_mode(:default_backtrace, backtrace_class)
         end
         trace_class_for(:default, build: true)
       end
@@ -216,11 +213,6 @@ module GraphQL
           const_set(:DefaultTrace, Class.new(base_class) do
             include DefaultTraceClass
           end)
-        when :default_backtrace
-          schema_base_class = trace_class_for(:default, build: true)
-          const_set(:DefaultTraceBacktrace, Class.new(schema_base_class) do
-            include(GraphQL::Backtrace::Trace)
-          end)
         else
           # First, see if the superclass has a custom-defined class for this.
           # Then, if it doesn't, use this class's default trace
@@ -1118,8 +1110,14 @@ module GraphQL
         }
       end
 
+      # @api private
+      attr_accessor :using_backtrace
+
       # @api private
       def handle_or_reraise(context, err)
+        if context[:backtrace] || using_backtrace
+          err = GraphQL::Backtrace::TracedError.new(err, context)
+        end
         handler = Execution::Errors.find_handler_for(self, err.class)
         if handler
           obj = context[:current_object]
@@ -1449,22 +1447,8 @@ module GraphQL
         target = options[:query] || options[:multiplex]
         mode ||= target && target.context[:trace_mode]
 
-        trace_mode = if mode
-          mode
-        elsif target && target.context[:backtrace]
-          if default_trace_mode != :default
-            raise ArgumentError, "Can't use `context[:backtrace]` with a custom default trace mode (`#{dm.inspect}`)"
-          else
-            own_trace_modes[:default_backtrace] ||= build_trace_mode(:default_backtrace)
-            options_trace_mode = :default
-            :default_backtrace
-          end
-        else
-          default_trace_mode
-        end
-
-        options_trace_mode ||= trace_mode
-        base_trace_options = trace_options_for(options_trace_mode)
+        trace_mode = mode || default_trace_mode
+        base_trace_options = trace_options_for(trace_mode)
         trace_options = base_trace_options.merge(options)
         trace_class_for_mode = trace_class_for(trace_mode, build: true)
         trace_class_for_mode.new(**trace_options)

data/lib/graphql/subscriptions/serialize.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 require "set"
-require "ostruct"
-
 module GraphQL
   class Subscriptions
     # Serialization helpers for passing subscription data around.
@@ -148,7 +146,7 @@ module GraphQL
           elsif obj.is_a?(Date) || obj.is_a?(Time)
             # DateTime extends Date; for TimeWithZone, call `.utc` first.
             { TIMESTAMP_KEY => [obj.class.name, obj.strftime(TIMESTAMP_FORMAT)] }
-          elsif obj.is_a?(OpenStruct)
+          elsif defined?(OpenStruct) && obj.is_a?(OpenStruct)
             { OPEN_STRUCT_KEY => dump_value(obj.to_h) }
           elsif defined?(ActiveRecord::Relation) && obj.is_a?(ActiveRecord::Relation)
             dump_value(obj.to_a)

data/lib/graphql/tracing/trace.rb

@@ -8,7 +8,7 @@ module GraphQL
     # "Trace modes" are subclasses of this with custom tracing modules mixed in.
     #
     # A trace module may implement any of the methods on `Trace`, being sure to call `super`
-    # to continue any tracing hooks and call the actual runtime behavior. See {GraphQL::Backtrace::Trace} for example.
+    # to continue any tracing hooks and call the actual runtime behavior.
     #
     class Trace
       # @param multiplex [GraphQL::Execution::Multiplex, nil]

data/lib/graphql/version.rb

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

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.4.8
+  version: 2.4.9
 platform: ruby
 authors:
 - Robert Mosolgo
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-12-10 00:00:00.000000000 Z
+date: 2025-01-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -38,6 +37,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: logger
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: benchmark-ips
   requirement: !ruby/object:Gem::Requirement
@@ -178,6 +191,76 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  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: simplecov-lcov
+  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: undercover
+  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: pronto
+  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: pronto-undercover
+  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
   requirement: !ruby/object:Gem::Requirement
@@ -248,6 +331,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 1.5.0
+- !ruby/object:Gem::Dependency
+  name: mutex_m
+  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: webrick
   requirement: !ruby/object:Gem::Requirement
@@ -330,11 +427,8 @@ files:
 - lib/graphql/analysis_error.rb
 - lib/graphql/autoload.rb
 - lib/graphql/backtrace.rb
-- lib/graphql/backtrace/inspect_result.rb
 - lib/graphql/backtrace/table.rb
-- lib/graphql/backtrace/trace.rb
 - lib/graphql/backtrace/traced_error.rb
-- lib/graphql/backtrace/tracer.rb
 - lib/graphql/coercion_error.rb
 - lib/graphql/current.rb
 - lib/graphql/dataloader.rb
@@ -654,7 +748,6 @@ metadata:
   bug_tracker_uri: https://github.com/rmosolgo/graphql-ruby/issues
   mailing_list_uri: https://buttondown.email/graphql-ruby
   rubygems_mfa_required: 'true'
-post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -669,8 +762,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.12
-signing_key:
+rubygems_version: 3.6.3
 specification_version: 4
 summary: A GraphQL language and runtime for Ruby
 test_files: []

data/lib/graphql/backtrace/inspect_result.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  class Backtrace
-    module InspectResult
-      module_function
-
-      def inspect_result(obj)
-        case obj
-        when Hash
-          "{" +
-            obj.map do |key, val|
-              "#{key}: #{inspect_truncated(val)}"
-            end.join(", ") +
-            "}"
-        when Array
-          "[" +
-            obj.map { |v| inspect_truncated(v) }.join(", ") +
-            "]"
-        else
-          inspect_truncated(obj)
-        end
-      end
-
-      def inspect_truncated(obj)
-        case obj
-        when Hash
-          "{...}"
-        when Array
-          "[...]"
-        when GraphQL::Execution::Lazy
-          "(unresolved)"
-        else
-          "#{obj.inspect}"
-        end
-      end
-    end
-  end
-end

data/lib/graphql/backtrace/trace.rb

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  class Backtrace
-    module Trace
-      def initialize(*args, **kwargs, &block)
-        @__backtrace_contexts = {}
-        @__backtrace_last_context = nil
-        super
-      end
-
-      def validate(query:, validate:)
-        if query.multiplex
-          push_query_backtrace_context(query)
-        end
-        super
-      end
-
-      def analyze_query(query:)
-        if query.multiplex # missing for stand-alone static validation
-          push_query_backtrace_context(query)
-        end
-        super
-      end
-
-      def execute_query(query:)
-        push_query_backtrace_context(query)
-        super
-      end
-
-      def execute_query_lazy(query:, multiplex:)
-        query ||= multiplex.queries.first
-        push_query_backtrace_context(query)
-        super
-      end
-
-      def execute_field(field:, query:, ast_node:, arguments:, object:)
-        push_field_backtrace_context(field, query, ast_node, arguments, object)
-        super
-      end
-
-      def execute_field_lazy(field:, query:, ast_node:, arguments:, object:)
-        push_field_backtrace_context(field, query, ast_node, arguments, object)
-        super
-      end
-
-      def execute_multiplex(multiplex:)
-        super
-      rescue StandardError => err
-        # This is an unhandled error from execution,
-        # Re-raise it with a GraphQL trace.
-        potential_context = @__backtrace_last_context
-        if potential_context.is_a?(GraphQL::Query::Context) ||
-            potential_context.is_a?(Backtrace::Frame)
-          raise TracedError.new(err, potential_context)
-        else
-          raise
-        end
-      end
-
-      private
-
-      def push_query_backtrace_context(query)
-        push_data = query
-        push_key = []
-        @__backtrace_contexts[push_key] = push_data
-        @__backtrace_last_context = push_data
-      end
-
-      def push_field_backtrace_context(field, query, ast_node, arguments, object)
-        push_key = query.context[:current_path]
-        push_storage = @__backtrace_contexts
-        parent_frame = push_storage[push_key[0..-2]]
-
-        if parent_frame.is_a?(GraphQL::Query)
-          parent_frame = parent_frame.context
-        end
-
-        push_data = Frame.new(
-          query: query,
-          path: push_key,
-          ast_node: ast_node,
-          field: field,
-          object: object,
-          arguments: arguments,
-          parent_frame: parent_frame,
-        )
-        push_storage[push_key] = push_data
-        @__backtrace_last_context = push_data
-      end
-
-    end
-  end
-end

data/lib/graphql/backtrace/tracer.rb

@@ -1,80 +0,0 @@
-# frozen_string_literal: true
-module GraphQL
-  class Backtrace
-    # TODO this is not fiber-friendly
-    module Tracer
-      module_function
-
-      # Implement the {GraphQL::Tracing} API.
-      def trace(key, metadata)
-        case key
-        when "lex", "parse"
-          # No context here, don't have a query yet
-          nil
-        when "execute_multiplex", "analyze_multiplex"
-          # No query context yet
-          nil
-        when "validate", "analyze_query", "execute_query", "execute_query_lazy"
-          push_key = []
-          if (query = metadata[:query]) || ((queries = metadata[:queries]) && (query = queries.first))
-            push_data = query
-            multiplex = query.multiplex
-          elsif (multiplex = metadata[:multiplex])
-            push_data = multiplex.queries.first
-          end
-        when "execute_field", "execute_field_lazy"
-          query = metadata[:query]
-          multiplex = query.multiplex
-          push_key = query.context[:current_path]
-          parent_frame = multiplex.context[:graphql_backtrace_contexts][push_key[0..-2]]
-
-          if parent_frame.is_a?(GraphQL::Query)
-            parent_frame = parent_frame.context
-          end
-
-          push_data = Frame.new(
-            query: query,
-            path: push_key,
-            ast_node: metadata[:ast_node],
-            field: metadata[:field],
-            object: metadata[:object],
-            arguments: metadata[:arguments],
-            parent_frame: parent_frame,
-          )
-        else
-          # Custom key, no backtrace data for this
-          nil
-        end
-
-        if push_data && multiplex
-          push_storage = multiplex.context[:graphql_backtrace_contexts] ||= {}
-          push_storage[push_key] = push_data
-          multiplex.context[:last_graphql_backtrace_context] = push_data
-        end
-
-        if key == "execute_multiplex"
-          multiplex_context = metadata[:multiplex].context
-          begin
-            yield
-          rescue StandardError => err
-            # This is an unhandled error from execution,
-            # Re-raise it with a GraphQL trace.
-            potential_context = multiplex_context[:last_graphql_backtrace_context]
-
-            if potential_context.is_a?(GraphQL::Query::Context) ||
-                potential_context.is_a?(Backtrace::Frame)
-              raise TracedError.new(err, potential_context)
-            else
-              raise
-            end
-          ensure
-            multiplex_context.delete(:graphql_backtrace_contexts)
-            multiplex_context.delete(:last_graphql_backtrace_context)
-          end
-        else
-          yield
-        end
-      end
-    end
-  end
-end