Clean up lazies_at_depth, DRY FlatDataloader

Author: rmosolgo

lib/graphql/dataloader.rb

@@ -65,11 +65,9 @@ def initialize(nonblocking: self.class.default_nonblocking, fiber_limit: self.cl
         @nonblocking = nonblocking
       end
       @fiber_limit = fiber_limit
-      @lazies_at_depth = nil
+      @lazies_at_depth = Hash.new { |h, k| h[k] = [] }
     end
 
-    attr_accessor :lazies_at_depth
-
     # @return [Integer, nil]
     attr_reader :fiber_limit
 
@@ -164,6 +162,8 @@ def clear_cache
     def run_isolated
       prev_queue = @pending_jobs
       prev_pending_keys = {}
+      prev_lazies_at_depth = @lazies_at_depth
+      @lazies_at_depth = @lazies_at_depth.dup.clear
       @source_cache.each do |source_class, batched_sources|
         batched_sources.each do |batch_args, batched_source_instance|
           if batched_source_instance.pending?
@@ -183,6 +183,7 @@ def run_isolated
       res
     ensure
       @pending_jobs = prev_queue
+      @lazies_at_depth = prev_lazies_at_depth
       prev_pending_keys.each do |source_instance, pending|
         pending.each do |key, value|
           if !source_instance.results.key?(key)
@@ -194,8 +195,6 @@ def run_isolated
 
     # @param trace_query_lazy [nil, Execution::Multiplex]
     def run(trace_query_lazy: nil)
-      # TODO unify the initialization lazies_at_depth
-      @lazies_at_depth ||= Hash.new { |h, k| h[k] = [] }
       trace = Fiber[:__graphql_current_multiplex]&.current_trace
       jobs_fiber_limit, total_fiber_limit = calculate_fiber_limit
       job_fibers = []

lib/graphql/dataloader/async_dataloader.rb

@@ -15,8 +15,6 @@ def yield(source = Fiber[:__graphql_current_dataloader_source])
       end
 
       def run(trace_query_lazy: nil)
-        # TODO unify the initialization lazies_at_depth
-        @lazies_at_depth ||= Hash.new { |h, k| h[k] = [] }
         trace = Fiber[:__graphql_current_multiplex]&.current_trace
         jobs_fiber_limit, total_fiber_limit = calculate_fiber_limit
         job_fibers = []

lib/graphql/dataloader/flat_dataloader.rb

@@ -2,48 +2,24 @@
 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] = [] }
-        @queue = []
-      end
-
       def run(trace_query_lazy: nil)
-        while !@queue.empty?
+        while !@pending_jobs.empty?
           run_pending_steps
           with_trace_query_lazy(trace_query_lazy) do
-            while @lazies_at_depth&.any?
+            while !@lazies_at_depth.empty?
               run_next_pending_lazies
               run_pending_steps
             end
           end
         end
       end
 
-      def run_isolated
-        prev_queue = @queue
-        prev_lad = @lazies_at_depth
-        @queue = []
-        @lazies_at_depth = @lazies_at_depth.dup&.clear
-        res = nil
-        append_job {
-          res = yield
-        }
-        run
-        res
-      ensure
-        @queue = prev_queue
-        @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)
+        @pending_jobs << (callable || block)
         nil
       end
 
@@ -69,7 +45,7 @@ def run_next_pending_lazies
       end
 
       def run_pending_steps
-        while (step = @queue.shift)
+        while (step = @pending_jobs.shift)
           step.call
         end
       end

lib/graphql/execution/interpreter.rb

@@ -41,8 +41,6 @@ def run_all(schema, query_options, context: {}, max_complexity: schema.max_compl
           trace.execute_multiplex(multiplex: multiplex) do
             schema = multiplex.schema
             queries = multiplex.queries
-            lazies_at_depth = Hash.new { |h, k| h[k] = [] }
-            multiplex.dataloader.lazies_at_depth = lazies_at_depth
             multiplex_analyzers = schema.multiplex_analyzers
             if multiplex.max_complexity
               multiplex_analyzers += [GraphQL::Analysis::MaxQueryComplexity]
@@ -73,7 +71,7 @@ def run_all(schema, query_options, context: {}, max_complexity: schema.max_compl
                       # Although queries in a multiplex _share_ an Interpreter instance,
                       # they also have another item of state, which is private to that query
                       # in particular, assign it here:
-                      runtime = Runtime.new(query: query, lazies_at_depth: lazies_at_depth)
+                      runtime = Runtime.new(query: query)
                       query.context.namespace(:interpreter_runtime)[:runtime] = runtime
 
                       query.current_trace.execute_query(query: query) do

lib/graphql/execution/interpreter/runtime.rb

@@ -35,7 +35,7 @@ def current_object
         # @return [GraphQL::Query::Context]
         attr_reader :context
 
-        def initialize(query:, lazies_at_depth:)
+        def initialize(query:)
           @query = query
           @current_trace = query.current_trace
           @dataloader = query.multiplex.dataloader