lib/graphql/batch/loader.rb in graphql-batch-0.3.5 vs lib/graphql/batch/loader.rb in graphql-batch-0.3.7

@@ -10,14 +10,11 @@
         raise NoExecutorError, "Cannot create loader without an Executor."\
           " Wrap the call to `for` with `GraphQL::Batch.batch` or use"\
           " `GraphQL::Batch::Setup` as a query instrumenter if using with `graphql-ruby`"
       end
 
-      executor.loaders[loader_key] ||= new(*group_args).tap do |loader|
-        loader.loader_key = loader_key
-        loader.executor = executor
-      end
+      executor.loader(loader_key) { new(*group_args) }
     end
 
     def self.loader_key_for(*group_args)
       [self].concat(group_args)
     end
@@ -33,11 +30,11 @@
     attr_accessor :loader_key, :executor
 
     def load(key)
       cache[cache_key(key)] ||= begin
         queue << key
-        Promise.new.tap { |promise| promise.source = self }
+        ::Promise.new.tap { |promise| promise.source = self }
       end
     end
 
     def load_many(keys)
       ::Promise.all(keys.map { |key| load(key) })
@@ -48,13 +45,11 @@
       load_keys = queue
       @queue = nil
       perform(load_keys)
       check_for_broken_promises(load_keys)
     rescue => err
-      each_pending_promise(load_keys) do |key, promise|
-        promise.reject(err)
-      end
+      reject_pending_promises
     end
 
     # For Promise#sync
     def wait #:nodoc:
       if executor
@@ -70,13 +65,21 @@
 
     protected
 
     # Fulfill the key with provided value, for use in #perform
     def fulfill(key, value)
-      promise_for(key).fulfill(value)
+      finish_resolve(key) do |promise|
+        promise.fulfill(value)
+      end
     end
 
+    def reject(key, reason)
+      finish_resolve(key) do |promise|
+        promise.reject(reason)
+      end
+    end
+
     # Returns true when the key has already been fulfilled, otherwise returns false
     def fulfilled?(key)
       promise_for(key).fulfilled?
     end
 
@@ -90,10 +93,18 @@
       load_key
     end
 
     private
 
+    def finish_resolve(key)
+      promise = promise_for(key)
+      return yield(promise) unless executor
+      executor.around_promise_callbacks do
+        yield promise
+      end
+    end
+
     def cache
       @cache ||= {}
     end
 
     def queue
@@ -102,21 +113,19 @@
 
     def promise_for(load_key)
       cache.fetch(cache_key(load_key))
     end
 
-    def each_pending_promise(load_keys)
+    def reject_pending_promises
       load_keys.each do |key|
-        promise = promise_for(key)
-        if promise.pending?
-          yield key, promise
-        end
+        # promise.rb ignores reject if promise isn't pending
+        reject(key, err)
       end
     end
 
     def check_for_broken_promises(load_keys)
-      each_pending_promise(load_keys) do |key, promise|
-        promise.reject(::Promise::BrokenError.new("#{self.class} didn't fulfill promise for key #{key.inspect}"))
+      load_keys.each do |key|
+        reject(key, ::Promise::BrokenError.new("#{self.class} didn't fulfill promise for key #{key.inspect}"))
       end
     end
   end
 end