Hack something that works

Author: rmosolgo

lib/graphql/dataloader.rb

@@ -77,6 +77,17 @@ def append_job(&job)
       nil
     end
 
+    # Use a self-contained queue for the work in the block.
+    def run_contained
+      prev_queue = @pending_jobs
+      @pending_jobs = []
+      res = yield
+      run
+      res
+    ensure
+      @pending_jobs = prev_queue
+    end
+
     # @api private Move along, move along
     def run
       # At a high level, the algorithm is:
@@ -224,16 +235,16 @@ def resume(fiber)
     #
     # @see https://github.com/rmosolgo/graphql-ruby/issues/3449
     def spawn_fiber
-      fiber_locals = {} 
+      fiber_locals = {}
 
       Thread.current.keys.each do |fiber_var_key|
         fiber_locals[fiber_var_key] = Thread.current[fiber_var_key]
-      end 
+      end
 
-      Fiber.new do 
+      Fiber.new do
         fiber_locals.each { |k, v| Thread.current[k] = v }
         yield
-      end 
+      end
     end
   end
 end

lib/graphql/dataloader/null_dataloader.rb

@@ -10,6 +10,7 @@ class NullDataloader < Dataloader
       # These are all no-ops because code was
       # executed sychronously.
       def run; end
+      def run_contained; yield; end
       def yield; end
 
       def append_job

lib/graphql/execution/interpreter/arguments_cache.rb

@@ -28,11 +28,12 @@ def initialize(query)
         end
 
         def fetch(ast_node, argument_owner, parent_object)
-          @storage[ast_node][argument_owner][parent_object]
           # If any jobs were enqueued, run them now,
           # since this might have been called outside of execution.
           # (The jobs are responsible for updating `result` in-place.)
-          @dataloader.run
+          @dataloader.run_contained do
+            @storage[ast_node][argument_owner][parent_object]
+          end
           # Ack, the _hash_ is updated, but the key is eventually
           # overridden with an immutable arguments instance.
           # The first call queues up the job,

lib/graphql/execution/interpreter/runtime.rb

@@ -629,7 +629,7 @@ def run_directive(object, ast_node, idx, &block)
             if !dir_defn.is_a?(Class)
               dir_defn = dir_defn.type_class || raise("Only class-based directives are supported (not `@#{dir_node.name}`)")
             end
-            dir_args = arguments(nil, dir_defn, dir_node).keyword_arguments
+            dir_args = arguments(nil, dir_defn, dir_node)
             dir_defn.resolve(object, dir_args, context) do
               run_directive(object, ast_node, idx + 1, &block)
             end
@@ -640,7 +640,7 @@ def run_directive(object, ast_node, idx, &block)
         def directives_include?(node, graphql_object, parent_type)
           node.directives.each do |dir_node|
             dir_defn = schema.directives.fetch(dir_node.name).type_class || raise("Only class-based directives are supported (not #{dir_node.name.inspect})")
-            args = arguments(graphql_object, dir_defn, dir_node).keyword_arguments
+            args = arguments(graphql_object, dir_defn, dir_node)
             if !dir_defn.include?(graphql_object, args, context)
               return false
             end

spec/graphql/schema/directive_spec.rb

@@ -87,17 +87,14 @@ class CountFields < GraphQL::Schema::Directive
 
       def self.resolve(obj, args, ctx)
         path = ctx[:current_path]
-        p [:fetched_path, path]
-        result = yield
-
-        p [:resolve_all, path]
-        GraphQL::Execution::Interpreter::Resolve.resolve_all([result], ctx.dataloader)
-        p [:run_dataloader, path]
-        ctx.dataloader.run
+        result = nil
+        ctx.dataloader.run_contained do
+          result = yield
+          GraphQL::Execution::Interpreter::Resolve.resolve_all([result], ctx.dataloader)
+        end
 
         ctx[:count_fields] ||= Hash.new { |h, k| h[k] = [] }
         field_count = result.is_a?(Hash) ? result.size : 1
-        p [path, field_count, result]
         ctx[:count_fields][path] << field_count
         nil # this does nothing
       end
@@ -150,7 +147,6 @@ class Schema < GraphQL::Schema
   end
 
   describe "runtime directives" do
-    focus
     it "works with fragment spreads, inline fragments, and fields" do
       query_str = <<-GRAPHQL
       {