graphql 1.12.0 → 1.12.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 433f1170eb17ab192761efcd8c27cf9efe5f952ab47b501baca270e33d6007cd
-  data.tar.gz: c56045f746385ae37ebd0f82116aad10782e9265c13e0e85e39488ef3db02c74
+  metadata.gz: 4ec7a782dba5df306d3e0590820d75d520b86651b9293417b115070057c45b8f
+  data.tar.gz: 731f02ddfda3690ecd54cba1b1f373f9c8a53b65d422f853d44ddc9072fa85d7
 SHA512:
-  metadata.gz: 6d580c78b6b659602067fcfd3043eff7ef2b20da1d50c1ca2b234614d864e1a232cb65e7456cfdf85764523f30bd5232823ea19b4664208aef875cc68e2e5fc9
-  data.tar.gz: 172bc16fadfeee1f022646498dd2ce359bd885fb96ddbeeab50f7583d27811501e583194dd582a7cf47d63545c2fe00c4fa4625b6b247155f537ff4a6de60ac1
+  metadata.gz: e0783dea9b65037ea2d92b9ab88fc98153a541b0821f7b5d38bb53de3d33024a85d626302c8c92ddc9971606806c1a7896fb7a98da0c8c2261f9a034d87624e2
+  data.tar.gz: c4b6035220bf578fc974a3fa437914dd5e652018b651b0c5af57f355e5d08b113a2faa2a6824242b71d01bab844767592f4d6ea5323e66e2ef05bcd74ad62df3

data/lib/generators/graphql/install_generator.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
+require 'rails/generators'
 require 'rails/generators/base'
 require_relative 'core'
+require_relative 'relay'
 
 module Graphql
   module Generators
@@ -50,6 +52,7 @@ module Graphql
     # TODO: also add base classes
     class InstallGenerator < Rails::Generators::Base
       include Core
+      include Relay
 
       desc "Install GraphQL folder structure and boilerplate code"
       source_root File.expand_path('../templates', __FILE__)
@@ -164,7 +167,7 @@ RUBY
         end
 
         if options[:relay]
-          generate("graphql:relay")
+          install_relay
         end
 
         if gemfile_modified?

data/lib/generators/graphql/loader_generator.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require 'rails/generators'
 require "rails/generators/named_base"
 require_relative "core"
 

data/lib/generators/graphql/mutation_generator.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require 'rails/generators'
 require 'rails/generators/named_base'
 require_relative 'core'
 

data/lib/generators/graphql/relay.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+module Graphql
+  module Generators
+    module Relay
+      def install_relay
+        # Add Node, `node(id:)`, and `nodes(ids:)`
+        template("node_type.erb", "#{options[:directory]}/types/node_type.rb")
+        in_root do
+          fields = "    # Add `node(id: ID!) and `nodes(ids: [ID!]!)`\n    include GraphQL::Types::Relay::HasNodeField\n    include GraphQL::Types::Relay::HasNodesField\n\n"
+          inject_into_file "#{options[:directory]}/types/query_type.rb", fields, after: /class .*QueryType\s*<\s*[^\s]+?\n/m, force: false
+        end
+
+        # Add connections and edges
+        template("base_connection.erb", "#{options[:directory]}/types/base_connection.rb")
+        template("base_edge.erb", "#{options[:directory]}/types/base_edge.rb")
+        connectionable_type_files = {
+          "#{options[:directory]}/types/base_object.rb" => /class .*BaseObject\s*<\s*[^\s]+?\n/m,
+          "#{options[:directory]}/types/base_union.rb" =>  /class .*BaseUnion\s*<\s*[^\s]+?\n/m,
+          "#{options[:directory]}/types/base_interface.rb" => /include GraphQL::Schema::Interface\n/m,
+        }
+        in_root do
+          connectionable_type_files.each do |type_class_file, sentinel|
+            inject_into_file type_class_file, "    connection_type_class(Types::BaseConnection)\n", after: sentinel, force: false
+            inject_into_file type_class_file, "    edge_type_class(Types::BaseEdge)\n", after: sentinel, force: false
+          end
+        end
+
+        # Add object ID hooks & connection plugin
+        schema_code = <<-RUBY
+
+  # Relay-style Object Identification:
+
+  # Return a string UUID for `object`
+  def self.id_from_object(object, type_definition, query_ctx)
+    # Here's a simple implementation which:
+    # - joins the type name & object.id
+    # - encodes it with base64:
+    # GraphQL::Schema::UniqueWithinType.encode(type_definition.name, object.id)
+  end
+
+  # Given a string UUID, find the object
+  def self.object_from_id(id, query_ctx)
+    # For example, to decode the UUIDs generated above:
+    # type_name, item_id = GraphQL::Schema::UniqueWithinType.decode(id)
+    #
+    # Then, based on `type_name` and `id`
+    # find an object in your application
+    # ...
+  end
+RUBY
+        inject_into_file schema_file_path, schema_code, before: /^end\n/m, force: false
+      end
+    end
+  end
+end

data/lib/generators/graphql/relay_generator.rb

@@ -1,62 +1,20 @@
 # frozen_string_literal: true
+require 'rails/generators'
 require 'rails/generators/base'
 require_relative 'core'
+require_relative 'relay'
 
 module Graphql
   module Generators
     class RelayGenerator < Rails::Generators::Base
       include Core
+      include Relay
 
       desc "Add base types and fields for Relay-style nodes and connections"
       source_root File.expand_path('../templates', __FILE__)
 
       def install_relay
-        # Add Node, `node(id:)`, and `nodes(ids:)`
-        template("node_type.erb", "#{options[:directory]}/types/node_type.rb")
-        in_root do
-          fields = "    # Add `node(id: ID!) and `nodes(ids: [ID!]!)`\n    include GraphQL::Types::Relay::HasNodeField\n    include GraphQL::Types::Relay::HasNodesField\n\n"
-          inject_into_file "#{options[:directory]}/types/query_type.rb", fields, after: /class .*QueryType\s*<\s*[^\s]+?\n/m, force: false
-        end
-
-        # Add connections and edges
-        template("base_connection.erb", "#{options[:directory]}/types/base_connection.rb")
-        template("base_edge.erb", "#{options[:directory]}/types/base_edge.rb")
-        connectionable_type_files = {
-          "#{options[:directory]}/types/base_object.rb" => /class .*BaseObject\s*<\s*[^\s]+?\n/m,
-          "#{options[:directory]}/types/base_union.rb" =>  /class .*BaseUnion\s*<\s*[^\s]+?\n/m,
-          "#{options[:directory]}/types/base_interface.rb" => /include GraphQL::Schema::Interface\n/m,
-        }
-        in_root do
-          connectionable_type_files.each do |type_class_file, sentinel|
-            inject_into_file type_class_file, "    connection_type_class(Types::BaseConnection)\n", after: sentinel, force: false
-            inject_into_file type_class_file, "    edge_type_class(Types::BaseEdge)\n", after: sentinel, force: false
-          end
-        end
-
-        # Add object ID hooks & connection plugin
-        schema_code = <<-RUBY
-
-  # Relay-style Object Identification:
-
-  # Return a string UUID for `object`
-  def self.id_from_object(object, type_definition, query_ctx)
-    # Here's a simple implementation which:
-    # - joins the type name & object.id
-    # - encodes it with base64:
-    # GraphQL::Schema::UniqueWithinType.encode(type_definition.name, object.id)
-  end
-
-  # Given a string UUID, find the object
-  def self.object_from_id(id, query_ctx)
-    # For example, to decode the UUIDs generated above:
-    # type_name, item_id = GraphQL::Schema::UniqueWithinType.decode(id)
-    #
-    # Then, based on `type_name` and `id`
-    # find an object in your application
-    # ...
-  end
-RUBY
-        inject_into_file schema_file_path, schema_code, before: /^end\n/m, force: false
+        super
       end
     end
   end

data/lib/generators/graphql/type_generator.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+require 'rails/generators'
 require 'rails/generators/base'
 require 'graphql'
 require 'active_support'

data/lib/graphql.rb

@@ -128,6 +128,7 @@ require "graphql/schema/printer"
 require "graphql/filter"
 require "graphql/internal_representation"
 require "graphql/static_validation"
+require "graphql/dataloader"
 require "graphql/introspection"
 
 require "graphql/analysis_error"
@@ -148,8 +149,7 @@ require "graphql/authorization"
 require "graphql/unauthorized_error"
 require "graphql/unauthorized_field_error"
 require "graphql/load_application_object_failed_error"
-require "graphql/dataloader"
-
+require "graphql/deprecation"
 
 module GraphQL
   # Ruby has `deprecate_constant`,

data/lib/graphql/analysis/analyze_query.rb

@@ -43,7 +43,7 @@ module GraphQL
     # @param analyzers [Array<#call>] Objects that respond to `#call(memo, visit_type, irep_node)`
     # @return [Array<Any>] Results from those analyzers
     def analyze_query(query, analyzers, multiplex_states: [])
-      warn "Legacy analysis will be removed in GraphQL-Ruby 2.0, please upgrade to AST Analysis: https://graphql-ruby.org/queries/ast_analysis.html (schema: #{query.schema})"
+      GraphQL::Deprecation.warn "Legacy analysis will be removed in GraphQL-Ruby 2.0, please upgrade to AST Analysis: https://graphql-ruby.org/queries/ast_analysis.html (schema: #{query.schema})"
 
       query.trace("analyze_query", { query: query }) do
         analyzers_to_run = analyzers.select do |analyzer|

data/lib/graphql/analysis/ast.rb

@@ -15,7 +15,7 @@ module GraphQL
       def use(schema_class)
         if schema_class.analysis_engine == self
           definition_line = caller(2, 1).first
-          warn("GraphQL::Analysis::AST is now the default; remove `use GraphQL::Analysis::AST` from the schema definition (#{definition_line})")
+          GraphQL::Deprecation.warn("GraphQL::Analysis::AST is now the default; remove `use GraphQL::Analysis::AST` from the schema definition (#{definition_line})")
         else
           schema_class.analysis_engine = self
         end

data/lib/graphql/backtrace/inspect_result.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# test_via: ../backtrace.rb
 module GraphQL
   class Backtrace
     module InspectResult

data/lib/graphql/backtrace/table.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# test_via: ../backtrace.rb
 module GraphQL
   class Backtrace
     # A class for turning a context into a human-readable table or array

data/lib/graphql/backtrace/traced_error.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# test_via: ../backtrace.rb
 module GraphQL
   class Backtrace
     # When {Backtrace} is enabled, raised errors are wrapped with {TracedError}.

data/lib/graphql/backtrace/tracer.rb

@@ -21,14 +21,10 @@ module GraphQL
           multiplex = query.multiplex
         when "execute_field", "execute_field_lazy"
           query = metadata[:query] || raise(ArgumentError, "Add `legacy: true` to use GraphQL::Backtrace without the interpreter runtime.")
-          context = query.context
           multiplex = query.multiplex
           push_key = metadata[:path].reject { |i| i.is_a?(Integer) }
           parent_frame = multiplex.context[:graphql_backtrace_contexts][push_key[0..-2]]
-          if parent_frame.nil?
-            p push_key
-            binding.pry
-          end
+
           if parent_frame.is_a?(GraphQL::Query)
             parent_frame = parent_frame.context
           end
@@ -47,14 +43,14 @@ module GraphQL
           nil
         end
 
-        if push_data
-          multiplex.context[:graphql_backtrace_contexts][push_key] = push_data
+        if push_data && multiplex
+          push_storage = multiplex.context[:graphql_backtrace_contexts] ||= {}
+          push_storage[push_key] = push_data
           multiplex.context[:last_graphql_backtrace_context] = push_data
         end
 
         if key == "execute_multiplex"
           multiplex_context = metadata[:multiplex].context
-          multiplex_context[:graphql_backtrace_contexts] = {}
           begin
             yield
           rescue StandardError => err

data/lib/graphql/backwards_compatibility.rb

@@ -22,7 +22,7 @@ module GraphQL
         backtrace = caller(0, 20)
         # Find the first line in the trace that isn't library internals:
         user_line = backtrace.find {|l| l !~ /lib\/graphql/ }
-        warn(message + "\n" + user_line + "\n")
+        GraphQL::Deprecation.warn(message + "\n" + user_line + "\n")
         wrapper = last ? LastArgumentsWrapper : FirstArgumentsWrapper
         wrapper.new(callable, from)
       else

data/lib/graphql/base_type.rb

@@ -224,7 +224,7 @@ module GraphQL
     private
 
     def warn_deprecated_coerce(alt_method_name)
-      warn("Coercing without a context is deprecated; use `#{alt_method_name}` if you don't want context-awareness")
+      GraphQL::Deprecation.warn("Coercing without a context is deprecated; use `#{alt_method_name}` if you don't want context-awareness")
     end
   end
 end

data/lib/graphql/compatibility/execution_specification.rb

@@ -32,7 +32,7 @@ module GraphQL
       # @param execution_strategy [<#new, #execute>] An execution strategy class
       # @return [Class<Minitest::Test>] A test suite for this execution strategy
       def self.build_suite(execution_strategy)
-        warn "#{self} will be removed from GraphQL-Ruby 2.0. There is no replacement, please open an issue on GitHub if you need support."
+        GraphQL::Deprecation.warn "#{self} will be removed from GraphQL-Ruby 2.0. There is no replacement, please open an issue on GitHub if you need support."
         Class.new(Minitest::Test) do
           class << self
             attr_accessor :counter_schema, :specification_schema

data/lib/graphql/compatibility/lazy_execution_specification.rb

@@ -7,7 +7,7 @@ module GraphQL
       # @param execution_strategy [<#new, #execute>] An execution strategy class
       # @return [Class<Minitest::Test>] A test suite for this execution strategy
       def self.build_suite(execution_strategy)
-        warn "#{self} will be removed from GraphQL-Ruby 2.0. There is no replacement, please open an issue on GitHub if you need support."
+        GraphQL::Deprecation.warn "#{self} will be removed from GraphQL-Ruby 2.0. There is no replacement, please open an issue on GitHub if you need support."
 
         Class.new(Minitest::Test) do
           class << self

data/lib/graphql/compatibility/query_parser_specification.rb

@@ -11,7 +11,7 @@ module GraphQL
       # @yieldreturn [GraphQL::Language::Nodes::Document]
       # @return [Class<Minitest::Test>] A test suite for this parse function
       def self.build_suite(&block)
-        warn "#{self} will be removed from GraphQL-Ruby 2.0. There is no replacement, please open an issue on GitHub if you need support."
+        GraphQL::Deprecation.warn "#{self} will be removed from GraphQL-Ruby 2.0. There is no replacement, please open an issue on GitHub if you need support."
 
         Class.new(Minitest::Test) do
           include QueryAssertions

data/lib/graphql/compatibility/schema_parser_specification.rb

@@ -8,7 +8,7 @@ module GraphQL
       # @yieldreturn [GraphQL::Language::Nodes::Document]
       # @return [Class<Minitest::Test>] A test suite for this parse function
       def self.build_suite(&block)
-        warn "#{self} will be removed from GraphQL-Ruby 2.0. There is no replacement, please open an issue on GitHub if you need support."
+        GraphQL::Deprecation.warn "#{self} will be removed from GraphQL-Ruby 2.0. There is no replacement, please open an issue on GitHub if you need support."
 
         Class.new(Minitest::Test) do
           @@parse_fn = block

data/lib/graphql/dataloader.rb

@@ -27,36 +27,24 @@ module GraphQL
       schema.dataloader_class = self
     end
 
-    def initialize(multiplex_context)
-      @context = multiplex_context
+    def initialize
       @source_cache = Hash.new { |h, source_class| h[source_class] = Hash.new { |h2, batch_parameters|
           source = source_class.new(*batch_parameters)
           source.setup(self)
           h2[batch_parameters] = source
         }
       }
-      @waiting_fibers = []
-      @yielded_fibers = Set.new
+      @pending_jobs = []
     end
 
-    # @return [Hash] the {Multiplex} context
-    attr_reader :context
-
-    # @api private
-    attr_reader :yielded_fibers
-
-    # Add some work to this dataloader to be scheduled later.
-    # @param block Some work to enqueue
-    # @return [void]
-    def enqueue(&block)
-      @waiting_fibers << Fiber.new {
-        begin
-          yield
-        rescue StandardError => exception
-          exception
-        end
-      }
-      nil
+    # Get a Source instance from this dataloader, for calling `.load(...)` or `.request(...)` on.
+    #
+    # @param source_class [Class<GraphQL::Dataloader::Source]
+    # @param batch_parameters [Array<Object>]
+    # @return [GraphQL::Dataloader::Source] An instance of {source_class}, initialized with `self, *batch_parameters`,
+    #   and cached for the lifetime of this {Multiplex}.
+    def with(source_class, *batch_parameters)
+      @source_cache[source_class][batch_parameters]
     end
 
     # Tell the dataloader that this fiber is waiting for data.
@@ -69,32 +57,67 @@ module GraphQL
       nil
     end
 
-    # @return [Boolean] Returns true if the current Fiber has yielded once via Dataloader
-    def yielded?
-      @yielded_fibers.include?(Fiber.current)
+    # @api private Nothing to see here
+    def append_job(&job)
+      # Given a block, queue it up to be worked through when `#run` is called.
+      # (If the dataloader is already running, than a Fiber will pick this up later.)
+      @pending_jobs.push(job)
+      nil
     end
 
-    # Run all Fibers until they're all done
-    #
-    # Each cycle works like this:
-    #
-    #   - Run each pending execution fiber (`@waiting_fibers`),
-    #   - Then run each pending Source, preparing more data for those fibers.
-    #     - Run each pending Source _again_ (if one Source requested more data from another Source)
-    #     - Continue until there are no pending sources
-    #   - Repeat: run execution fibers again ...
-    #
-    # @return [void]
+    # @api private Move along, move along
     def run
-      # Start executing Fibers. This will run until all the Fibers are done.
-      already_run_fibers = []
-      while (current_fiber = @waiting_fibers.pop)
-        # Run each execution fiber, enqueuing it in `already_run_fibers`
-        # if it's still `.alive?`.
-        # Any spin-off continuations will be enqueued in `@waiting_fibers` (via {#enqueue})
-        resume_fiber_and_enqueue_continuation(current_fiber, already_run_fibers)
-
-        if @waiting_fibers.empty?
+      # At a high level, the algorithm is:
+      #
+      #  A) Inside Fibers, run jobs from the queue one-by-one
+      #    - When one of the jobs yields to the dataloader (`Fiber.yield`), then that fiber will pause
+      #    - In that case, if there are still pending jobs, a new Fiber will be created to run jobs
+      #    - Continue until all jobs have been _started_ by a Fiber. (Any number of those Fibers may be waiting to be resumed, after their data is loaded)
+      #  B) Once all known jobs have been run until they are complete or paused for data, run all pending data sources.
+      #    - Similarly, create a Fiber to consume pending sources and tell them to load their data.
+      #    - If one of those Fibers pauses, then create a new Fiber to continue working through remaining pending sources.
+      #    - When a source causes another source to become pending, run the newly-pending source _first_, since it's a dependency of the previous one.
+      #  C) After all pending sources have been completely loaded (there are no more pending sources), resume any Fibers that were waiting for data.
+      #    - Those Fibers assume that source caches will have been populated with the data they were waiting for.
+      #    - Those Fibers may request data from a source again, in which case they will yeilded and be added to a new pending fiber list.
+      #  D) Once all pending fibers have been resumed once, return to `A` above.
+      #
+      # For whatever reason, the best implementation I could find was to order the steps `[D, A, B, C]`, with a special case for skipping `D`
+      # on the first pass. I just couldn't find a better way to write the loops in a way that was DRY and easy to read.
+      #
+      pending_fibers = []
+      next_fibers = []
+      first_pass = true
+
+      while first_pass || (f = pending_fibers.shift)
+        if first_pass
+          first_pass = false
+        else
+          # These fibers were previously waiting for sources to load data,
+          # resume them. (They might wait again, in which case, re-enqueue them.)
+          resume(f)
+          if f.alive?
+            next_fibers << f
+          end
+        end
+
+        while @pending_jobs.any?
+          # Create a Fiber to consume jobs until one of the jobs yields
+          # or jobs run out
+          f = Fiber.new {
+            while (job = @pending_jobs.shift)
+              job.call
+            end
+          }
+          resume(f)
+          # In this case, the job yielded. Queue it up to run again after
+          # we load whatever it's waiting for.
+          if f.alive?
+            next_fibers << f
+          end
+        end
+
+        if pending_fibers.empty?
           # Now, run all Sources which have become pending _before_ resuming GraphQL execution.
           # Sources might queue up other Sources, which is fine -- those will also run before resuming execution.
           #
@@ -108,9 +131,15 @@ module GraphQL
           end
 
           if source_fiber_stack
+            # Use a stack with `.pop` here so that when a source causes another source to become pending,
+            # that newly-pending source will run _before_ the one that depends on it.
+            # (See below where the old fiber is pushed to the stack, then the new fiber is pushed on the stack.)
             while (outer_source_fiber = source_fiber_stack.pop)
-              resume_fiber_and_enqueue_continuation(outer_source_fiber, source_fiber_stack)
+              resume(outer_source_fiber)
 
+              if outer_source_fiber.alive?
+                source_fiber_stack << outer_source_fiber
+              end
               # If this source caused more sources to become pending, run those before running this one again:
               next_source_fiber = create_source_fiber
               if next_source_fiber
@@ -118,58 +147,26 @@ module GraphQL
               end
             end
           end
-
-          # We ran all the first round of execution fibers,
-          # and we ran all the pending sources.
-          # So pick up any paused execution fibers and repeat.
-          @waiting_fibers.concat(already_run_fibers)
-          already_run_fibers.clear
+          # Move newly-enqueued Fibers on to the list to be resumed.
+          # Clear out the list of next-round Fibers, so that
+          # any Fibers that pause can be put on it.
+          pending_fibers.concat(next_fibers)
+          next_fibers.clear
         end
       end
-      nil
-    end
 
-    # Get a Source instance from this dataloader, for calling `.load(...)` or `.request(...)` on.
-    #
-    # @param source_class [Class<GraphQL::Dataloader::Source]
-    # @param batch_parameters [Array<Object>]
-    # @return [GraphQL::Dataloader::Source] An instance of {source_class}, initialized with `self, *batch_parameters`,
-    #   and cached for the lifetime of this {Multiplex}.
-    def with(source_class, *batch_parameters)
-      @source_cache[source_class][batch_parameters]
+      if @pending_jobs.any?
+        raise "Invariant: #{@pending_jobs.size} pending jobs"
+      elsif pending_fibers.any?
+        raise "Invariant: #{pending_fibers.size} pending fibers"
+      elsif next_fibers.any?
+        raise "Invariant: #{next_fibers.size} next fibers"
+      end
+      nil
     end
 
-    # @api private
-    attr_accessor :current_runtime
-
     private
 
-    # Check if this fiber is still alive.
-    # If it is, and it should continue, then enqueue a continuation.
-    # If it is, re-enqueue it in `fiber_queue`.
-    # Otherwise, clean it up from @yielded_fibers.
-    # @return [void]
-    def resume_fiber_and_enqueue_continuation(fiber, fiber_stack)
-      result = fiber.resume
-      if result.is_a?(StandardError)
-        raise result
-      end
-
-      # This fiber yielded; there's more to do here.
-      # (If `#alive?` is false, then the fiber concluded without yielding.)
-      if fiber.alive?
-        if !@yielded_fibers.include?(fiber)
-          # This fiber hasn't yielded yet, we should enqueue a continuation fiber
-          @yielded_fibers.add(fiber)
-          current_runtime.enqueue_selections_fiber
-        end
-        fiber_stack << fiber
-      else
-        # Keep this set clean so that fibers can be GC'ed during execution
-        @yielded_fibers.delete(fiber)
-      end
-    end
-
     # If there are pending sources, return a fiber for running them.
     # Otherwise, return `nil`.
     #
@@ -186,6 +183,14 @@ module GraphQL
       end
 
       if pending_sources
+        # By passing the whole array into this Fiber, it's possible that we set ourselves up for a bunch of no-ops.
+        # For example, if you have sources `[a, b, c]`, and `a` is loaded, then `b` yields to wait for `d`, then
+        # the next fiber would be dispatched with `[c, d]`. It would fulfill `c`, then `d`, then eventually
+        # the previous fiber would start up again. `c` would no longer be pending, but it would still receive `.run_pending_keys`.
+        # That method is short-circuited since it isn't pending any more, but it's still a waste.
+        #
+        # This design could probably be improved by maintaining a `@pending_sources` queue which is shared by the fibers,
+        # similar to `@pending_jobs`. That way, when a fiber is resumed, it would never pick up work that was finished by a different fiber.
         source_fiber = Fiber.new do
           pending_sources.each(&:run_pending_keys)
         end
@@ -193,5 +198,11 @@ module GraphQL
 
       source_fiber
     end
+
+    def resume(fiber)
+      fiber.resume
+    rescue UncaughtThrowError => e
+      throw e.tag, e.value
+    end
   end
 end