Use a queue for execution

benchmark/batch_loading.rb

@@ -63,9 +63,7 @@ def initialize(options = {column: :id})
 
       def fetch(keys)
         keys.map { |key|
-          d = GraphQLBatchSchema::DATA.find { |d| d[@column] == key }
-          # p [key, @column, d]
-          d
+          GraphQLBatchSchema::DATA.find { |d| d[@column] == key }
         }
       end
     end

lib/graphql/dataloader.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "graphql/dataloader/flat_dataloader"
 require "graphql/dataloader/null_dataloader"
 require "graphql/dataloader/request"
 require "graphql/dataloader/request_all"
@@ -65,8 +66,13 @@ def initialize(nonblocking: self.class.default_nonblocking, fiber_limit: self.cl
       end
       @fiber_limit = fiber_limit
       @lazies_at_depth = Hash.new { |h, k| h[k] = [] }
+      @steps_to_rerun_after_lazy = []
     end
 
+    attr_accessor :lazies_at_depth
+
+    attr_reader :steps_to_rerun_after_lazy
+
     # @return [Integer, nil]
     attr_reader :fiber_limit
 
@@ -216,6 +222,31 @@ def run(trace_query_lazy: nil)
               run_pending_steps(trace, job_fibers, next_job_fibers, jobs_fiber_limit, source_fibers, next_source_fibers, total_fiber_limit)
             end
           end
+
+          if !@lazies_at_depth.empty?
+            smallest_depth = nil
+            @lazies_at_depth.each_key do |depth_key|
+              smallest_depth ||= depth_key
+              if depth_key < smallest_depth
+                smallest_depth = depth_key
+              end
+            end
+
+            if smallest_depth
+              lazies = @lazies_at_depth.delete(smallest_depth)
+              if !lazies.empty?
+                append_job {
+                  lazies.each(&:value) # resolve these Lazy instances
+                }
+                job_fibers << spawn_job_fiber(trace)
+              end
+            end
+          elsif !@steps_to_rerun_after_lazy.empty?
+            @pending_jobs.concat(@steps_to_rerun_after_lazy)
+            f = spawn_job_fiber(trace)
+            job_fibers << f
+            @steps_to_rerun_after_lazy.clear
+          end
         end
 
         trace&.end_dataloader(self)

lib/graphql/dataloader/flat_dataloader.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Dataloader
+    class FlatDataloader < Dataloader
+      def initialize(*)
+        # TODO unify the initialization lazies_at_depth
+        @lazies_at_depth ||= Hash.new { |h, k| h[k] = [] }
+        @steps_to_rerun_after_lazy = []
+        @queue = []
+      end
+
+      def run(trace_query_lazy: nil)
+        while @queue.any?
+          while (step = @queue.shift)
+            step.call
+          end
+
+          while @lazies_at_depth&.any?
+            smallest_depth = nil
+            @lazies_at_depth.each_key do |depth_key|
+              smallest_depth ||= depth_key
+              if depth_key < smallest_depth
+                smallest_depth = depth_key
+              end
+            end
+
+            if smallest_depth
+              with_trace_query_lazy(trace_query_lazy) do
+                lazies = @lazies_at_depth.delete(smallest_depth)
+                lazies.each(&:value) # resolve these Lazy instances
+              end
+            end
+          end
+
+          if @steps_to_rerun_after_lazy.any?
+            current_srrl = @steps_to_rerun_after_lazy.dup
+            @steps_to_rerun_after_lazy.clear
+            current_srrl.each(&:call)
+          end
+        end
+      end
+
+      def run_isolated
+        prev_queue = @queue
+        prev_stral = @steps_to_rerun_after_lazy
+        prev_lad = @lazies_at_depth
+        @steps_to_rerun_after_lazy = []
+        @queue = []
+        @lazies_at_depth = @lazies_at_depth.dup&.clear
+        res = nil
+        append_job {
+          res = yield
+        }
+        run
+        res
+      ensure
+        @queue = prev_queue
+        @steps_to_rerun_after_lazy = prev_stral
+        @lazies_at_depth = prev_lad
+      end
+
+      def clear_cache; end
+
+      def yield(_source)
+        raise GraphQL::Error, "GraphQL::Dataloader is not running -- add `use GraphQL::Dataloader` to your schema to use Dataloader sources."
+      end
+
+      def append_job(callable = nil, &block)
+        @queue << (callable || block)
+        nil
+      end
+
+      def with(*)
+        raise GraphQL::Error, "GraphQL::Dataloader is not running -- add `use GraphQL::Dataloader` to your schema to use Dataloader sources."
+      end
+    end
+  end
+end

lib/graphql/execution/interpreter.rb

@@ -5,7 +5,6 @@
 require "graphql/execution/interpreter/arguments_cache"
 require "graphql/execution/interpreter/execution_errors"
 require "graphql/execution/interpreter/runtime"
-require "graphql/execution/interpreter/resolve"
 require "graphql/execution/interpreter/handles_raw_value"
 
 module GraphQL
@@ -111,7 +110,6 @@ def run_all(schema, query_options, context: {}, max_complexity: schema.max_compl
                   end
 
                   result["data"] = query.context.namespace(:interpreter_runtime)[:runtime].final_result
-
                   result
                 end
                 if query.context.namespace?(:__query_result_extensions__)