Hack and hack until the nested load test passes

Author: rmosolgo

lib/graphql/dataloader.rb

@@ -8,6 +8,7 @@ def self.use(schema)
         dataloader_class: self,
       )
       schema.instrument(:multiplex, instrumenter)
+      schema.lazy_resolve(Dataloader::Loader::PendingLoad, :sync)
       # TODO clean this up when we can assume it's a class-based schema
       if !schema.is_a?(Class)
         schema = schema.target.class

lib/graphql/dataloader/loader.rb

@@ -3,6 +3,89 @@
 module GraphQL
   class Dataloader
     class Loader
+      # TODO: this is basically a reimplementation of Promise.rb
+      # Should I just take on that dependency, or is there a value in a
+      # custom implementation?
+      class PendingLoad
+        attr_writer :loaded
+        attr_reader :pending_thens
+
+        def initialize(loader, key)
+          @loader = loader
+          @key = key
+          @loaded = false
+          @pending_thens = []
+        end
+
+        def sync
+          if !@loaded
+            @loaded = true
+            if @loader.nil?
+              binding.pry
+            end
+            @loader.sync
+          end
+          @loader.fulfilled_value_for(@key)
+        end
+
+        def value
+          if !@fully_loaded
+            @fully_loaded = true
+            v = sync
+            if v.is_a?(PendingLoad)
+              v = v.value
+            end
+            @fully_loaded_value = v
+          end
+          @fully_loaded_value
+        end
+
+        def then(&next_block)
+          pending_then = ThenBlock.new(self, next_block)
+          if !@loaded
+            @pending_thens << pending_then
+          end
+          pending_then
+        end
+      end
+
+      class ThenBlock < PendingLoad
+        def initialize(pending_load, then_block)
+          @pending_load = pending_load
+          @then_block = then_block
+          @loaded = false
+          @pending_thens = []
+          @value = nil
+        end
+
+        def sync
+          if !@loaded
+            @loaded = true
+            @value = @then_block.call(@pending_load.sync)
+            @pending_thens.each(&:sync)
+          end
+          @value
+        end
+      end
+
+      class AllPendingLoads < PendingLoad
+        def initialize(pending_loads)
+          @loaded = false
+          @value = nil
+          @pending_loads = pending_loads
+          @pending_thens = []
+        end
+
+        def sync
+          if !@loaded
+            @loaded = true
+            @value = @pending_loads.map(&:sync)
+            @pending_thens.each(&:sync)
+          end
+          @value
+        end
+      end
+
       def self.load(context, *key, value)
         self.for(context, *key).load(value)
       end
@@ -13,7 +96,8 @@ def self.for(context, *key_parts)
       end
 
       def self.load_all(context, key, values)
-        GraphQL::Execution::Lazy.all(values.map { |value| load(context, key, value) })
+        pending_loads = values.map { |value| load(context, key, value) }
+        AllPendingLoads.new(pending_loads)
       end
 
       def initialize(context, *key)
@@ -23,14 +107,8 @@ def initialize(context, *key)
         @loaded_values = {}
       end
 
-      def load(value)
-        @promises[value] ||= GraphQL::Execution::Lazy.new do
-          if !@loaded_values.key?(value)
-            sync
-          end
-          # TODO raise if key is missing?
-          @loaded_values[value]
-        end
+      def load(key)
+        @promises[key] ||= PendingLoad.new(self, key)
       end
 
       def sync
@@ -42,12 +120,20 @@ def sync
 
       def fulfill(key, value)
         @loaded_values[key] = value
+        @promises[key].loaded = true
+        @promises[key].pending_thens.each(&:sync)
+        value
       end
 
       def fulfilled?(key)
         @loaded_values.key?(key)
       end
 
+      def fulfilled_value_for(key)
+        # TODO raise if not loaded?
+        @loaded_values[key]
+      end
+
       def perform(values)
         raise NotImplementedError, "`#{self.class}#perform` should load `values` for `@key` and return an item for each of `values`"
       end

spec/graphql/dataloader/batch_compat_spec.rb

@@ -186,9 +186,10 @@ def images
         variant_image_queries = variants.map do |variant|
           AssociationLoader.for(context, ProductVariant, :images).load(variant)
         end
-        GraphQL::Execution::Lazy.all(variant_image_queries).then(&:flatten)
+        # TODO this is not good -- needs a good public API
+        GraphQL::Dataloader::Loader::AllPendingLoads.new(variant_image_queries).then(&:flatten)
       end
-      GraphQL::Execution::Lazy.all([product_image_query, variant_images_query]).then do
+      GraphQL::Dataloader::Loader::AllPendingLoads.new([product_image_query, variant_images_query]).then do
         [product_image_query.value] + variant_images_query.value
       end
     end

spec/graphql/dataloader_spec.rb

@@ -33,6 +33,7 @@ def self.load_object(ctx, id)
       end
 
       def perform(ids)
+        ids = ids.sort # for stable logging
         Backend.mget(ids).each_with_index do |item, idx|
           fulfill(ids[idx], item)
         end
@@ -80,7 +81,7 @@ def author(id:)
         end
 
         def books_count(author_id:)
-          # Of course this could be done without a load, but I want to test nested loaders
+          # Of course this could be done without a nested load, but I want to test nested loaders
           BackendLoader.load_object(@context, author_id).then do |author|
             BackendLoader.load_all(@context, nil, author[:book_ids]).then do |books|
               books.size
@@ -166,7 +167,7 @@ def exec_query(*args)
     }')
 
     expected_log = [
-      'MGET ["b1", "a1"]',
+      'MGET ["a1", "b1"]',
       'MGET ["b2"]'
     ]
     assert_equal expected_log, log