graphql 2.3.2 → 2.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 573ce6f5423ca2d9eb0ca3dab40f01869501f834c3b48d5cac7f7c06fbf36da9
-  data.tar.gz: c3b1f0393d2838a2478a36a43cec88560832c220a3896f2ee4c715d013d1758c
+  metadata.gz: c8f2d38dd0c349521f7f22050bb70cee1f06a7832de74d5afe523a35310ed318
+  data.tar.gz: da047a5e11a1441060411c47468daad16300db1dc7064ab1b1a76d2e519e76fd
 SHA512:
-  metadata.gz: 14d6c96c20c8fdb56ecddf0279e24e83c862d4133c72b3cebc44dca9e40e1c684b4f4a4c45fca81451d48d1bb97a4e6c3ae13499a40e12a76926e679a12a13f2
-  data.tar.gz: 44157aaa761da8c9f82afa9e31533ee3c87cdf4257256ec84f70f0e30dff8dc1830486c2ff02b4464a67e8815518466451ae598eabc12249cf2edaad6a9371f1
+  metadata.gz: 73bd380530a4183241587083beb2ef6c96709657fb18e702a294a37c22f26e2141b2111b96c79570b9588d330e9c8d851fd532cdaf6d6fbd55f9dd5b30c6fe4e
+  data.tar.gz: 917e88d0cec3cbc760ec89714cf31325088f94f0a93094b3fcbf1cc3c07f52a99e30f0e418e561518c0a7deef0358dfa0ae457b8bad88fb50883aacb9d7dae7f

data/lib/graphql/analysis/ast/query_complexity.rb

@@ -8,6 +8,7 @@ module GraphQL
         # - `complexities_on_type` holds complexity scores for each type
         def initialize(query)
           super
+          @skip_introspection_fields = !query.schema.max_complexity_count_introspection_fields
           @complexities_on_type_by_query = {}
         end
 
@@ -51,6 +52,7 @@ module GraphQL
           # we'll visit them when we hit the spreads instead
           return if visitor.visiting_fragment_definition?
           return if visitor.skipping?
+          return if @skip_introspection_fields && visitor.field_definition.introspection?
           parent_type = visitor.parent_type_definition
           field_key = node.alias || node.name
 
@@ -68,6 +70,7 @@ module GraphQL
           # we'll visit them when we hit the spreads instead
           return if visitor.visiting_fragment_definition?
           return if visitor.skipping?
+          return if @skip_introspection_fields && visitor.field_definition.introspection?
           scopes_stack = @complexities_on_type_by_query[visitor.query]
           scopes_stack.pop
         end

data/lib/graphql/dataloader/async_dataloader.rb

@@ -77,6 +77,7 @@ module GraphQL
             set_fiber_variables(fiber_vars)
             Thread.current[:graphql_dataloader_next_tick] = condition
             pending_sources.each(&:run_pending_keys)
+            cleanup_fiber
           end
         end
       end

data/lib/graphql/dataloader.rb

@@ -88,6 +88,11 @@ module GraphQL
       nil
     end
 
+    # This method is called when Dataloader is finished using a fiber.
+    # Use it to perform any cleanup, such as releasing database connections (if required manually)
+    def cleanup_fiber
+    end
+
     # Get a Source instance from this dataloader, for calling `.load(...)` or `.request(...)` on.
     #
     # @param source_class [Class<GraphQL::Dataloader::Source]
@@ -231,9 +236,7 @@ module GraphQL
       Fiber.new(blocking: !@nonblocking) {
         set_fiber_variables(fiber_vars)
         yield
-        # With `.transfer`, you have to explicitly pass back to the parent --
-        # if the fiber is allowed to terminate normally, control is passed to the main fiber instead.
-        true
+        cleanup_fiber
       }
     end
 

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

@@ -5,8 +5,10 @@ module GraphQL
     class Interpreter
       class Runtime
         module GraphQLResult
-          def initialize(result_name, parent_result, is_non_null_in_parent)
+          def initialize(result_name, result_type, application_value, parent_result, is_non_null_in_parent)
             @graphql_parent = parent_result
+            @graphql_application_value = application_value
+            @graphql_result_type = result_type
             if parent_result && parent_result.graphql_dead
               @graphql_dead = true
             end
@@ -26,14 +28,14 @@ module GraphQL
           end
 
           attr_accessor :graphql_dead
-          attr_reader :graphql_parent, :graphql_result_name, :graphql_is_non_null_in_parent
+          attr_reader :graphql_parent, :graphql_result_name, :graphql_is_non_null_in_parent, :graphql_application_value, :graphql_result_type
 
           # @return [Hash] Plain-Ruby result data (`@graphql_metadata` contains Result wrapper objects)
           attr_accessor :graphql_result_data
         end
 
         class GraphQLResultHash
-          def initialize(_result_name, _parent_result, _is_non_null_in_parent)
+          def initialize(_result_name, _result_type, _application_value, _parent_result, _is_non_null_in_parent)
             super
             @graphql_result_data = {}
           end
@@ -121,7 +123,7 @@ module GraphQL
         class GraphQLResultArray
           include GraphQLResult
 
-          def initialize(_result_name, _parent_result, _is_non_null_in_parent)
+          def initialize(_result_name, _result_type, _application_value, _parent_result, _is_non_null_in_parent)
             super
             @graphql_result_data = []
           end

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

@@ -11,7 +11,6 @@ module GraphQL
       class Runtime
         class CurrentState
           def initialize
-            @current_object = nil
             @current_field = nil
             @current_arguments = nil
             @current_result_name = nil
@@ -19,8 +18,12 @@ module GraphQL
             @was_authorized_by_scope_items = nil
           end
 
+          def current_object
+            @current_result.graphql_application_value
+          end
+
           attr_accessor :current_result, :current_result_name,
-            :current_arguments, :current_field, :current_object, :was_authorized_by_scope_items
+            :current_arguments, :current_field, :was_authorized_by_scope_items
         end
 
         # @return [GraphQL::Query]
@@ -39,7 +42,7 @@ module GraphQL
           @lazies_at_depth = lazies_at_depth
           @schema = query.schema
           @context = query.context
-          @response = GraphQLResultHash.new(nil, nil, false)
+          @response = nil
           # Identify runtime directives by checking which of this schema's directives have overridden `def self.resolve`
           @runtime_directive_names = []
           noop_resolve_owner = GraphQL::Schema::Directive.singleton_class
@@ -79,12 +82,11 @@ module GraphQL
           root_operation = query.selected_operation
           root_op_type = root_operation.operation_type || "query"
           root_type = schema.root_type_for_operation(root_op_type)
-
-          st = get_current_runtime_state
-          st.current_object = query.root_value
-          st.current_result = @response
           runtime_object = root_type.wrap(query.root_value, context)
           runtime_object = schema.sync_lazy(runtime_object)
+          @response = GraphQLResultHash.new(nil, root_type, runtime_object, nil, false)
+          st = get_current_runtime_state
+          st.current_result = @response
 
           if runtime_object.nil?
             # Root .authorized? returned false.
@@ -101,7 +103,7 @@ module GraphQL
               # directly evaluated and the results can be written right into the main response hash.
               tap_or_each(gathered_selections) do |selections, is_selection_array|
                 if is_selection_array
-                  selection_response = GraphQLResultHash.new(nil, nil, false)
+                  selection_response = GraphQLResultHash.new(nil, root_type, runtime_object, nil, false)
                   final_response = @response
                 else
                   selection_response = @response
@@ -109,26 +111,14 @@ module GraphQL
                 end
 
                 @dataloader.append_job {
-                  st = get_current_runtime_state
-                  st.current_object = query.root_value
-                  st.current_result_name = nil
-                  st.current_result = selection_response
-                  # This is a less-frequent case; use a fast check since it's often not there.
-                  if (directives = selections[:graphql_directives])
-                    selections.delete(:graphql_directives)
-                  end
-                  call_method_on_directives(:resolve, runtime_object, directives) do
-                    evaluate_selections(
-                      runtime_object,
-                      root_type,
-                      root_op_type == "mutation",
-                      selections,
-                      selection_response,
-                      final_response,
-                      nil,
-                      st,
-                    )
-                  end
+                  evaluate_selections(
+                    root_op_type == "mutation",
+                    selections,
+                    selection_response,
+                    final_response,
+                    nil,
+                    nil,
+                  )
                 }
               end
             end
@@ -137,7 +127,6 @@ module GraphQL
         end
 
         def gather_selections(owner_object, owner_type, selections, selections_to_run = nil, selections_by_name = {})
-
           selections.each do |node|
             # Skip gathering this if the directive says so
             if !directives_include?(node, owner_object, owner_type)
@@ -182,17 +171,26 @@ module GraphQL
                   type_defn = schema.get_type(node.type.name, context)
 
                   if query.warden.possible_types(type_defn).include?(owner_type)
-                    gather_selections(owner_object, owner_type, node.selections, selections_to_run, next_selections)
+                    result = gather_selections(owner_object, owner_type, node.selections, selections_to_run, next_selections)
+                    if !result.equal?(next_selections)
+                      selections_to_run = result
+                    end
                   end
                 else
                   # it's an untyped fragment, definitely continue
-                  gather_selections(owner_object, owner_type, node.selections, selections_to_run, next_selections)
+                  result = gather_selections(owner_object, owner_type, node.selections, selections_to_run, next_selections)
+                  if !result.equal?(next_selections)
+                    selections_to_run = result
+                  end
                 end
               when GraphQL::Language::Nodes::FragmentSpread
                 fragment_def = query.fragments[node.name]
                 type_defn = query.get_type(fragment_def.type.name)
                 if query.warden.possible_types(type_defn).include?(owner_type)
-                  gather_selections(owner_object, owner_type, fragment_def.selections, selections_to_run, next_selections)
+                  result = gather_selections(owner_object, owner_type, fragment_def.selections, selections_to_run, next_selections)
+                  if !result.equal?(next_selections)
+                    selections_to_run = result
+                  end
                 end
               else
                 raise "Invariant: unexpected selection class: #{node.class}"
@@ -205,36 +203,44 @@ module GraphQL
         NO_ARGS = GraphQL::EmptyObjects::EMPTY_HASH
 
         # @return [void]
-        def evaluate_selections(owner_object, owner_type, is_eager_selection, gathered_selections, selections_result, target_result, parent_object, runtime_state) # rubocop:disable Metrics/ParameterLists
-          finished_jobs = 0
-          enqueued_jobs = gathered_selections.size
-          gathered_selections.each do |result_name, field_ast_nodes_or_ast_node|
-            @dataloader.append_job {
-              runtime_state = get_current_runtime_state
-              evaluate_selection(
-                result_name, field_ast_nodes_or_ast_node, owner_object, owner_type, is_eager_selection, selections_result, parent_object, runtime_state
-              )
-              finished_jobs += 1
-              if target_result && finished_jobs == enqueued_jobs
-                selections_result.merge_into(target_result)
+        def evaluate_selections(is_eager_selection, gathered_selections, selections_result, target_result, parent_object, runtime_state) # rubocop:disable Metrics/ParameterLists
+          runtime_state ||= get_current_runtime_state
+          runtime_state.current_result_name = nil
+          runtime_state.current_result = selections_result
+          # This is a less-frequent case; use a fast check since it's often not there.
+          if (directives = gathered_selections[:graphql_directives])
+            gathered_selections.delete(:graphql_directives)
+          end
+
+          call_method_on_directives(:resolve, selections_result.graphql_application_value, directives) do
+            finished_jobs = 0
+            enqueued_jobs = gathered_selections.size
+            gathered_selections.each do |result_name, field_ast_nodes_or_ast_node|
+              @dataloader.append_job {
+                evaluate_selection(
+                  result_name, field_ast_nodes_or_ast_node, is_eager_selection, selections_result, parent_object
+                )
+                finished_jobs += 1
+                if target_result && finished_jobs == enqueued_jobs
+                  selections_result.merge_into(target_result)
+                end
+              }
+              # Field resolution may pause the fiber,
+              # so it wouldn't get to the `Resolve` call that happens below.
+              # So instead trigger a run from this outer context.
+              if is_eager_selection
+                @dataloader.clear_cache
+                @dataloader.run
+                @dataloader.clear_cache
               end
-            }
-            # Field resolution may pause the fiber,
-            # so it wouldn't get to the `Resolve` call that happens below.
-            # So instead trigger a run from this outer context.
-            if is_eager_selection
-              @dataloader.clear_cache
-              @dataloader.run
-              @dataloader.clear_cache
             end
+            selections_result
           end
-
-          selections_result
         end
 
         # @return [void]
-        def evaluate_selection(result_name, field_ast_nodes_or_ast_node, owner_object, owner_type, is_eager_field, selections_result, parent_object, runtime_state) # rubocop:disable Metrics/ParameterLists
-          return if dead_result?(selections_result)
+        def evaluate_selection(result_name, field_ast_nodes_or_ast_node, is_eager_field, selections_result, parent_object) # rubocop:disable Metrics/ParameterLists
+          return if selections_result.graphql_dead
           # As a performance optimization, the hash key will be a `Node` if
           # there's only one selection of the field. But if there are multiple
           # selections of the field, it will be an Array of nodes
@@ -246,13 +252,16 @@ module GraphQL
             ast_node = field_ast_nodes_or_ast_node
           end
           field_name = ast_node.name
+          owner_type = selections_result.graphql_result_type
           field_defn = query.warden.get_field(owner_type, field_name)
 
           # Set this before calling `run_with_directives`, so that the directive can have the latest path
+          runtime_state = get_current_runtime_state
           runtime_state.current_field = field_defn
           runtime_state.current_result = selections_result
           runtime_state.current_result_name = result_name
 
+          owner_object = selections_result.graphql_application_value
           if field_defn.dynamic_introspection
             owner_object = field_defn.owner.wrap(owner_object, context)
           end
@@ -262,24 +271,24 @@ module GraphQL
             resolved_arguments = GraphQL::Execution::Interpreter::Arguments::EMPTY
             if field_defn.extras.size == 0
               evaluate_selection_with_resolved_keyword_args(
-                NO_ARGS, resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_type, owner_object, is_eager_field, result_name, selections_result, parent_object, return_type, return_type.non_null?, runtime_state
+                NO_ARGS, resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_object, is_eager_field, result_name, selections_result, parent_object, return_type, return_type.non_null?, runtime_state
               )
             else
-              evaluate_selection_with_args(resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_type, owner_object, is_eager_field, result_name, selections_result, parent_object, return_type, runtime_state)
+              evaluate_selection_with_args(resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_object, is_eager_field, result_name, selections_result, parent_object, return_type, runtime_state)
             end
           else
             @query.arguments_cache.dataload_for(ast_node, field_defn, owner_object) do |resolved_arguments|
               runtime_state = get_current_runtime_state # This might be in a different fiber
-              evaluate_selection_with_args(resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_type, owner_object, is_eager_field, result_name, selections_result, parent_object, return_type, runtime_state)
+              evaluate_selection_with_args(resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_object, is_eager_field, result_name, selections_result, parent_object, return_type, runtime_state)
             end
           end
         end
 
-        def evaluate_selection_with_args(arguments, field_defn, ast_node, field_ast_nodes, owner_type, object, is_eager_field, result_name, selection_result, parent_object, return_type, runtime_state)  # rubocop:disable Metrics/ParameterLists
+        def evaluate_selection_with_args(arguments, field_defn, ast_node, field_ast_nodes, object, is_eager_field, result_name, selection_result, parent_object, return_type, runtime_state)  # rubocop:disable Metrics/ParameterLists
           after_lazy(arguments, field: field_defn, ast_node: ast_node, owner_object: object, arguments: arguments, result_name: result_name, result: selection_result, runtime_state: runtime_state) do |resolved_arguments, runtime_state|
             return_type_non_null = return_type.non_null?
             if resolved_arguments.is_a?(GraphQL::ExecutionError) || resolved_arguments.is_a?(GraphQL::UnauthorizedError)
-              continue_value(resolved_arguments, owner_type, field_defn, return_type_non_null, ast_node, result_name, selection_result)
+              continue_value(resolved_arguments, field_defn, return_type_non_null, ast_node, result_name, selection_result)
               next
             end
 
@@ -328,13 +337,12 @@ module GraphQL
               resolved_arguments.keyword_arguments
             end
 
-            evaluate_selection_with_resolved_keyword_args(kwarg_arguments, resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_type, object, is_eager_field, result_name, selection_result, parent_object, return_type, return_type_non_null, runtime_state)
+            evaluate_selection_with_resolved_keyword_args(kwarg_arguments, resolved_arguments, field_defn, ast_node, field_ast_nodes, object, is_eager_field, result_name, selection_result, parent_object, return_type, return_type_non_null, runtime_state)
           end
         end
 
-        def evaluate_selection_with_resolved_keyword_args(kwarg_arguments, resolved_arguments, field_defn, ast_node, field_ast_nodes, owner_type, object, is_eager_field, result_name, selection_result, parent_object, return_type, return_type_non_null, runtime_state)  # rubocop:disable Metrics/ParameterLists
+        def evaluate_selection_with_resolved_keyword_args(kwarg_arguments, resolved_arguments, field_defn, ast_node, field_ast_nodes, object, is_eager_field, result_name, selection_result, parent_object, return_type, return_type_non_null, runtime_state)  # rubocop:disable Metrics/ParameterLists
           runtime_state.current_field = field_defn
-          runtime_state.current_object = object
           runtime_state.current_arguments = resolved_arguments
           runtime_state.current_result_name = result_name
           runtime_state.current_result = selection_result
@@ -356,7 +364,6 @@ module GraphQL
               # This might be executed in a different context; reset this info
               runtime_state = get_current_runtime_state
               runtime_state.current_field = field_defn
-              runtime_state.current_object = object
               runtime_state.current_arguments = resolved_arguments
               runtime_state.current_result_name = result_name
               runtime_state.current_result = selection_result
@@ -376,7 +383,8 @@ module GraphQL
               end
             end
             after_lazy(app_result, field: field_defn, ast_node: ast_node, owner_object: object, arguments: resolved_arguments, result_name: result_name, result: selection_result, runtime_state: runtime_state) do |inner_result, runtime_state|
-              continue_value = continue_value(inner_result, owner_type, field_defn, return_type_non_null, ast_node, result_name, selection_result)
+              owner_type = selection_result.graphql_result_type
+              continue_value = continue_value(inner_result, field_defn, return_type_non_null, ast_node, result_name, selection_result)
               if HALT != continue_value
                 was_scoped = runtime_state.was_authorized_by_scope_items
                 runtime_state.was_authorized_by_scope_items = nil
@@ -384,25 +392,16 @@ module GraphQL
               end
             end
           end
-
           # If this field is a root mutation field, immediately resolve
           # all of its child fields before moving on to the next root mutation field.
           # (Subselections of this mutation will still be resolved level-by-level.)
           if is_eager_field
             Interpreter::Resolve.resolve_all([field_result], @dataloader)
-          else
-            # Return this from `after_lazy` because it might be another lazy that needs to be resolved
-            field_result
           end
         end
 
-
-        def dead_result?(selection_result)
-          selection_result.graphql_dead  # || ((parent = selection_result.graphql_parent) && parent.graphql_dead)
-        end
-
         def set_result(selection_result, result_name, value, is_child_result, is_non_null)
-          if !dead_result?(selection_result)
+          if !selection_result.graphql_dead
             if value.nil? && is_non_null
               # This is an invalid nil that should be propagated
               # One caller of this method passes a block,
@@ -456,11 +455,13 @@ module GraphQL
         end
 
         HALT = Object.new
-        def continue_value(value, parent_type, field, is_non_null, ast_node, result_name, selection_result) # rubocop:disable Metrics/ParameterLists
+        def continue_value(value, field, is_non_null, ast_node, result_name, selection_result) # rubocop:disable Metrics/ParameterLists
           case value
           when nil
             if is_non_null
               set_result(selection_result, result_name, nil, false, is_non_null) do
+                # 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)
                 schema.type_error(err, context)
@@ -474,7 +475,7 @@ module GraphQL
             # to avoid the overhead of checking three different classes
             # every time.
             if value.is_a?(GraphQL::ExecutionError)
-              if selection_result.nil? || !dead_result?(selection_result)
+              if selection_result.nil? || !selection_result.graphql_dead
                 value.path ||= current_path
                 value.ast_node ||= ast_node
                 context.errors << value
@@ -492,7 +493,7 @@ module GraphQL
               rescue GraphQL::ExecutionError => err
                 err
               end
-              continue_value(next_value, parent_type, field, is_non_null, ast_node, result_name, selection_result)
+              continue_value(next_value, field, is_non_null, ast_node, result_name, selection_result)
             elsif value.is_a?(GraphQL::UnauthorizedError)
               # this hook might raise & crash, or it might return
               # a replacement value
@@ -501,7 +502,7 @@ module GraphQL
               rescue GraphQL::ExecutionError => err
                 err
               end
-              continue_value(next_value, parent_type, field, is_non_null, ast_node, result_name, selection_result)
+              continue_value(next_value, field, is_non_null, ast_node, result_name, selection_result)
             elsif GraphQL::Execution::SKIP == value
               # It's possible a lazy was already written here
               case selection_result
@@ -524,7 +525,7 @@ module GraphQL
             # It's an array full of execution errors; add them all.
             if value.any? && value.all?(GraphQL::ExecutionError)
               list_type_at_all = (field && (field.type.list?))
-              if selection_result.nil? || !dead_result?(selection_result)
+              if selection_result.nil? || !selection_result.graphql_dead
                 value.each_with_index do |error, index|
                   error.ast_node ||= ast_node
                   error.path ||= current_path + (list_type_at_all ? [index] : [])
@@ -604,9 +605,9 @@ module GraphQL
               err
             end
             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, owner_type, field, is_non_null, ast_node, result_name, selection_result)
+              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, selection_result, is_non_null)
+                response_hash = GraphQLResultHash.new(result_name, current_type, continue_value, selection_result, is_non_null)
                 set_result(selection_result, result_name, response_hash, true, is_non_null)
 
                 gathered_selections = gather_selections(continue_value, current_type, next_selections)
@@ -620,34 +621,21 @@ module GraphQL
                 #    (Technically, it's possible that one of those entries _doesn't_ require isolation.)
                 tap_or_each(gathered_selections) do |selections, is_selection_array|
                   if is_selection_array
-                    this_result = GraphQLResultHash.new(result_name, selection_result, is_non_null)
+                    this_result = GraphQLResultHash.new(result_name, current_type, continue_value, selection_result, is_non_null)
                     final_result = response_hash
                   else
                     this_result = response_hash
                     final_result = nil
                   end
-                  # reset this mutable state
-                  # Unset `result_name` here because it's already included in the new response hash
-                  runtime_state.current_object = continue_value
-                  runtime_state.current_result_name = nil
-                  runtime_state.current_result = this_result
-                  # This is a less-frequent case; use a fast check since it's often not there.
-                  if (directives = selections[:graphql_directives])
-                    selections.delete(:graphql_directives)
-                  end
-                  call_method_on_directives(:resolve, continue_value, directives) do
-                    evaluate_selections(
-                      continue_value,
-                      current_type,
-                      false,
-                      selections,
-                      this_result,
-                      final_result,
-                      owner_object.object,
-                      runtime_state,
-                    )
-                    this_result
-                  end
+
+                  evaluate_selections(
+                    false,
+                    selections,
+                    this_result,
+                    final_result,
+                    owner_object.object,
+                    runtime_state,
+                  )
                 end
               end
             end
@@ -656,7 +644,7 @@ 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, selection_result, is_non_null)
+            response_list = GraphQLResultArray.new(result_name, current_type, response_list, selection_result, is_non_null)
             set_result(selection_result, result_name, response_list, true, is_non_null)
             idx = nil
             list_value = begin
@@ -694,7 +682,7 @@ module GraphQL
             end
             # Detect whether this error came while calling `.each` (before `idx` is set) or while running list *items* (after `idx` is set)
             error_is_non_null = idx.nil? ? is_non_null : inner_type.non_null?
-            continue_value(list_value, owner_type, field, error_is_non_null, ast_node, result_name, selection_result)
+            continue_value(list_value, field, error_is_non_null, ast_node, result_name, selection_result)
           else
             raise "Invariant: Unhandled type kind #{current_type.kind} (#{current_type})"
           end
@@ -706,7 +694,7 @@ module GraphQL
           call_method_on_directives(:resolve_each, owner_object, ast_node.directives) do
             # This will update `response_list` with the lazy
             after_lazy(inner_value, ast_node: ast_node, field: field, owner_object: owner_object, arguments: arguments, result_name: this_idx, result: response_list, runtime_state: runtime_state) do |inner_inner_value, runtime_state|
-              continue_value = continue_value(inner_inner_value, owner_type, field, inner_type_non_null, ast_node, this_idx, response_list)
+              continue_value = continue_value(inner_inner_value, field, inner_type_non_null, ast_node, this_idx, response_list)
               if HALT != continue_value
                 continue_field(continue_value, owner_type, field, inner_type, ast_node, next_selections, false, owner_object, arguments, this_idx, response_list, was_scoped, runtime_state)
               end
@@ -728,7 +716,6 @@ module GraphQL
             raw_dir_args = arguments(nil, dir_defn, dir_node)
             dir_args = continue_value(
               raw_dir_args, # value
-              dir_defn, # parent_type
               nil, # field
               false, # is_non_null
               dir_node, # ast_node
@@ -794,7 +781,6 @@ module GraphQL
               # In that case, this will initialize a new state
               # to avoid conflicting with the parent fiber.
               runtime_state = get_current_runtime_state
-              runtime_state.current_object = owner_object
               runtime_state.current_field = field
               runtime_state.current_arguments = arguments
               runtime_state.current_result_name = result_name

data/lib/graphql/language/nodes.rb

@@ -20,26 +20,29 @@ module GraphQL
             @definition_line = definition_line
             super(**_rest)
           end
+
+          def marshal_dump
+            super << @definition_line
+          end
+
+          def marshal_load(values)
+            @definition_line = values.pop
+            super
+          end
         end
 
         attr_reader :filename
 
         def line
-          @line ||= (@source_string && @pos) ? @source_string[0..@pos].count("\n") + 1 : nil
+          @line ||= @source.line_at(@pos)
         end
 
         def col
-          @col ||= if @source_string && @pos
-            if @pos == 0
-              1
-            else
-              @source_string[0..@pos].split("\n").last.length
-            end
-          end
+          @col ||= @source.column_at(@pos)
         end
 
         def definition_line
-          @definition_line ||= (@source_string && @definition_pos) ? @source_string[0..@definition_pos].count("\n") + 1 : nil
+          @definition_line ||= (@source && @definition_pos) ? @source.line_at(@definition_pos) : nil
         end
 
         # Value equality
@@ -267,7 +270,7 @@ module GraphQL
             "col: nil",
             "pos: nil",
             "filename: nil",
-            "source_string: nil",
+            "source: nil",
           ]
 
           def generate_initialize
@@ -279,18 +282,20 @@ module GraphQL
               end
             end
 
-            all_method_names = scalar_method_names + @children_methods.keys
+            children_method_names = @children_methods.keys
+
+            all_method_names = scalar_method_names + children_method_names
             if all_method_names.include?(:alias)
               # Rather than complicating this special case,
               # let it be overridden (in field)
               return
             else
               arguments = scalar_method_names.map { |m| "#{m}: nil"} +
-                @children_methods.keys.map { |m| "#{m}: NO_CHILDREN" } +
+                children_method_names.map { |m| "#{m}: NO_CHILDREN" } +
                 DEFAULT_INITIALIZE_OPTIONS
 
               assignments = scalar_method_names.map { |m| "@#{m} = #{m}"} +
-                @children_methods.keys.map { |m| "@#{m} = #{m}.freeze" }
+                children_method_names.map { |m| "@#{m} = #{m}.freeze" }
 
               if name.end_with?("Definition") && name != "FragmentDefinition"
                 arguments << "definition_pos: nil"
@@ -298,7 +303,7 @@ module GraphQL
               end
 
               keywords = scalar_method_names.map { |m| "#{m}: #{m}"} +
-                @children_methods.keys.map { |m| "#{m}: #{m}" }
+                children_method_names.map { |m| "#{m}: #{m}" }
 
               module_eval <<-RUBY, __FILE__, __LINE__
                 def initialize(#{arguments.join(", ")})
@@ -306,13 +311,25 @@ module GraphQL
                   @col = col
                   @pos = pos
                   @filename = filename
-                  @source_string = source_string
+                  @source = source
                   #{assignments.join("\n")}
                 end
 
-                def self.from_a(filename, line, col, #{(scalar_method_names + @children_methods.keys).join(", ")})
+                def self.from_a(filename, line, col, #{all_method_names.join(", ")})
                   self.new(filename: filename, line: line, col: col, #{keywords.join(", ")})
                 end
+
+                def marshal_dump
+                  [
+                    line, col, # use methods here to force them to be calculated
+                    @filename,
+                    #{all_method_names.map { |n| "@#{n}," }.join}
+                  ]
+                end
+
+                def marshal_load(values)
+                  @line, @col, @filename #{all_method_names.map { |n| ", @#{n}"}.join} = values
+                end
               RUBY
             end
           end
@@ -385,7 +402,7 @@ module GraphQL
         # @!attribute selections
         #   @return [Array<Nodes::Field>] Selections on this object (or empty array if this is a scalar field)
 
-        def initialize(name: nil, arguments: NONE, directives: NONE, selections: NONE, field_alias: nil, line: nil, col: nil, pos: nil, filename: nil, source_string: nil)
+        def initialize(name: nil, arguments: NONE, directives: NONE, selections: NONE, field_alias: nil, line: nil, col: nil, pos: nil, filename: nil, source: nil)
           @name = name
           @arguments = arguments || NONE
           @directives = directives || NONE
@@ -396,13 +413,21 @@ module GraphQL
           @col = col
           @pos = pos
           @filename = filename
-          @source_string = source_string
+          @source = source
         end
 
         def self.from_a(filename, line, col, field_alias, name, arguments, directives, selections) # rubocop:disable Metrics/ParameterLists
           self.new(filename: filename, line: line, col: col, field_alias: field_alias, name: name, arguments: arguments, directives: directives, selections: selections)
         end
 
+        def marshal_dump
+          [line, col, @filename, @name, @arguments, @directives, @selections, @alias]
+        end
+
+        def marshal_load(values)
+          @line, @col, @filename, @name, @arguments, @directives, @selections, @alias = values
+        end
+
         # Override this because default is `:fields`
         self.children_method_name = :selections
       end
@@ -421,14 +446,14 @@ module GraphQL
 
         # @!attribute type
         #   @return [String] the type condition for this fragment (name of type which it may apply to)
-        def initialize(name: nil, type: nil, directives: NONE, selections: NONE, filename: nil, pos: nil, source_string: nil, line: nil, col: nil)
+        def initialize(name: nil, type: nil, directives: NONE, selections: NONE, filename: nil, pos: nil, source: nil, line: nil, col: nil)
           @name = name
           @type = type
           @directives = directives
           @selections = selections
           @filename  = filename
           @pos = pos
-          @source_string = source_string
+          @source = source
           @line = line
           @col = col
         end
@@ -436,6 +461,14 @@ module GraphQL
         def self.from_a(filename, line, col, name, type, directives, selections)
           self.new(filename: filename, line: line, col: col, name: name, type: type, directives: directives, selections: selections)
         end
+
+        def marshal_dump
+          [line, col, @filename, @name, @type, @directives, @selections]
+        end
+
+        def marshal_load(values)
+          @line, @col, @filename, @name, @type, @directives, @selections = values
+        end
       end
 
       # Application of a named fragment in a selection

data/lib/graphql/language/parser.rb

@@ -36,6 +36,7 @@ module GraphQL
         @filename = filename
         @trace = trace
         @dedup_identifiers = false
+        @lines_at = nil
       end
 
       def parse
@@ -48,9 +49,43 @@ module GraphQL
         end
       end
 
+      def line_at(pos)
+        line = lines_at.bsearch_index { |l| l >= pos }
+        if line.nil?
+          @lines_at.size + 1
+        else
+          line + 1
+        end
+      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
+        else
+          pos + 1
+        end
+      end
 
       private
 
+      # @return [Array<Integer>] Positions of each line break in the original string
+      def lines_at
+        @lines_at ||= begin
+          la = []
+          idx = 0
+          while idx
+            idx = @graphql_str.index("\n", idx)
+            if idx
+              la << idx
+              idx += 1
+            end
+          end
+          la
+        end
+      end
+
       attr_reader :token_name
 
       def advance_token
@@ -73,7 +108,7 @@ module GraphQL
         while !@lexer.eos?
           defns << definition
         end
-        Document.new(pos: 0, definitions: defns, filename: @filename, source_string: @graphql_str)
+        Document.new(pos: 0, definitions: defns, filename: @filename, source: self)
       end
 
       def definition
@@ -95,7 +130,7 @@ module GraphQL
             directives: directives,
             selections: selections,
             filename: @filename,
-            source_string: @graphql_str
+            source: self
           )
         when :QUERY, :MUTATION, :SUBSCRIPTION, :LCURLY
           op_loc = pos
@@ -131,7 +166,7 @@ module GraphQL
                 default_value: default_value,
                 directives: directives,
                 filename: @filename,
-                source_string: @graphql_str
+                source: self
               )
             end
             expect_token(:RPAREN)
@@ -150,7 +185,7 @@ module GraphQL
             directives: directives,
             selections: selection_set,
             filename: @filename,
-            source_string: @graphql_str
+            source: self
           )
         when :EXTEND
           loc = pos
@@ -160,7 +195,7 @@ module GraphQL
             advance_token
             name = parse_name
             directives = parse_directives
-            ScalarTypeExtension.new(pos: loc, name: name, directives: directives, filename: @filename, source_string: @graphql_str)
+            ScalarTypeExtension.new(pos: loc, name: name, directives: directives, filename: @filename, source: self)
           when :TYPE
             advance_token
             name = parse_name
@@ -168,32 +203,32 @@ module GraphQL
             directives = parse_directives
             field_defns = at?(:LCURLY) ? parse_field_definitions : EMPTY_ARRAY
 
-            ObjectTypeExtension.new(pos: loc, name: name, interfaces: implements_interfaces, directives: directives, fields: field_defns, filename: @filename, source_string: @graphql_str)
+            ObjectTypeExtension.new(pos: loc, name: name, interfaces: implements_interfaces, directives: directives, fields: field_defns, filename: @filename, source: self)
           when :INTERFACE
             advance_token
             name = parse_name
             directives = parse_directives
             interfaces = parse_implements
             fields_definition = at?(:LCURLY) ? parse_field_definitions : EMPTY_ARRAY
-            InterfaceTypeExtension.new(pos: loc, name: name, directives: directives, fields: fields_definition, interfaces: interfaces, filename: @filename, source_string: @graphql_str)
+            InterfaceTypeExtension.new(pos: loc, name: name, directives: directives, fields: fields_definition, interfaces: interfaces, filename: @filename, source: self)
           when :UNION
             advance_token
             name = parse_name
             directives = parse_directives
             union_member_types = parse_union_members
-            UnionTypeExtension.new(pos: loc, name: name, directives: directives, types: union_member_types, filename: @filename, source_string: @graphql_str)
+            UnionTypeExtension.new(pos: loc, name: name, directives: directives, types: union_member_types, filename: @filename, source: self)
           when :ENUM
             advance_token
             name = parse_name
             directives = parse_directives
             enum_values_definition = parse_enum_value_definitions
-            Nodes::EnumTypeExtension.new(pos: loc, name: name, directives: directives, values: enum_values_definition, filename: @filename, source_string: @graphql_str)
+            Nodes::EnumTypeExtension.new(pos: loc, name: name, directives: directives, values: enum_values_definition, filename: @filename, source: self)
           when :INPUT
             advance_token
             name = parse_name
             directives = parse_directives
             input_fields_definition = parse_input_object_field_definitions
-            InputObjectTypeExtension.new(pos: loc, name: name, directives: directives, fields: input_fields_definition, filename: @filename, source_string: @graphql_str)
+            InputObjectTypeExtension.new(pos: loc, name: name, directives: directives, fields: input_fields_definition, filename: @filename, source: self)
           when :SCHEMA
             advance_token
             directives = parse_directives
@@ -226,7 +261,7 @@ module GraphQL
               directives: directives,
               pos: loc,
               filename: @filename,
-              source_string: @graphql_str,
+              source: self,
             )
           else
             expect_one_of([:SCHEMA, :SCALAR, :TYPE, :ENUM, :INPUT, :UNION, :INTERFACE])
@@ -259,7 +294,7 @@ module GraphQL
               end
             end
             expect_token :RCURLY
-            SchemaDefinition.new(pos: loc, definition_pos: defn_loc, query: query, mutation: mutation, subscription: subscription, directives: directives, filename: @filename, source_string: @graphql_str)
+            SchemaDefinition.new(pos: loc, definition_pos: defn_loc, query: query, mutation: mutation, subscription: subscription, directives: directives, filename: @filename, source: self)
           when :DIRECTIVE
             advance_token
             expect_token :DIR_SIGN
@@ -272,12 +307,12 @@ module GraphQL
               false
             end
             expect_token :ON
-            directive_locations = [DirectiveLocation.new(pos: pos, name: parse_name, filename: @filename, source_string: @graphql_str)]
+            directive_locations = [DirectiveLocation.new(pos: pos, name: parse_name, filename: @filename, source: self)]
             while at?(:PIPE)
               advance_token
-              directive_locations << DirectiveLocation.new(pos: pos, name: parse_name, filename: @filename, source_string: @graphql_str)
+              directive_locations << DirectiveLocation.new(pos: pos, name: parse_name, filename: @filename, source: self)
             end
-            DirectiveDefinition.new(pos: loc, definition_pos: defn_loc, description: desc, name: name, arguments: arguments_definition, locations: directive_locations, repeatable: repeatable, filename: @filename, source_string: @graphql_str)
+            DirectiveDefinition.new(pos: loc, definition_pos: defn_loc, description: desc, name: name, arguments: arguments_definition, locations: directive_locations, repeatable: repeatable, filename: @filename, source: self)
           when :TYPE
             advance_token
             name = parse_name
@@ -285,37 +320,37 @@ module GraphQL
             directives = parse_directives
             field_defns = at?(:LCURLY) ? parse_field_definitions : EMPTY_ARRAY
 
-            ObjectTypeDefinition.new(pos: loc, definition_pos: defn_loc, description: desc, name: name, interfaces: implements_interfaces, directives: directives, fields: field_defns, filename: @filename, source_string: @graphql_str)
+            ObjectTypeDefinition.new(pos: loc, definition_pos: defn_loc, description: desc, name: name, interfaces: implements_interfaces, directives: directives, fields: field_defns, filename: @filename, source: self)
           when :INTERFACE
             advance_token
             name = parse_name
             interfaces = parse_implements
             directives = parse_directives
             fields_definition = parse_field_definitions
-            InterfaceTypeDefinition.new(pos: loc, definition_pos: defn_loc, description: desc, name: name, directives: directives, fields: fields_definition, interfaces: interfaces, filename: @filename, source_string: @graphql_str)
+            InterfaceTypeDefinition.new(pos: loc, definition_pos: defn_loc, description: desc, name: name, directives: directives, fields: fields_definition, interfaces: interfaces, filename: @filename, source: self)
           when :UNION
             advance_token
             name = parse_name
             directives = parse_directives
             union_member_types = parse_union_members
-            UnionTypeDefinition.new(pos: loc, definition_pos: defn_loc, description: desc, name: name, directives: directives, types: union_member_types, filename: @filename, source_string: @graphql_str)
+            UnionTypeDefinition.new(pos: loc, definition_pos: defn_loc, description: desc, name: name, directives: directives, types: union_member_types, filename: @filename, source: self)
           when :SCALAR
             advance_token
             name = parse_name
             directives = parse_directives
-            ScalarTypeDefinition.new(pos: loc, definition_pos: defn_loc, description: desc, name: name, directives: directives, filename: @filename, source_string: @graphql_str)
+            ScalarTypeDefinition.new(pos: loc, definition_pos: defn_loc, description: desc, name: name, directives: directives, filename: @filename, source: self)
           when :ENUM
             advance_token
             name = parse_name
             directives = parse_directives
             enum_values_definition = parse_enum_value_definitions
-            Nodes::EnumTypeDefinition.new(pos: loc, definition_pos: defn_loc, description: desc, name: name, directives: directives, values: enum_values_definition, filename: @filename, source_string: @graphql_str)
+            Nodes::EnumTypeDefinition.new(pos: loc, definition_pos: defn_loc, description: desc, name: name, directives: directives, values: enum_values_definition, filename: @filename, source: self)
           when :INPUT
             advance_token
             name = parse_name
             directives = parse_directives
             input_fields_definition = parse_input_object_field_definitions
-            InputObjectTypeDefinition.new(pos: loc, definition_pos: defn_loc, description: desc, name: name, directives: directives, fields: input_fields_definition, filename: @filename, source_string: @graphql_str)
+            InputObjectTypeDefinition.new(pos: loc, definition_pos: defn_loc, description: desc, name: name, directives: directives, fields: input_fields_definition, filename: @filename, source: self)
           else
             expect_one_of([:SCHEMA, :SCALAR, :TYPE, :ENUM, :INPUT, :UNION, :INTERFACE])
           end
@@ -346,7 +381,7 @@ module GraphQL
             defn_loc = pos
             enum_value = parse_enum_name
             v_directives = parse_directives
-            list << EnumValueDefinition.new(pos: v_loc, definition_pos: defn_loc, description: description, name: enum_value, directives: v_directives, filename: @filename, source_string: @graphql_str)
+            list << EnumValueDefinition.new(pos: v_loc, definition_pos: defn_loc, description: description, name: enum_value, directives: v_directives, filename: @filename, source: self)
           end
           expect_token :RCURLY
           list
@@ -397,7 +432,7 @@ module GraphQL
           type = self.type
           directives = parse_directives
 
-          list << FieldDefinition.new(pos: loc, definition_pos: defn_loc, description: description, name: name, arguments: arguments_definition, type: type, directives: directives, filename: @filename, source_string: @graphql_str)
+          list << FieldDefinition.new(pos: loc, definition_pos: defn_loc, description: description, name: name, arguments: arguments_definition, type: type, directives: directives, filename: @filename, source: self)
         end
         expect_token :RCURLY
         list
@@ -431,7 +466,7 @@ module GraphQL
           nil
         end
         directives = parse_directives
-        InputValueDefinition.new(pos: loc, definition_pos: defn_loc, description: description, name: name, type: type, default_value: default_value, directives: directives, filename: @filename, source_string: @graphql_str)
+        InputValueDefinition.new(pos: loc, definition_pos: defn_loc, description: description, name: name, type: type, default_value: default_value, directives: directives, filename: @filename, source: self)
       end
 
       def type
@@ -443,7 +478,7 @@ module GraphQL
         end
 
         if at?(:BANG)
-          type = Nodes::NonNullType.new(pos: pos, of_type: type)
+          type = Nodes::NonNullType.new(pos: pos, of_type: type, source: self)
           expect_token(:BANG)
         end
         type
@@ -452,7 +487,7 @@ module GraphQL
       def list_type
         loc = pos
         expect_token(:LBRACKET)
-        type = Nodes::ListType.new(pos: loc, of_type: self.type)
+        type = Nodes::ListType.new(pos: loc, of_type: self.type, source: self)
         expect_token(:RBRACKET)
         type
       end
@@ -489,7 +524,7 @@ module GraphQL
 
               directives = parse_directives
 
-              Nodes::InlineFragment.new(pos: loc, type: if_type, directives: directives, selections: selection_set, filename: @filename, source_string: @graphql_str)
+              Nodes::InlineFragment.new(pos: loc, type: if_type, directives: directives, selections: selection_set, filename: @filename, source: self)
             else
               name = parse_name_without_on
               directives = parse_directives
@@ -497,7 +532,7 @@ module GraphQL
               # Can this ever happen?
               # expect_token(:IDENTIFIER) if at?(:ON)
 
-              FragmentSpread.new(pos: loc, name: name, directives: directives, filename: @filename, source_string: @graphql_str)
+              FragmentSpread.new(pos: loc, name: name, directives: directives, filename: @filename, source: self)
             end
           else
             loc = pos
@@ -515,7 +550,7 @@ module GraphQL
             directives = at?(:DIR_SIGN) ? parse_directives : nil
             selection_set = at?(:LCURLY) ? self.selection_set : nil
 
-            Nodes::Field.new(pos: loc, field_alias: field_alias, name: name, arguments: arguments, directives: directives, selections: selection_set, filename: @filename, source_string: @graphql_str)
+            Nodes::Field.new(pos: loc, field_alias: field_alias, name: name, arguments: arguments, directives: directives, selections: selection_set, filename: @filename, source: self)
           end
         end
         expect_token(:RCURLY)
@@ -609,7 +644,7 @@ module GraphQL
       end
 
       def parse_type_name
-        TypeName.new(pos: pos, name: parse_name, filename: @filename, source_string: @graphql_str)
+        TypeName.new(pos: pos, name: parse_name, filename: @filename, source: self)
       end
 
       def parse_directives
@@ -621,7 +656,7 @@ module GraphQL
             name = parse_name
             arguments = parse_arguments
 
-            dirs << Nodes::Directive.new(pos: loc, name: name, arguments: arguments, filename: @filename, source_string: @graphql_str)
+            dirs << Nodes::Directive.new(pos: loc, name: name, arguments: arguments, filename: @filename, source: self)
           end
           dirs
         else
@@ -637,7 +672,7 @@ module GraphQL
             loc = pos
             name = parse_name
             expect_token(:COLON)
-            args << Nodes::Argument.new(pos: loc, name: name, value: value, filename: @filename, source_string: @graphql_str)
+            args << Nodes::Argument.new(pos: loc, name: name, value: value, filename: @filename, source: self)
           end
           if args.empty?
             expect_token(:ARGUMENT_NAME) # At least one argument is required
@@ -671,9 +706,9 @@ module GraphQL
           false
         when :NULL
           advance_token
-          NullValue.new(pos: pos, name: "null", filename: @filename, source_string: @graphql_str)
+          NullValue.new(pos: pos, name: "null", filename: @filename, source: self)
         when :IDENTIFIER
-          Nodes::Enum.new(pos: pos, name: expect_token_value(:IDENTIFIER), filename: @filename, source_string: @graphql_str)
+          Nodes::Enum.new(pos: pos, name: expect_token_value(:IDENTIFIER), filename: @filename, source: self)
         when :LBRACKET
           advance_token
           list = []
@@ -690,14 +725,14 @@ module GraphQL
             loc = pos
             n = parse_name
             expect_token(:COLON)
-            args << Argument.new(pos: loc, name: n, value: value, filename: @filename, source_string: @graphql_str)
+            args << Argument.new(pos: loc, name: n, value: value, filename: @filename, source: self)
           end
           expect_token(:RCURLY)
-          InputObject.new(pos: start, arguments: args, filename: @filename, source_string: @graphql_str)
+          InputObject.new(pos: start, arguments: args, filename: @filename, source: self)
         when :VAR_SIGN
           loc = pos
           advance_token
-          VariableIdentifier.new(pos: loc, name: parse_name, filename: @filename, source_string: @graphql_str)
+          VariableIdentifier.new(pos: loc, name: parse_name, filename: @filename, source: self)
         else
           expect_token(:VALUE)
         end

data/lib/graphql/query.rb

@@ -304,7 +304,7 @@ module GraphQL
 
     # @return [String] An opaque hash for identifying this query's given query string and selected operation
     def operation_fingerprint
-      @operation_fingerprint ||= "#{selected_operation_name || "anonymous"}/#{Fingerprint.generate(query_string)}"
+      @operation_fingerprint ||= "#{selected_operation_name || "anonymous"}/#{Fingerprint.generate(query_string || "")}"
     end
 
     # @return [String] An opaque hash for identifying this query's given a variable values (not including defaults)

data/lib/graphql/schema.rb

@@ -749,9 +749,10 @@ module GraphQL
 
       attr_writer :max_complexity
 
-      def max_complexity(max_complexity = nil)
+      def max_complexity(max_complexity = nil, count_introspection_fields: true)
         if max_complexity
           @max_complexity = max_complexity
+          @max_complexity_count_introspection_fields = count_introspection_fields
         elsif defined?(@max_complexity)
           @max_complexity
         else
@@ -759,6 +760,14 @@ module GraphQL
         end
       end
 
+      def max_complexity_count_introspection_fields
+        if defined?(@max_complexity_count_introspection_fields)
+          @max_complexity_count_introspection_fields
+        else
+          find_inherited_value(:max_complexity_count_introspection_fields, true)
+        end
+      end
+
       attr_writer :analysis_engine
 
       def analysis_engine

data/lib/graphql/tracing/prometheus_trace.rb

@@ -25,33 +25,33 @@ module GraphQL
       }.each do |trace_method, platform_key|
         module_eval <<-RUBY, __FILE__, __LINE__
           def #{trace_method}(**data)
-            instrument_execution("#{platform_key}", "#{trace_method}") { super }
+            instrument_prometheus_execution("#{platform_key}", "#{trace_method}") { super }
           end
         RUBY
       end
 
       def platform_execute_field(platform_key, &block)
-        instrument_execution(platform_key, "execute_field", &block)
+        instrument_prometheus_execution(platform_key, "execute_field", &block)
       end
 
       def platform_execute_field_lazy(platform_key, &block)
-        instrument_execution(platform_key, "execute_field_lazy", &block)
+        instrument_prometheus_execution(platform_key, "execute_field_lazy", &block)
       end
 
       def platform_authorized(platform_key, &block)
-        instrument_execution(platform_key, "authorized", &block)
+        instrument_prometheus_execution(platform_key, "authorized", &block)
       end
 
       def platform_authorized_lazy(platform_key, &block)
-        instrument_execution(platform_key, "authorized_lazy", &block)
+        instrument_prometheus_execution(platform_key, "authorized_lazy", &block)
       end
 
       def platform_resolve_type(platform_key, &block)
-        instrument_execution(platform_key, "resolve_type", &block)
+        instrument_prometheus_execution(platform_key, "resolve_type", &block)
       end
 
       def platform_resolve_type_lazy(platform_key, &block)
-        instrument_execution(platform_key, "resolve_type_lazy", &block)
+        instrument_prometheus_execution(platform_key, "resolve_type_lazy", &block)
       end
 
       def platform_field_key(field)
@@ -68,7 +68,7 @@ module GraphQL
 
       private
 
-      def instrument_execution(platform_key, key, &block)
+      def instrument_prometheus_execution(platform_key, key, &block)
         if @keys_whitelist.include?(key)
           start = ::Process.clock_gettime ::Process::CLOCK_MONOTONIC
           result = block.call

data/lib/graphql/tracing/sentry_trace.rb

@@ -12,7 +12,7 @@ module GraphQL
         @set_transaction_name = set_transaction_name
         super
       end
-      
+
       def execute_query(**data)
         set_this_txn_name = data[:query].context[:set_sentry_transaction_name]
         if set_this_txn_name == true || (set_this_txn_name.nil? && @set_transaction_name)
@@ -20,7 +20,7 @@ module GraphQL
             scope.set_transaction_name(transaction_name(data[:query]))
           end
         end
-        instrument_execution("graphql.execute", "execute_query", data) { super }
+        instrument_sentry_execution("graphql.execute", "execute_query", data) { super }
       end
 
       {
@@ -34,33 +34,33 @@ module GraphQL
       }.each do |trace_method, platform_key|
         module_eval <<-RUBY, __FILE__, __LINE__
         def #{trace_method}(**data)
-          instrument_execution("#{platform_key}", "#{trace_method}", data) { super }
+          instrument_sentry_execution("#{platform_key}", "#{trace_method}", data) { super }
         end
         RUBY
       end
 
       def platform_execute_field(platform_key, &block)
-        instrument_execution(platform_key, "execute_field", &block)
+        instrument_sentry_execution(platform_key, "execute_field", &block)
       end
 
       def platform_execute_field_lazy(platform_key, &block)
-        instrument_execution(platform_key, "execute_field_lazy", &block)
+        instrument_sentry_execution(platform_key, "execute_field_lazy", &block)
       end
 
       def platform_authorized(platform_key, &block)
-        instrument_execution(platform_key, "authorized", &block)
+        instrument_sentry_execution(platform_key, "authorized", &block)
       end
 
       def platform_authorized_lazy(platform_key, &block)
-        instrument_execution(platform_key, "authorized_lazy", &block)
+        instrument_sentry_execution(platform_key, "authorized_lazy", &block)
       end
 
       def platform_resolve_type(platform_key, &block)
-        instrument_execution(platform_key, "resolve_type", &block)
+        instrument_sentry_execution(platform_key, "resolve_type", &block)
       end
 
       def platform_resolve_type_lazy(platform_key, &block)
-        instrument_execution(platform_key, "resolve_type_lazy", &block)
+        instrument_sentry_execution(platform_key, "resolve_type_lazy", &block)
       end
 
       def platform_field_key(field)
@@ -77,7 +77,7 @@ module GraphQL
 
       private
 
-      def instrument_execution(platform_key, trace_method, data=nil, &block)
+      def instrument_sentry_execution(platform_key, trace_method, data=nil, &block)
         return yield unless Sentry.initialized?
 
         Sentry.with_child_span(op: platform_key, start_timestamp: Sentry.utc_now.to_f) do |span|

data/lib/graphql/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: graphql
 version: !ruby/object:Gem::Version
-  version: 2.3.2
+  version: 2.3.4
 platform: ruby
 authors:
 - Robert Mosolgo
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-04-26 00:00:00.000000000 Z
+date: 2024-05-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64