graphql 2.4.11 → 2.4.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ba5296cae016dea52b006bebe1515d6eef54876ec9f6437f5414bfccd7d8cf40
-  data.tar.gz: 75bf06fbb277d4e9c400f57998e0de5d2a6e4a41d562c71b0969fc30fe2bbb64
+  metadata.gz: 35661aff446f955116332f131cd6323839e0b5f0ea104512a8257a28d3232e43
+  data.tar.gz: 023eb7cff94490520342572da1b7dc2b017dfa99daa5c9d18503b51de7dccc66
 SHA512:
-  metadata.gz: e05120bb3377cbda64651ef2128b97daedf1b58e5e4a36b90d01d8ba4435a26e0dce6e270dfbc22ae75d29abcbe4d6f50c853ad6e13225a71eafeadbaad05519
-  data.tar.gz: 2caa24da0288b0efab47b94a441351f8bbd0d1d3cb8bac1c834102fedb2ea350787fb74e2fe1d502971b181308f2b17b1e5b5273a2bf2a868d4917b29fc27f9b
+  metadata.gz: 29645fc0f923d6e268888c43fbd703189160ac8be5ea8d0fc9a17683d7336c43b20cfcdfd1cafd90291840c59e2d06d3eb8b27b66bb41e26beea0f4388e7a839
+  data.tar.gz: 63f1a5c91cbd08948ffc96bcb0d581a3959c2d0f13be19402200d1e0209187ab70d6f8c27e2b6a62ac93a27a945792d93ecf03bb6f53b37778eb88c3570e2553

data/lib/graphql/analysis/analyzer.rb

@@ -42,6 +42,7 @@ module GraphQL
         raise GraphQL::RequiredImplementationMissingError
       end
 
+      # rubocop:disable Development/NoEvalCop This eval takes static inputs at load-time
       class << self
         private
 
@@ -72,7 +73,7 @@ module GraphQL
       build_visitor_hooks :variable_definition
       build_visitor_hooks :variable_identifier
       build_visitor_hooks :abstract_node
-
+      # rubocop:enable Development/NoEvalCop
       protected
 
       # @return [GraphQL::Query, GraphQL::Execution::Multiplex] Whatever this analyzer is analyzing

data/lib/graphql/analysis/visitor.rb

@@ -10,7 +10,7 @@ module GraphQL
     #
     # @see {GraphQL::Analysis::Analyzer} AST Analyzers for queries
     class Visitor < GraphQL::Language::StaticVisitor
-      def initialize(query:, analyzers:)
+      def initialize(query:, analyzers:, timeout:)
         @analyzers = analyzers
         @path = []
         @object_types = []
@@ -24,6 +24,11 @@ module GraphQL
         @types = query.types
         @response_path = []
         @skip_stack = [false]
+        @timeout_time = if timeout
+          Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_second) + timeout
+        else
+          Float::INFINITY
+        end
         super(query.selected_operation)
       end
 
@@ -64,6 +69,7 @@ module GraphQL
         @response_path.dup
       end
 
+      # rubocop:disable Development/NoEvalCop This eval takes static inputs at load-time
       # Visitor Hooks
       [
         :operation_definition, :fragment_definition,
@@ -72,28 +78,26 @@ module GraphQL
         module_eval <<-RUBY, __FILE__, __LINE__
         def call_on_enter_#{node_type}(node, parent)
           @analyzers.each do |a|
-            begin
-              a.on_enter_#{node_type}(node, parent, self)
-            rescue AnalysisError => err
-              @rescued_errors << err
-            end
+            a.on_enter_#{node_type}(node, parent, self)
+          rescue AnalysisError => err
+            @rescued_errors << err
           end
         end
 
         def call_on_leave_#{node_type}(node, parent)
           @analyzers.each do |a|
-            begin
-              a.on_leave_#{node_type}(node, parent, self)
-            rescue AnalysisError => err
-              @rescued_errors << err
-            end
+            a.on_leave_#{node_type}(node, parent, self)
+          rescue AnalysisError => err
+            @rescued_errors << err
           end
         end
 
         RUBY
       end
+      # rubocop:enable Development/NoEvalCop
 
       def on_operation_definition(node, parent)
+        check_timeout
         object_type = @schema.root_type_for_operation(node.operation_type)
         @object_types.push(object_type)
         @path.push("#{node.operation_type}#{node.name ? " #{node.name}" : ""}")
@@ -104,31 +108,27 @@ module GraphQL
         @path.pop
       end
 
-      def on_fragment_definition(node, parent)
-        on_fragment_with_type(node) do
-          @path.push("fragment #{node.name}")
-          @in_fragment_def = false
-          call_on_enter_fragment_definition(node, parent)
-          super
-          @in_fragment_def = false
-          call_on_leave_fragment_definition(node, parent)
-        end
-      end
-
       def on_inline_fragment(node, parent)
-        on_fragment_with_type(node) do
-          @path.push("...#{node.type ? " on #{node.type.name}" : ""}")
-          @skipping = @skip_stack.last || skip?(node)
-          @skip_stack << @skipping
-
-          call_on_enter_inline_fragment(node, parent)
-          super
-          @skipping = @skip_stack.pop
-          call_on_leave_inline_fragment(node, parent)
+        check_timeout
+        object_type = if node.type
+          @types.type(node.type.name)
+        else
+          @object_types.last
         end
+        @object_types.push(object_type)
+        @path.push("...#{node.type ? " on #{node.type.name}" : ""}")
+        @skipping = @skip_stack.last || skip?(node)
+        @skip_stack << @skipping
+        call_on_enter_inline_fragment(node, parent)
+        super
+        @skipping = @skip_stack.pop
+        call_on_leave_inline_fragment(node, parent)
+        @object_types.pop
+        @path.pop
       end
 
       def on_field(node, parent)
+        check_timeout
         @response_path.push(node.alias || node.name)
         parent_type = @object_types.last
         # This could be nil if the previous field wasn't found:
@@ -156,6 +156,7 @@ module GraphQL
       end
 
       def on_directive(node, parent)
+        check_timeout
         directive_defn = @schema.directives[node.name]
         @directive_definitions.push(directive_defn)
         call_on_enter_directive(node, parent)
@@ -165,6 +166,7 @@ module GraphQL
       end
 
       def on_argument(node, parent)
+        check_timeout
         argument_defn = if (arg = @argument_definitions.last)
           arg_type = arg.type.unwrap
           if arg_type.kind.input_object?
@@ -190,6 +192,7 @@ module GraphQL
       end
 
       def on_fragment_spread(node, parent)
+        check_timeout
         @path.push("... #{node.name}")
         @skipping = @skip_stack.last || skip?(node)
         @skip_stack << @skipping
@@ -267,16 +270,10 @@ module GraphQL
         !dir.empty? && !GraphQL::Execution::DirectiveChecks.include?(dir, query)
       end
 
-      def on_fragment_with_type(node)
-        object_type = if node.type
-          @types.type(node.type.name)
-        else
-          @object_types.last
+      def check_timeout
+        if Process.clock_gettime(Process::CLOCK_MONOTONIC, :float_second) > @timeout_time
+          raise GraphQL::Analysis::TimeoutError
         end
-        @object_types.push(object_type)
-        yield(node)
-        @object_types.pop
-        @path.pop
       end
     end
   end

data/lib/graphql/analysis.rb

@@ -6,11 +6,16 @@ require "graphql/analysis/query_complexity"
 require "graphql/analysis/max_query_complexity"
 require "graphql/analysis/query_depth"
 require "graphql/analysis/max_query_depth"
-require "timeout"
-
 module GraphQL
   module Analysis
     AST = self
+
+    class TimeoutError < AnalysisError
+      def initialize(...)
+        super("Timeout on validation of query")
+      end
+    end
+
     module_function
     # Analyze a multiplex, and all queries within.
     # Multiplex analyzers are ran for all queries, keeping state.
@@ -61,13 +66,11 @@ module GraphQL
           if !analyzers_to_run.empty?
             visitor = GraphQL::Analysis::Visitor.new(
               query: query,
-              analyzers: analyzers_to_run
+              analyzers: analyzers_to_run,
+              timeout: query.validate_timeout_remaining,
             )
 
-            # `nil` or `0` causes no timeout
-            Timeout::timeout(query.validate_timeout_remaining) do
-              visitor.visit
-            end
+            visitor.visit
 
             if !visitor.rescued_errors.empty?
               return visitor.rescued_errors
@@ -79,8 +82,8 @@ module GraphQL
           []
         end
       end
-    rescue Timeout::Error
-      [GraphQL::AnalysisError.new("Timeout on validation of query")]
+    rescue TimeoutError => err
+      [err]
     rescue GraphQL::UnauthorizedError, GraphQL::ExecutionError
       # This error was raised during analysis and will be returned the client before execution
       []

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

@@ -473,7 +473,7 @@ module GraphQL
                 # When this comes from a list item, use the parent object:
                 parent_type = selection_result.is_a?(GraphQLResultArray) ? selection_result.graphql_parent.graphql_result_type : selection_result.graphql_result_type
                 # This block is called if `result_name` is not dead. (Maybe a previous invalid nil caused it be marked dead.)
-                err = parent_type::InvalidNullError.new(parent_type, field, value, ast_node)
+                err = parent_type::InvalidNullError.new(parent_type, field, ast_node)
                 schema.type_error(err, context)
               end
             else

data/lib/graphql/invalid_null_error.rb

@@ -9,16 +9,12 @@ module GraphQL
     # @return [GraphQL::Field] The field which failed to return a value
     attr_reader :field
 
-    # @return [nil, GraphQL::ExecutionError] The invalid value for this field
-    attr_reader :value
-
     # @return [GraphQL::Language::Nodes::Field] the field where the error occurred
     attr_reader :ast_node
 
-    def initialize(parent_type, field, value, ast_node)
+    def initialize(parent_type, field, ast_node)
       @parent_type = parent_type
       @field = field
-      @value = value
       @ast_node = ast_node
       super("Cannot return null for non-nullable field #{@parent_type.graphql_name}.#{@field.graphql_name}")
     end

data/lib/graphql/language/lexer.rb

@@ -13,17 +13,21 @@ module GraphQL
         @pos = nil
         @max_tokens = max_tokens || Float::INFINITY
         @tokens_count = 0
+        @finished = false
       end
 
-      def eos?
-        @scanner.eos?
+      def finished?
+        @finished
       end
 
       attr_reader :pos, :tokens_count
 
       def advance
         @scanner.skip(IGNORE_REGEXP)
-        return false if @scanner.eos?
+        if @scanner.eos?
+          @finished = true
+          return false
+        end
         @tokens_count += 1
         if @tokens_count > @max_tokens
           raise_parse_error("This query is too large to execute.")

data/lib/graphql/language/nodes.rb

@@ -141,6 +141,8 @@ module GraphQL
         end
 
         class << self
+          # rubocop:disable Development/NoEvalCop This eval takes static inputs at load-time
+
           # Add a default `#visit_method` and `#children_method_name` using the class name
           def inherited(child_class)
             super
@@ -343,6 +345,7 @@ module GraphQL
               RUBY
             end
           end
+          # rubocop:enable Development/NoEvalCop
         end
       end
 

data/lib/graphql/language/parser.rb

@@ -110,7 +110,7 @@ module GraphQL
           # Only ignored characters is not a valid document
           raise GraphQL::ParseError.new("Unexpected end of document", nil, nil, @graphql_str)
         end
-        while !@lexer.eos?
+        while !@lexer.finished?
           defns << definition
         end
         Document.new(pos: 0, definitions: defns, filename: @filename, source: self)

data/lib/graphql/language/static_visitor.rb

@@ -22,39 +22,6 @@ module GraphQL
         end
       end
 
-      # We don't use `alias` here because it breaks `super`
-      def self.make_visit_methods(ast_node_class)
-        node_method = ast_node_class.visit_method
-        children_of_type = ast_node_class.children_of_type
-        child_visit_method = :"#{node_method}_children"
-
-        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-          # The default implementation for visiting an AST node.
-          # It doesn't _do_ anything, but it continues to visiting the node's children.
-          # To customize this hook, override one of its make_visit_methods (or the base method?)
-          # in your subclasses.
-          #
-          # @param node [GraphQL::Language::Nodes::AbstractNode] the node being visited
-          # @param parent [GraphQL::Language::Nodes::AbstractNode, nil] the previously-visited node, or `nil` if this is the root node.
-          # @return [void]
-          def #{node_method}(node, parent)
-            #{
-              if method_defined?(child_visit_method)
-                "#{child_visit_method}(node)"
-              elsif children_of_type
-                children_of_type.map do |child_accessor, child_class|
-                  "node.#{child_accessor}.each do |child_node|
-                    #{child_class.visit_method}(child_node, node)
-                  end"
-                end.join("\n")
-              else
-                ""
-              end
-            }
-          end
-        RUBY
-      end
-
       def on_document_children(document_node)
         document_node.children.each do |child_node|
           visit_method = child_node.visit_method
@@ -123,6 +90,41 @@ module GraphQL
         end
       end
 
+      # rubocop:disable Development/NoEvalCop This eval takes static inputs at load-time
+
+      # We don't use `alias` here because it breaks `super`
+      def self.make_visit_methods(ast_node_class)
+        node_method = ast_node_class.visit_method
+        children_of_type = ast_node_class.children_of_type
+        child_visit_method = :"#{node_method}_children"
+
+        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+          # The default implementation for visiting an AST node.
+          # It doesn't _do_ anything, but it continues to visiting the node's children.
+          # To customize this hook, override one of its make_visit_methods (or the base method?)
+          # in your subclasses.
+          #
+          # @param node [GraphQL::Language::Nodes::AbstractNode] the node being visited
+          # @param parent [GraphQL::Language::Nodes::AbstractNode, nil] the previously-visited node, or `nil` if this is the root node.
+          # @return [void]
+          def #{node_method}(node, parent)
+            #{
+              if method_defined?(child_visit_method)
+                "#{child_visit_method}(node)"
+              elsif children_of_type
+                children_of_type.map do |child_accessor, child_class|
+                  "node.#{child_accessor}.each do |child_node|
+                    #{child_class.visit_method}(child_node, node)
+                  end"
+                end.join("\n")
+              else
+                ""
+              end
+            }
+          end
+        RUBY
+      end
+
       [
         Language::Nodes::Argument,
         Language::Nodes::Directive,
@@ -162,6 +164,8 @@ module GraphQL
       ].each do |ast_node_class|
         make_visit_methods(ast_node_class)
       end
+
+      # rubocop:disable Development/NoEvalCop
     end
   end
 end

data/lib/graphql/language/visitor.rb

@@ -61,61 +61,6 @@ module GraphQL
         end
       end
 
-      # We don't use `alias` here because it breaks `super`
-      def self.make_visit_methods(ast_node_class)
-        node_method = ast_node_class.visit_method
-        children_of_type = ast_node_class.children_of_type
-        child_visit_method = :"#{node_method}_children"
-
-        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
-          # The default implementation for visiting an AST node.
-          # It doesn't _do_ anything, but it continues to visiting the node's children.
-          # To customize this hook, override one of its make_visit_methods (or the base method?)
-          # in your subclasses.
-          #
-          # @param node [GraphQL::Language::Nodes::AbstractNode] the node being visited
-          # @param parent [GraphQL::Language::Nodes::AbstractNode, nil] the previously-visited node, or `nil` if this is the root node.
-          # @return [Array, nil] If there were modifications, it returns an array of new nodes, otherwise, it returns `nil`.
-          def #{node_method}(node, parent)
-            if node.equal?(DELETE_NODE)
-              # This might be passed to `super(DELETE_NODE, ...)`
-              # by a user hook, don't want to keep visiting in that case.
-              [node, parent]
-            else
-              new_node = node
-              #{
-                if method_defined?(child_visit_method)
-                  "new_node = #{child_visit_method}(new_node)"
-                elsif children_of_type
-                  children_of_type.map do |child_accessor, child_class|
-                    "node.#{child_accessor}.each do |child_node|
-                      new_child_and_node = #{child_class.visit_method}_with_modifications(child_node, new_node)
-                      # Reassign `node` in case the child hook makes a modification
-                      if new_child_and_node.is_a?(Array)
-                        new_node = new_child_and_node[1]
-                      end
-                    end"
-                  end.join("\n")
-                else
-                  ""
-                end
-              }
-
-              if new_node.equal?(node)
-                [node, parent]
-              else
-                [new_node, parent]
-              end
-            end
-          end
-
-          def #{node_method}_with_modifications(node, parent)
-            new_node_and_new_parent = #{node_method}(node, parent)
-            apply_modifications(node, parent, new_node_and_new_parent)
-          end
-        RUBY
-      end
-
       def on_document_children(document_node)
         new_node = document_node
         document_node.children.each do |child_node|
@@ -216,6 +161,63 @@ module GraphQL
         new_node
       end
 
+      # rubocop:disable Development/NoEvalCop This eval takes static inputs at load-time
+
+      # We don't use `alias` here because it breaks `super`
+      def self.make_visit_methods(ast_node_class)
+        node_method = ast_node_class.visit_method
+        children_of_type = ast_node_class.children_of_type
+        child_visit_method = :"#{node_method}_children"
+
+        class_eval(<<-RUBY, __FILE__, __LINE__ + 1)
+          # The default implementation for visiting an AST node.
+          # It doesn't _do_ anything, but it continues to visiting the node's children.
+          # To customize this hook, override one of its make_visit_methods (or the base method?)
+          # in your subclasses.
+          #
+          # @param node [GraphQL::Language::Nodes::AbstractNode] the node being visited
+          # @param parent [GraphQL::Language::Nodes::AbstractNode, nil] the previously-visited node, or `nil` if this is the root node.
+          # @return [Array, nil] If there were modifications, it returns an array of new nodes, otherwise, it returns `nil`.
+          def #{node_method}(node, parent)
+            if node.equal?(DELETE_NODE)
+              # This might be passed to `super(DELETE_NODE, ...)`
+              # by a user hook, don't want to keep visiting in that case.
+              [node, parent]
+            else
+              new_node = node
+              #{
+                if method_defined?(child_visit_method)
+                  "new_node = #{child_visit_method}(new_node)"
+                elsif children_of_type
+                  children_of_type.map do |child_accessor, child_class|
+                    "node.#{child_accessor}.each do |child_node|
+                      new_child_and_node = #{child_class.visit_method}_with_modifications(child_node, new_node)
+                      # Reassign `node` in case the child hook makes a modification
+                      if new_child_and_node.is_a?(Array)
+                        new_node = new_child_and_node[1]
+                      end
+                    end"
+                  end.join("\n")
+                else
+                  ""
+                end
+              }
+
+              if new_node.equal?(node)
+                [node, parent]
+              else
+                [new_node, parent]
+              end
+            end
+          end
+
+          def #{node_method}_with_modifications(node, parent)
+            new_node_and_new_parent = #{node_method}(node, parent)
+            apply_modifications(node, parent, new_node_and_new_parent)
+          end
+        RUBY
+      end
+
       [
         Language::Nodes::Argument,
         Language::Nodes::Directive,
@@ -256,6 +258,8 @@ module GraphQL
         make_visit_methods(ast_node_class)
       end
 
+      # rubocop:enable Development/NoEvalCop
+
       private
 
       def apply_modifications(node, parent, new_node_and_new_parent)

data/lib/graphql/schema/argument.rb

@@ -53,6 +53,7 @@ module GraphQL
       def initialize(arg_name = nil, type_expr = nil, desc = nil, required: true, type: nil, name: nil, loads: nil, description: nil, comment: nil, ast_node: nil, default_value: NOT_CONFIGURED, as: nil, from_resolver: false, camelize: true, prepare: nil, owner:, validates: nil, directives: nil, deprecation_reason: nil, replace_null_with_default: false, &definition_block)
         arg_name ||= name
         @name = -(camelize ? Member::BuildType.camelize(arg_name.to_s) : arg_name.to_s)
+        NameValidator.validate!(@name)
         @type_expr = type_expr || type
         @description = desc || description
         @comment = comment
@@ -89,11 +90,8 @@ module GraphQL
         end
 
         if definition_block
-          if definition_block.arity == 1
-            instance_exec(self, &definition_block)
-          else
-            instance_eval(&definition_block)
-          end
+          # `self` will still be self, it will also be the first argument to the block:
+          instance_exec(self, &definition_block)
         end
       end
 

data/lib/graphql/schema/build_from_definition.rb

@@ -467,17 +467,18 @@ module GraphQL
 
             # Don't do this for interfaces
             if default_resolve
-              owner.class_eval <<-RUBY, __FILE__, __LINE__
-                # frozen_string_literal: true
-                def #{resolve_method_name}(**args)
-                  field_instance = self.class.get_field("#{field_definition.name}")
-                  context.schema.definition_default_resolve.call(self.class, field_instance, object, args, context)
-                end
-              RUBY
+              define_field_resolve_method(owner, resolve_method_name, field_definition.name)
             end
           end
         end
 
+        def define_field_resolve_method(owner, method_name, field_name)
+          owner.define_method(method_name) { |**args|
+            field_instance = self.class.get_field(field_name)
+            context.schema.definition_default_resolve.call(self.class, field_instance, object, args, context)
+          }
+        end
+
         def build_resolve_type(lookup_hash, directives, missing_type_handler)
           resolve_type_proc = nil
           resolve_type_proc = ->(ast_node) {

data/lib/graphql/schema/directive.rb

@@ -99,7 +99,7 @@ module GraphQL
 
         def inherited(subclass)
           super
-          subclass.class_eval do
+          subclass.class_exec do
             @default_graphql_name ||= nil
           end
         end

data/lib/graphql/schema/enum.rb

@@ -234,7 +234,7 @@ module GraphQL
             # because they would end up with names like `#<Class0x1234>::UnresolvedValueError` which messes up bug trackers
             child_class.const_set(:UnresolvedValueError, Class.new(Schema::Enum::UnresolvedValueError))
           end
-          child_class.class_eval { @value_methods = nil }
+          child_class.class_exec { @value_methods = nil }
           super
         end
 
@@ -256,7 +256,7 @@ module GraphQL
             return
           end
 
-          instance_eval("def #{value_method_name}; #{value.graphql_name.inspect}; end;", __FILE__, __LINE__)
+          define_singleton_method(value_method_name) { value.graphql_name }
         end
       end
 

data/lib/graphql/schema/enum_value.rb

@@ -48,7 +48,7 @@ module GraphQL
         end
 
         if block_given?
-          instance_eval(&block)
+          instance_exec(self, &block)
         end
       end
 

data/lib/graphql/schema/field.rb

@@ -255,7 +255,7 @@ module GraphQL
 
         @underscored_name = -Member::BuildType.underscore(name_s)
         @name = -(camelize ? Member::BuildType.camelize(name_s) : name_s)
-
+        NameValidator.validate!(@name)
         @description = description
         @comment = comment
         @type = @owner_type = @own_validators = @own_directives = @own_arguments = @arguments_statically_coercible = nil # these will be prepared later if necessary
@@ -369,7 +369,7 @@ module GraphQL
           if @definition_block.arity == 1
             @definition_block.call(self)
           else
-            instance_eval(&@definition_block)
+            instance_exec(self, &@definition_block)
           end
           self.extensions.each(&:after_define_apply)
           @call_after_define = true

data/lib/graphql/schema/input_object.rb

@@ -59,7 +59,7 @@ module GraphQL
         else
           new_h = {}
           keys.each { |k| @ruby_style_hash.key?(k) && new_h[k] = @ruby_style_hash[k] }
-          new_h 
+          new_h
         end
       end
 
@@ -150,14 +150,8 @@ module GraphQL
             end
           end
           # Add a method access
-          method_name = argument_defn.keyword
           suppress_redefinition_warning do
-            class_eval <<-RUBY, __FILE__, __LINE__
-              def #{method_name}
-                self[#{method_name.inspect}]
-              end
-              alias_method #{method_name.inspect}, #{method_name.inspect}
-            RUBY
+            define_accessor_method(argument_defn.keyword)
           end
           argument_defn
         end
@@ -293,6 +287,11 @@ module GraphQL
         ensure
           $VERBOSE = verbose
         end
+
+        def define_accessor_method(method_name)
+          define_method(method_name) { self[method_name] }
+          alias_method(method_name, method_name)
+        end
       end
 
       private

data/lib/graphql/schema/interface.rb

@@ -30,7 +30,7 @@ module GraphQL
             const_set(:DefinitionMethods, defn_methods_module)
             extend(self::DefinitionMethods)
           end
-          self::DefinitionMethods.module_eval(&block)
+          self::DefinitionMethods.module_exec(&block)
         end
 
         # @see {Schema::Warden} hides interfaces without visible implementations

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

@@ -6,7 +6,7 @@ module GraphQL
       module HasDirectives
         def self.extended(child_cls)
           super
-          child_cls.module_eval { self.own_directives = nil }
+          child_cls.module_exec { self.own_directives = nil }
         end
 
         def inherited(child_cls)

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

@@ -202,7 +202,7 @@ module GraphQL
 
         def inherited(subclass)
           super
-          subclass.class_eval do
+          subclass.class_exec do
             @own_fields ||= nil
             @field_class ||= nil
             @has_no_fields ||= false

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

@@ -133,7 +133,7 @@ module GraphQL
 
         def inherited(subclass)
           super
-          subclass.class_eval do
+          subclass.class_exec do
             @own_interface_type_memberships ||= nil
           end
         end

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

@@ -30,7 +30,7 @@ module GraphQL
 
         def inherited(subclass)
           super
-          subclass.class_eval do
+          subclass.class_exec do
             @reauthorize_scoped_objects = nil
           end
         end

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

@@ -42,7 +42,7 @@ module GraphQL
         private
 
         def inherited(subclass)
-          subclass.class_eval do
+          subclass.class_exec do
             @to_non_null_type ||= nil
             @to_list_type ||= nil
           end

data/lib/graphql/schema/resolver.rb

@@ -22,7 +22,6 @@ 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
@@ -404,6 +403,11 @@ module GraphQL
           end
         end
 
+        def inherited(child_class)
+          child_class.description(description)
+          super
+        end
+
         private
 
         attr_reader :own_extensions

data/lib/graphql/schema.rb

@@ -821,13 +821,13 @@ module GraphQL
 
       attr_writer :validate_timeout
 
-      def validate_timeout(new_validate_timeout = nil)
-        if new_validate_timeout
+      def validate_timeout(new_validate_timeout = NOT_CONFIGURED)
+        if !NOT_CONFIGURED.equal?(new_validate_timeout)
           @validate_timeout = new_validate_timeout
         elsif defined?(@validate_timeout)
           @validate_timeout
         else
-          find_inherited_value(:validate_timeout)
+          find_inherited_value(:validate_timeout) || 3
         end
       end
 

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

@@ -345,7 +345,7 @@ module GraphQL
             fields << Field.new(node, definition, owner_type, parents)
           when GraphQL::Language::Nodes::InlineFragment
             fragment_type = node.type ? @types.type(node.type.name) : owner_type
-            find_fields_and_fragments(node.selections, parents: [*parents, fragment_type], owner_type: owner_type, fields: fields, fragment_spreads: fragment_spreads) if fragment_type
+            find_fields_and_fragments(node.selections, parents: [*parents, fragment_type], owner_type: fragment_type, fields: fields, fragment_spreads: fragment_spreads) if fragment_type
           when GraphQL::Language::Nodes::FragmentSpread
             fragment_spreads << FragmentSpread.new(node.name, parents)
           end

data/lib/graphql/tracing/appoptics_trace.rb

@@ -32,6 +32,8 @@ module GraphQL
         Gem::Version.new('1.0.0')
       end
 
+      # rubocop:disable Development/NoEvalCop This eval takes static inputs at load-time
+
       [
         'lex',
         'parse',
@@ -59,6 +61,8 @@ module GraphQL
         RUBY
       end
 
+      # rubocop:enable Development/NoEvalCop
+
       def execute_field(query:, field:, ast_node:, arguments:, object:)
         return_type = field.type.unwrap
         trace_field = if return_type.kind.scalar? || return_type.kind.enum?

data/lib/graphql/tracing/appsignal_trace.rb

@@ -21,6 +21,8 @@ module GraphQL
         super
       end
 
+      # rubocop:disable Development/NoEvalCop This eval takes static inputs at load-time
+
       {
         "lex" => "lex.graphql",
         "parse" => "parse.graphql",
@@ -51,6 +53,8 @@ module GraphQL
         RUBY
       end
 
+      # rubocop:enable Development/NoEvalCop
+
       def platform_execute_field(platform_key)
         Appsignal.instrument(platform_key) do
           yield

data/lib/graphql/tracing/data_dog_trace.rb

@@ -27,6 +27,8 @@ module GraphQL
         super
       end
 
+      # rubocop:disable Development/NoEvalCop This eval takes static inputs at load-time
+
       {
         'lex' => 'lex.graphql',
         'parse' => 'parse.graphql',
@@ -76,6 +78,8 @@ module GraphQL
         RUBY
       end
 
+      # rubocop:enable Development/NoEvalCop
+
       def execute_field_span(span_key, query, field, ast_node, arguments, object)
         return_type = field.type.unwrap
         trace_field = if return_type.kind.scalar? || return_type.kind.enum?

data/lib/graphql/tracing/new_relic_trace.rb

@@ -13,16 +13,21 @@ module GraphQL
     #     # Optional, use the operation name to set the new relic transaction name:
     #     # trace_with GraphQL::Tracing::NewRelicTrace, set_transaction_name: true
     #   end
+    #
+    # @example Installing without trace events for `authorized?` or `resolve_type` calls
+    #   trace_with GraphQL::Tracing::NewRelicTrace, trace_authorized: false, trace_resolve_type: false
     module NewRelicTrace
       # @param set_transaction_name [Boolean] If true, the GraphQL operation name will be used as the transaction name.
       #   This is not advised if you run more than one query per HTTP request, for example, with `graphql-client` or multiplexing.
       #   It can also be specified per-query with `context[:set_new_relic_transaction_name]`.
       # @param trace_authorized [Boolean] If `false`, skip tracing `authorized?` calls
       # @param trace_resolve_type [Boolean] If `false`, skip tracing `resolve_type?` calls
-      def initialize(set_transaction_name: false, trace_authorized: true, trace_resolve_type: true, **_rest)
+      # @param trace_scalars [Boolean] If `true`, Enum and Scalar fields will be traced by default
+      def initialize(set_transaction_name: false, trace_authorized: true, trace_resolve_type: true, trace_scalars: false, **_rest)
         @set_transaction_name = set_transaction_name
         @trace_authorized = trace_authorized
         @trace_resolve_type = trace_resolve_type
+        @trace_scalars = trace_scalars
         @nr_field_names = Hash.new do |h, field|
           h[field] = "GraphQL/#{field.owner.graphql_name}/#{field.graphql_name}"
         end.compare_by_identity
@@ -89,78 +94,88 @@ module GraphQL
       end
 
       def begin_execute_field(field, object, arguments, query)
-        nr_segment_stack << NewRelic::Agent::Tracer.start_transaction_or_segment(partial_name: @nr_field_names[field], category: :web)
+        return_type = field.type.unwrap
+        trace_field = if return_type.kind.scalar? || return_type.kind.enum?
+          (field.trace.nil? && @trace_scalars) || field.trace
+        else
+          true
+        end
+        if trace_field
+          start_segment(partial_name: @nr_field_names[field], category: :web)
+        end
         super
       end
 
       def end_execute_field(field, objects, arguments, query, result)
-        nr_segment_stack.pop.finish
+        finish_segment
         super
       end
 
       def begin_authorized(type, obj, ctx)
         if @trace_authorized
-          nr_segment_stack << NewRelic::Agent::Tracer.start_transaction_or_segment(partial_name: @nr_authorized_names[type], category: :web)
+          start_segment(partial_name: @nr_authorized_names[type], category: :web)
         end
         super
       end
 
       def end_authorized(type, obj, ctx, is_authed)
         if @trace_authorized
-          nr_segment_stack.pop.finish
+          finish_segment
         end
         super
       end
 
       def begin_resolve_type(type, value, context)
         if @trace_resolve_type
-          nr_segment_stack << NewRelic::Agent::Tracer.start_transaction_or_segment(partial_name: @nr_resolve_type_names[type], category: :web)
+          start_segment(partial_name: @nr_resolve_type_names[type], category: :web)
         end
         super
       end
 
       def end_resolve_type(type, value, context, resolved_type)
         if @trace_resolve_type
-          nr_segment_stack.pop.finish
+          finish_segment
         end
         super
       end
 
-      def begin_dataloader(dl)
-        super
-      end
-
-      def end_dataloader(dl)
-        super
-      end
-
       def begin_dataloader_source(source)
-        nr_segment_stack << NewRelic::Agent::Tracer.start_transaction_or_segment(partial_name: @nr_source_names[source], category: :web)
+        start_segment(partial_name: @nr_source_names[source], category: :web)
         super
       end
 
       def end_dataloader_source(source)
-        nr_segment_stack.pop.finish
+        finish_segment
         super
       end
 
       def dataloader_fiber_yield(source)
-        current_segment = nr_segment_stack.last
-        current_segment.finish
+        prev_segment = finish_segment
+        Fiber[:graphql_nr_previous_segment] = prev_segment
         super
       end
 
       def dataloader_fiber_resume(source)
-        prev_segment = nr_segment_stack.pop
+        prev_segment = Fiber[:graphql_nr_previous_segment]
+        Fiber[:graphql_nr_previous_segment] = nil
         seg_partial_name = prev_segment.name.sub(/^.*(GraphQL.*)$/, '\1')
-        nr_segment_stack << NewRelic::Agent::Tracer.start_transaction_or_segment(partial_name: seg_partial_name, category: :web)
+        start_segment(partial_name: seg_partial_name, category: :web)
         super
       end
 
       private
 
-      def nr_segment_stack
-        Fiber[:graphql_nr_segment_stack] ||= []
+      def start_segment(...)
+        Fiber[:graphql_nr_segment] = NewRelic::Agent::Tracer.start_transaction_or_segment(...)
+      end
+
+      def finish_segment
+        segment = Fiber[:graphql_nr_segment]
+        if segment
+          segment.finish
+          Fiber[:graphql_nr_segment] = nil
+          segment
+        end
       end
 
       def transaction_name(query)

data/lib/graphql/tracing/notifications_trace.rb

@@ -16,6 +16,8 @@ module GraphQL
         super
       end
 
+      # rubocop:disable Development/NoEvalCop This eval takes static inputs at load-time
+
       {
         "lex" => "lex.graphql",
         "parse" => "parse.graphql",
@@ -39,6 +41,8 @@ module GraphQL
         RUBY
       end
 
+      # rubocop:enable Development/NoEvalCop
+
       include PlatformTrace
     end
   end

data/lib/graphql/tracing/platform_trace.rb

@@ -39,6 +39,9 @@ module GraphQL
           include(BaseKeyCache)
         }
         child_class.const_set(:KeyCache, key_methods_class)
+
+        # rubocop:disable Development/NoEvalCop This eval takes static inputs at load-time
+
         [:execute_field, :execute_field_lazy].each do |field_trace_method|
           if !child_class.method_defined?(field_trace_method)
             child_class.module_eval <<-RUBY, __FILE__, __LINE__
@@ -91,6 +94,8 @@ module GraphQL
               end
             RUBY
           end
+
+          # rubocop:enable Development/NoEvalCop
         end
       end
 

data/lib/graphql/tracing/prometheus_trace.rb

@@ -40,6 +40,8 @@ module GraphQL
         super(**rest)
       end
 
+      # rubocop:disable Development/NoEvalCop This eval takes static inputs at load-time
+
       {
         'lex' => "graphql.lex",
         'parse' => "graphql.parse",
@@ -57,6 +59,8 @@ module GraphQL
         RUBY
       end
 
+      # rubocop:enable Development/NoEvalCop
+
       def platform_execute_field(platform_key, &block)
         instrument_prometheus_execution(platform_key, "execute_field", &block)
       end

data/lib/graphql/tracing/scout_trace.rb

@@ -24,6 +24,8 @@ module GraphQL
         super
       end
 
+      # rubocop:disable Development/NoEvalCop This eval takes static inputs at load-time
+
       {
         "lex" => "lex.graphql",
         "parse" => "parse.graphql",
@@ -53,6 +55,7 @@ module GraphQL
         end
         RUBY
       end
+      # rubocop:enable Development/NoEvalCop
 
       def platform_execute_field(platform_key, &block)
         self.class.instrument("GraphQL", platform_key, INSTRUMENT_OPTS, &block)

data/lib/graphql/tracing/sentry_trace.rb

@@ -30,6 +30,8 @@ module GraphQL
         instrument_sentry_execution("graphql.execute", "execute_query", data) { super }
       end
 
+      # rubocop:disable Development/NoEvalCop This eval takes static inputs at load-time
+
       {
         "lex" => "graphql.lex",
         "parse" => "graphql.parse",
@@ -46,6 +48,8 @@ module GraphQL
         RUBY
       end
 
+      # rubocop:enable Development/NoEvalCop
+
       def platform_execute_field(platform_key, &block)
         instrument_sentry_execution(platform_key, "execute_field", &block)
       end

data/lib/graphql/tracing/statsd_trace.rb

@@ -22,6 +22,8 @@ module GraphQL
         super(**rest)
       end
 
+      # rubocop:disable Development/NoEvalCop This eval takes static inputs at load-time
+
       {
         'lex' => "graphql.lex",
         'parse' => "graphql.parse",
@@ -41,6 +43,8 @@ module GraphQL
         RUBY
       end
 
+      # rubocop:enable Development/NoEvalCop
+
       def platform_execute_field(platform_key, &block)
         @statsd.time(platform_key, &block)
       end

data/lib/graphql/types/relay/connection_behaviors.rb

@@ -13,7 +13,7 @@ module GraphQL
           child_class.node_nullable(true)
           child_class.edges_nullable(true)
           child_class.edge_nullable(true)
-          child_class.module_eval {
+          child_class.module_exec {
             self.edge_type = nil
             self.node_type = nil
             self.edge_class = nil

data/lib/graphql/types/relay/edge_behaviors.rb

@@ -8,7 +8,7 @@ module GraphQL
           child_class.description("An edge in a connection.")
           child_class.field(:cursor, String, null: false, description: "A cursor for use in pagination.")
           child_class.extend(ClassMethods)
-          child_class.class_eval { self.node_type = nil }
+          child_class.class_exec { self.node_type = nil }
           child_class.node_nullable(true)
           child_class.default_broadcastable(nil)
         end

data/lib/graphql/version.rb

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

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.4.11
+  version: 2.4.13
 platform: ruby
 authors:
 - Robert Mosolgo
 bindir: bin
 cert_chain: []
-date: 2025-02-28 00:00:00.000000000 Z
+date: 2025-03-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64