graphql 1.13.19 → 2.0.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c21327429549138738debab2d522197133548eb4b275a5f67086154e08469149
-  data.tar.gz: ec61107f4f45aaf1de25c6674d7fcf3b8e19b1245fdbf2a1bd1b0f7f1dd9b0aa
+  metadata.gz: 0e3f276db828fe3908e759e87f8cc5d33ae761c3ea80bd53b92b16a971ef507a
+  data.tar.gz: fc59e806f45125da3065ed4d7758170f88231377664b9a130e0896d6b2790fa3
 SHA512:
-  metadata.gz: 5b56c3aaa86b6d758b53d49a7906de483375c54f40db9126b96d791f41c7bba6407d9b59205a4d47215cef1391cd5ebbc03d5eb76825747cbfc1d0f6baf1f0ef
-  data.tar.gz: 7f7cb3b2e4fa8c26b355ea4adf01803ab32e2d97036475469071e2cf67d06431ab0486f0daf8ab28433deb95bb8642ea0a2b52739abe6d0ad06bb22b4fdcb2cc
+  metadata.gz: 580e967d89228c0174072f5857cb646ea7495ee5a00587249ffc3034ffe9b536f751c09b8112e443b0c93efcd868db01c584497364897d23c7e798ee3f496d64
+  data.tar.gz: 43db761134f0ea83311f6a8b62b3b34b9dccdc335869c9067f43dcc5b9fc7f4023b77b8bb70cf203435ac25711d16d0ce5aa620478d351950d0db9f2e7bee9c7

data/lib/generators/graphql/install_generator.rb

@@ -47,7 +47,7 @@ module Graphql
     #
     # Accept a `--batch` option which adds `GraphQL::Batch` setup.
     #
-    # Use `--no-graphiql` to skip `graphiql-rails` installation.
+    # Use `--skip-graphiql` to skip `graphiql-rails` installation.
     #
     # TODO: also add base classes
     class InstallGenerator < Rails::Generators::Base

data/lib/generators/graphql/relay.rb

@@ -33,27 +33,13 @@ module Graphql
   # Return a string UUID for `object`
   def self.id_from_object(object, type_definition, query_ctx)
     # For example, use Rails' GlobalID library (https://github.com/rails/globalid):
-    object_id = object.to_global_id.to_s
-    # Remove this redundant prefix to make IDs shorter:
-    object_id = object_id.sub("gid://\#{GlobalID.app}/", "")
-    encoded_id = Base64.urlsafe_encode64(object_id)
-    # Remove the "=" padding
-    encoded_id = encoded_id.sub(/=+/, "")
-    # Add a type hint
-    type_hint = type_definition.graphql_name.first
-    "\#{type_hint}_\#{encoded_id}"
+    object.to_gid_param
   end
 
   # Given a string UUID, find the object
-  def self.object_from_id(encoded_id_with_hint, query_ctx)
+  def self.object_from_id(global_id, query_ctx)
     # For example, use Rails' GlobalID library (https://github.com/rails/globalid):
-    # Split off the type hint
-    _type_hint, encoded_id = encoded_id_with_hint.split("_", 2)
-    # Decode the ID
-    id = Base64.urlsafe_decode64(encoded_id)
-    # Rebuild it for Rails then find the object:
-    full_global_id = "gid://\#{GlobalID.app}/\#{id}"
-    GlobalID::Locator.locate(full_global_id)
+    GlobalID.find(global_id)
   end
 RUBY
         inject_into_file schema_file_path, schema_code, before: /^end\n/m, force: false

data/lib/generators/graphql/templates/schema.erb

@@ -23,5 +23,8 @@ class <%= schema_name %> < GraphQL::Schema
     # to return the correct GraphQL object type for `obj`
     raise(GraphQL::RequiredImplementationMissingError)
   end
+
+  # Stop validating when it encounters this many errors:
+  validate_max_errors(100)
 end
 <% end -%>

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

@@ -39,9 +39,11 @@ module GraphQL
               @used_deprecated_arguments << argument.definition.path
             end
 
+            next if argument.value.nil?
+
             if argument.definition.type.kind.input_object?
               extract_deprecated_arguments(argument.value.arguments.argument_values) # rubocop:disable Development/ContextIsPassedCop -- runtime args instance
-            elsif argument.definition.type.list? && !argument.value.nil?
+            elsif argument.definition.type.list?
               argument
                 .value
                 .select { |value| value.respond_to?(:arguments) }

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

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-require_relative "./query_complexity"
 module GraphQL
   module Analysis
     module AST

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

@@ -5,7 +5,7 @@ module GraphQL
     module AST
       class QueryComplexity < Analyzer
         # State for the query complexity calculation:
-        # - `complexities_on_type` holds complexity scores for each type in an IRep node
+        # - `complexities_on_type` holds complexity scores for each type
         def initialize(query)
           super
           @complexities_on_type_by_query = {}

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

@@ -15,7 +15,6 @@ module GraphQL
     #   # In your Schema file:
     #
     #   class MySchema < GraphQL::Schema
-    #     use GraphQL::Analysis::AST
     #     query_analyzer LogQueryDepth
     #   end
     #

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

@@ -43,7 +43,7 @@ module GraphQL
 
         # Visit Helpers
 
-        # @return [GraphQL::Query::Arguments] Arguments for this node, merging default values, literal values and query variables
+        # @return [GraphQL::Execution::Interpreter::Arguments] Arguments for this node, merging default values, literal values and query variables
         # @see {GraphQL::Query#arguments_for}
         def arguments_for(ast_node, field_definition)
           @query.arguments_for(ast_node, field_definition)
@@ -65,14 +65,41 @@ module GraphQL
         end
 
         # Visitor Hooks
+        [
+          :operation_definition, :fragment_definition,
+          :inline_fragment, :field, :directive, :argument, :fragment_spread
+        ].each do |node_type|
+          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
+            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
+            end
+          end
+
+          RUBY
+        end
 
         def on_operation_definition(node, parent)
           object_type = @schema.root_type_for_operation(node.operation_type)
           @object_types.push(object_type)
           @path.push("#{node.operation_type}#{node.name ? " #{node.name}" : ""}")
-          call_analyzers(:on_enter_operation_definition, node, parent)
+          call_on_enter_operation_definition(node, parent)
           super
-          call_analyzers(:on_leave_operation_definition, node, parent)
+          call_on_leave_operation_definition(node, parent)
           @object_types.pop
           @path.pop
         end
@@ -81,19 +108,19 @@ module GraphQL
           on_fragment_with_type(node) do
             @path.push("fragment #{node.name}")
             @in_fragment_def = false
-            call_analyzers(:on_enter_fragment_definition, node, parent)
+            call_on_enter_fragment_definition(node, parent)
             super
             @in_fragment_def = false
-            call_analyzers(:on_leave_fragment_definition, node, parent)
+            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}" : ""}")
-            call_analyzers(:on_enter_inline_fragment, node, parent)
+            call_on_enter_inline_fragment(node, parent)
             super
-            call_analyzers(:on_leave_inline_fragment, node, parent)
+            call_on_leave_inline_fragment(node, parent)
           end
         end
 
@@ -114,12 +141,10 @@ module GraphQL
           @skipping = @skip_stack.last || skip?(node)
           @skip_stack << @skipping
 
-          call_analyzers(:on_enter_field, node, parent)
+          call_on_enter_field(node, parent)
           super
-
           @skipping = @skip_stack.pop
-
-          call_analyzers(:on_leave_field, node, parent)
+          call_on_leave_field(node, parent)
           @response_path.pop
           @field_definitions.pop
           @object_types.pop
@@ -129,9 +154,9 @@ module GraphQL
         def on_directive(node, parent)
           directive_defn = @schema.directives[node.name]
           @directive_definitions.push(directive_defn)
-          call_analyzers(:on_enter_directive, node, parent)
+          call_on_enter_directive(node, parent)
           super
-          call_analyzers(:on_leave_directive, node, parent)
+          call_on_leave_directive(node, parent)
           @directive_definitions.pop
         end
 
@@ -153,29 +178,23 @@ module GraphQL
 
           @argument_definitions.push(argument_defn)
           @path.push(node.name)
-          call_analyzers(:on_enter_argument, node, parent)
+          call_on_enter_argument(node, parent)
           super
-          call_analyzers(:on_leave_argument, node, parent)
+          call_on_leave_argument(node, parent)
           @argument_definitions.pop
           @path.pop
         end
 
         def on_fragment_spread(node, parent)
           @path.push("... #{node.name}")
-          call_analyzers(:on_enter_fragment_spread, node, parent)
+          call_on_enter_fragment_spread(node, parent)
           enter_fragment_spread_inline(node)
           super
           leave_fragment_spread_inline(node)
-          call_analyzers(:on_leave_fragment_spread, node, parent)
+          call_on_leave_fragment_spread(node, parent)
           @path.pop
         end
 
-        def on_abstract_node(node, parent)
-          call_analyzers(:on_enter_abstract_node, node, parent)
-          super
-          call_analyzers(:on_leave_abstract_node, node, parent)
-        end
-
         # @return [GraphQL::BaseType] The current object type
         def type_definition
           @object_types.last
@@ -226,9 +245,7 @@ module GraphQL
 
           object_types << object_type
 
-          fragment_def.selections.each do |selection|
-            visit_node(selection, fragment_def)
-          end
+          on_fragment_definition_children(fragment_def)
         end
 
         # Visit a fragment spread inline instead of visiting the definition
@@ -242,16 +259,6 @@ module GraphQL
           dir.any? && !GraphQL::Execution::DirectiveChecks.include?(dir, query)
         end
 
-        def call_analyzers(method, node, parent)
-          @analyzers.each do |analyzer|
-            begin
-              analyzer.public_send(method, node, parent, self)
-            rescue AnalysisError => err
-              @rescued_errors << err
-            end
-          end
-        end
-
         def on_fragment_with_type(node)
           object_type = if node.type
             @query.warden.get_type(node.type.name)

data/lib/graphql/analysis/ast.rb

@@ -11,16 +11,6 @@ module GraphQL
   module Analysis
     module AST
       module_function
-
-      def use(schema_class)
-        if schema_class.analysis_engine == self
-          definition_line = caller(2, 1).first
-          GraphQL::Deprecation.warn("GraphQL::Analysis::AST is now the default; remove `use GraphQL::Analysis::AST` from the schema definition (#{definition_line})")
-        else
-          schema_class.analysis_engine = self
-        end
-      end
-
       # Analyze a multiplex, and all queries within.
       # Multiplex analyzers are ran for all queries, keeping state.
       # Query analyzers are ran per query, without carrying state between queries.
@@ -31,7 +21,7 @@ module GraphQL
       def analyze_multiplex(multiplex, analyzers)
         multiplex_analyzers = analyzers.map { |analyzer| analyzer.new(multiplex) }
 
-        multiplex.trace("analyze_multiplex", { multiplex: multiplex }) do
+        multiplex.current_trace.analyze_multiplex(multiplex: multiplex) do
           query_results = multiplex.queries.map do |query|
             if query.valid?
               analyze_query(
@@ -58,7 +48,7 @@ module GraphQL
       # @param analyzers [Array<GraphQL::Analysis::AST::Analyzer>]
       # @return [Array<Any>] Results from those analyzers
       def analyze_query(query, analyzers, multiplex_analyzers: [])
-        query.trace("analyze_query", { query: query }) do
+        query.current_trace.analyze_query(query: query) do
           query_analyzers = analyzers
             .map { |analyzer| analyzer.new(query) }
             .select { |analyzer| analyzer.analyze? }

data/lib/graphql/analysis.rb

@@ -1,9 +1,2 @@
 # frozen_string_literal: true
 require "graphql/analysis/ast"
-require "graphql/analysis/max_query_complexity"
-require "graphql/analysis/max_query_depth"
-require "graphql/analysis/query_complexity"
-require "graphql/analysis/query_depth"
-require "graphql/analysis/reducer_state"
-require "graphql/analysis/analyze_query"
-require "graphql/analysis/field_usage"

data/lib/graphql/backtrace/table.rb

@@ -83,7 +83,7 @@ module GraphQL
           value = if top && @override_value
             @override_value
           else
-            value_at(@context.query.context.namespace(:interpreter)[:runtime], context_entry.path)
+            value_at(@context.query.context.namespace(:interpreter_runtime)[:runtime], context_entry.path)
           end
           rows << [
             "#{context_entry.ast_node ? context_entry.ast_node.position.join(":") : ""}",
@@ -97,24 +97,6 @@ module GraphQL
           else
             rows
           end
-        when GraphQL::Query::Context::FieldResolutionContext
-          ctx = context_entry
-          field_name = "#{ctx.irep_node.owner_type.name}.#{ctx.field.name}"
-          position = "#{ctx.ast_node.line}:#{ctx.ast_node.col}"
-          field_alias = ctx.ast_node.alias
-          object = ctx.object
-          if object.is_a?(GraphQL::Schema::Object)
-            object = object.object
-          end
-          rows << [
-            "#{position}",
-            "#{field_name}#{field_alias ? " as #{field_alias}" : ""}",
-            "#{object.inspect}",
-            ctx.irep_node.arguments.to_h.inspect,
-            Backtrace::InspectResult.inspect_result(top && @override_value ? @override_value : ctx.value),
-          ]
-
-          build_rows(ctx.parent, rows: rows)
         when GraphQL::Query::Context
           query = context_entry.query
           op = query.selected_operation
@@ -130,7 +112,7 @@ module GraphQL
           if object.is_a?(GraphQL::Schema::Object)
             object = object.object
           end
-          value = value_at(context_entry.namespace(:interpreter)[:runtime], [])
+          value = value_at(context_entry.namespace(:interpreter_runtime)[:runtime], [])
           rows << [
             "#{position}",
             "#{op_type}#{op_name ? " #{op_name}" : ""}",

data/lib/graphql/backtrace/tracer.rb

@@ -23,9 +23,9 @@ module GraphQL
             push_data = multiplex.queries.first
           end
         when "execute_field", "execute_field_lazy"
-          query = metadata[:query] || raise(ArgumentError, "Add `legacy: true` to use GraphQL::Backtrace without the interpreter runtime.")
+          query = metadata[:query]
           multiplex = query.multiplex
-          push_key = metadata[:path]
+          push_key = query.context[:current_path]
           parent_frame = multiplex.context[:graphql_backtrace_contexts][push_key[0..-2]]
 
           if parent_frame.is_a?(GraphQL::Query)
@@ -62,7 +62,6 @@ module GraphQL
             potential_context = multiplex_context[:last_graphql_backtrace_context]
 
             if potential_context.is_a?(GraphQL::Query::Context) ||
-                potential_context.is_a?(GraphQL::Query::Context::FieldResolutionContext) ||
                 potential_context.is_a?(Backtrace::Frame)
               raise TracedError.new(err, potential_context)
             else

data/lib/graphql/backtrace.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 require "graphql/backtrace/inspect_result"
-require "graphql/backtrace/legacy_tracer"
 require "graphql/backtrace/table"
 require "graphql/backtrace/traced_error"
 require "graphql/backtrace/tracer"
@@ -23,13 +22,8 @@ module GraphQL
 
     def_delegators :to_a, :each, :[]
 
-    def self.use(schema_defn, legacy: false)
-      tracer = if legacy
-        self::LegacyTracer
-      else
-        self::Tracer
-      end
-      schema_defn.tracer(tracer)
+    def self.use(schema_defn)
+      schema_defn.tracer(self::Tracer)
     end
 
     def initialize(context, value: nil)

data/lib/graphql/dataloader/null_dataloader.rb

@@ -11,7 +11,9 @@ module GraphQL
       # executed sychronously.
       def run; end
       def run_isolated; yield; end
-      def yield; end
+      def yield
+        raise GraphQL::Error, "GraphQL::Dataloader is not running -- add `use GraphQL::Dataloader` to your schema to use Dataloader sources."
+      end
 
       def append_job
         yield

data/lib/graphql/dataloader/source.rb

@@ -86,6 +86,15 @@ module GraphQL
         !@pending_keys.empty?
       end
 
+      # Add these key-value pairs to this source's cache
+      # (future loads will use these merged values).
+      # @param results [Hash<Object => Object>] key-value pairs to cache in this source
+      # @return [void]
+      def merge(results)
+        @results.merge!(results)
+        nil
+      end
+
       # Called by {GraphQL::Dataloader} to resolve and pending requests to this source.
       # @api private
       # @return [void]

data/lib/graphql/dataloader.rb

@@ -289,7 +289,10 @@ module GraphQL
       fiber_locals = {}
 
       Thread.current.keys.each do |fiber_var_key|
-        fiber_locals[fiber_var_key] = Thread.current[fiber_var_key]
+        # This variable should be fresh in each new fiber
+        if fiber_var_key != :__graphql_runtime_info
+          fiber_locals[fiber_var_key] = Thread.current[fiber_var_key]
+        end
       end
 
       if @nonblocking

data/lib/graphql/dig.rb

@@ -2,7 +2,7 @@
 module GraphQL
   module Dig
     # implemented using the old activesupport #dig instead of the ruby built-in
-    # so we can use some of the magic in Schema::InputObject and Query::Arguments
+    # so we can use some of the magic in Schema::InputObject and Interpreter::Arguments
     # to handle stringified/symbolized keys.
     #
     # @param args [Array<[String, Symbol>] Retrieves the value object corresponding to the each key objects repeatedly

data/lib/graphql/execution/errors.rb

@@ -2,59 +2,15 @@
 
 module GraphQL
   module Execution
-    # A plugin that wraps query execution with error handling.
-    # Supports class-based schemas and the new {Interpreter} runtime only.
-    #
-    # @example Handling ActiveRecord::NotFound
-    #
-    #   class MySchema < GraphQL::Schema
-    #     use GraphQL::Execution::Errors
-    #
-    #     rescue_from(ActiveRecord::NotFound) do |err, obj, args, ctx, field|
-    #       ErrorTracker.log("Not Found: #{err.message}")
-    #       nil
-    #     end
-    #   end
-    #
     class Errors
-      def self.use(schema)
-        definition_line = caller(2, 1).first
-        GraphQL::Deprecation.warn("GraphQL::Execution::Errors is now installed by default, remove `use GraphQL::Execution::Errors` from #{definition_line}")
-      end
-
-      NEW_HANDLER_HASH = ->(h, k) {
-        h[k] = {
-          class: k,
-          handler: nil,
-          subclass_handlers: Hash.new(&NEW_HANDLER_HASH),
-         }
-      }
-
-      def initialize(schema)
-        @schema = schema
-        @handlers = {
-          class: nil,
-          handler: nil,
-          subclass_handlers: Hash.new(&NEW_HANDLER_HASH),
-        }
-      end
-
-      # @api private
-      def each_rescue
-        handlers = @handlers.values
-        while (handler = handlers.shift) do
-          yield(handler[:class], handler[:handler])
-          handlers.concat(handler[:subclass_handlers].values)
-        end
-      end
-
       # Register this handler, updating the
       # internal handler index to maintain least-to-most specific.
       #
       # @param error_class [Class<Exception>]
+      # @param error_handlers [Hash]
       # @param error_handler [Proc]
       # @return [void]
-      def rescue_from(error_class, error_handler)
+      def self.register_rescue_from(error_class, error_handlers, error_handler)
         subclasses_handlers = {}
         this_level_subclasses = []
         # During this traversal, do two things:
@@ -62,13 +18,12 @@ module GraphQL
         #   and gather them up to be inserted _under_ this class
         # - Find the point in the index where this handler should be inserted
         #   (That is, _under_ any superclasses, or at top-level, if there are no superclasses registered)
-        handlers = @handlers[:subclass_handlers]
-        while (handlers) do
+        while (error_handlers) do
           this_level_subclasses.clear
           # First, identify already-loaded handlers that belong
           # _under_ this one. (That is, they're handlers
           # for subclasses of `error_class`.)
-          handlers.each do |err_class, handler|
+          error_handlers.each do |err_class, handler|
             if err_class < error_class
               subclasses_handlers[err_class] = handler
               this_level_subclasses << err_class
@@ -76,13 +31,13 @@ module GraphQL
           end
           # Any handlers that we'll be moving, delete them from this point in the index
           this_level_subclasses.each do |err_class|
-            handlers.delete(err_class)
+            error_handlers.delete(err_class)
           end
 
           # See if any keys in this hash are superclasses of this new class:
-          next_index_point = handlers.find { |err_class, handler| error_class < err_class }
+          next_index_point = error_handlers.find { |err_class, handler| error_class < err_class }
           if next_index_point
-            handlers = next_index_point[1][:subclass_handlers]
+            error_handlers = next_index_point[1][:subclass_handlers]
           else
             # this new handler doesn't belong to any sub-handlers,
             # so insert it in the current set of `handlers`
@@ -91,40 +46,15 @@ module GraphQL
         end
         # Having found the point at which to insert this handler,
         # register it and merge any subclass handlers back in at this point.
-        this_class_handlers = handlers[error_class]
+        this_class_handlers = error_handlers[error_class]
         this_class_handlers[:handler] = error_handler
         this_class_handlers[:subclass_handlers].merge!(subclasses_handlers)
         nil
       end
 
-      # Call the given block with the schema's configured error handlers.
-      #
-      # If the block returns a lazy value, it's not wrapped with error handling. That area will have to be wrapped itself.
-      #
-      # @param ctx [GraphQL::Query::Context]
-      # @return [Object] Either the result of the given block, or some object to replace the result, in case of error handling.
-      def with_error_handling(ctx)
-        yield
-      rescue StandardError => err
-        handler = find_handler_for(err.class)
-        if handler
-          runtime_info = ctx.namespace(:interpreter) || {}
-          obj = runtime_info[:current_object]
-          args = runtime_info[:current_arguments]
-          args = args && args.keyword_arguments
-          field = runtime_info[:current_field]
-          if obj.is_a?(GraphQL::Schema::Object)
-            obj = obj.object
-          end
-          handler[:handler].call(err, obj, args, ctx, field)
-        else
-          raise err
-        end
-      end
-
       # @return [Proc, nil] The handler for `error_class`, if one was registered on this schema or inherited
-      def find_handler_for(error_class)
-        handlers = @handlers[:subclass_handlers]
+      def self.find_handler_for(schema, error_class)
+        handlers = schema.error_handlers[:subclass_handlers]
         handler = nil
         while (handlers) do
           _err_class, next_handler = handlers.find { |err_class, handler| error_class <= err_class }
@@ -139,8 +69,8 @@ module GraphQL
         end
 
         # check for a handler from a parent class:
-        if @schema.superclass.respond_to?(:error_handler) && (parent_errors = @schema.superclass.error_handler)
-          parent_handler = parent_errors.find_handler_for(error_class)
+        if schema.superclass.respond_to?(:error_handlers)
+          parent_handler = find_handler_for(schema.superclass, error_class)
         end
 
         # If the inherited handler is more specific than the one defined here,

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

@@ -11,6 +11,25 @@ module GraphQL
           nil
         end
 
+        def self.resolve_each_depth(lazies_at_depth, dataloader)
+          depths = lazies_at_depth.keys
+          depths.sort!
+          next_depth = depths.first
+          if next_depth
+            lazies = lazies_at_depth[next_depth]
+            lazies_at_depth.delete(next_depth)
+            if lazies.any?
+              dataloader.append_job {
+                lazies.each(&:value) # resolve these Lazy instances
+              }
+              # Run lazies _and_ dataloader, see if more are enqueued
+              dataloader.run
+              resolve_each_depth(lazies_at_depth, dataloader)
+            end
+          end
+          nil
+        end
+
         # After getting `results` back from an interpreter evaluation,
         # continue it until you get a response-ready Ruby value.
         #
@@ -59,6 +78,13 @@ module GraphQL
           end
 
           if next_results.any?
+            # Any pending data loader jobs may populate the
+            # resutl arrays or result hashes accumulated in
+            # `next_results``. Run those **to completion**
+            # before continuing to resolve `next_results`.
+            # (Just `.append_job` doesn't work if any pending
+            # jobs require multiple passes.)
+            dataloader.run
             dataloader.append_job { resolve(next_results, dataloader) }
           end