graphql 2.1.7 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f0e3e74b44a52e45b992da7fe79d28ff53ea9871ac621517888f887c1a0bd8fb
-  data.tar.gz: fc0a67822082dfc133b1b7f44135df17a5181de2e8404d4b756c4ac0b69a9761
+  metadata.gz: 1294ac9e09f2c6924a771765e3f79d6c29449235e65f736afd177270b2a90b99
+  data.tar.gz: eece859aa0e3137e5d7a67c39ec79917d3ee884e3011cb8e9f203801c78c0408
 SHA512:
-  metadata.gz: 00bcdc566706f6fc323b0872c5c36230e7964a518e37825dc14a49cc274cbcac099ab3dca8a24608fafb598dcdfb5c239abb2be81359fd234dbce6954530c044
-  data.tar.gz: efb58609553a215455f026bd686b01c699ea858a732733554198150c1c6a0b8f4b60b514c3aa0532bdc611267039c413cb82b5a63bff7a2a7f6b948a3c154814
+  metadata.gz: 4a8343dd7ddcdfbaa05cdfd462612810bbbaa600c62c2d392d367926e7c4742a14705cc05a7e14cfae6d0d5aecb0509e96b645edcbfcdb63d250349bdeef725e
+  data.tar.gz: de145d99232eecc3feb68fa0cb2f3cdfe73fa154924f3ad27ec25ab1e90783927a2b064667233379adc5f7bc1a38563a39466c193a5378b64e13676f802aeeeb

data/lib/generators/graphql/install_generator.rb

@@ -105,6 +105,9 @@ module Graphql
           template("#{base_type}.erb", "#{options[:directory]}/types/#{base_type}.rb")
         end
 
+        # All resolvers are defined as living in their own module, including this class.
+        template("base_resolver.erb", "#{options[:directory]}/resolvers/base.rb")
+
         # Note: You can't have a schema without the query type, otherwise introspection breaks
         template("query_type.erb", "#{options[:directory]}/types/query_type.rb")
         insert_root_type('query', 'QueryType')

data/lib/generators/graphql/templates/base_resolver.erb

@@ -0,0 +1,6 @@
+<% module_namespacing_when_supported do -%>
+module Types
+  class BaseResolver < GraphQL::Schema::Resolver
+  end
+end
+<% end -%>

data/lib/graphql/dataloader/async_dataloader.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+module GraphQL
+  class Dataloader
+    class AsyncDataloader < Dataloader
+      def yield
+        Thread.current[:graphql_dataloader_next_tick].wait
+        nil
+      end
+
+      def run
+        job_tasks = []
+        next_job_tasks = []
+        source_tasks = []
+        next_source_tasks = []
+        first_pass = true
+        jobs_condition = Async::Condition.new
+        sources_condition = Async::Condition.new
+        Sync do |root_task|
+          while first_pass || job_tasks.any?
+            first_pass = false
+
+            root_task.async do |jobs_task|
+              while (task = job_tasks.shift || spawn_job_task(jobs_task, jobs_condition))
+                if task.alive?
+                  next_job_tasks << task
+                end
+              end
+            end.wait
+            job_tasks.concat(next_job_tasks)
+            next_job_tasks.clear
+
+            while source_tasks.any? || @source_cache.each_value.any? { |group_sources| group_sources.each_value.any?(&:pending?) }
+              root_task.async do |sources_loop_task|
+                while (task = source_tasks.shift || spawn_source_task(sources_loop_task, sources_condition))
+                  if task.alive?
+                    next_source_tasks << task
+                  end
+                end
+              end.wait
+              sources_condition.signal
+              source_tasks.concat(next_source_tasks)
+              next_source_tasks.clear
+            end
+            jobs_condition.signal
+          end
+        end
+      rescue UncaughtThrowError => e
+        throw e.tag, e.value
+      end
+
+      private
+
+      def spawn_job_task(parent_task, condition)
+        if @pending_jobs.any?
+          fiber_vars = get_fiber_variables
+          parent_task.async do |t|
+            set_fiber_variables(fiber_vars)
+            Thread.current[:graphql_dataloader_next_tick] = condition
+            while job = @pending_jobs.shift
+              job.call
+            end
+          end
+        end
+      end
+
+      def spawn_source_task(parent_task, condition)
+        pending_sources = nil
+        @source_cache.each_value do |source_by_batch_params|
+          source_by_batch_params.each_value do |source|
+            if source.pending?
+              pending_sources ||= []
+              pending_sources << source
+            end
+          end
+        end
+
+        if pending_sources
+          fiber_vars = get_fiber_variables
+          parent_task.async do
+            set_fiber_variables(fiber_vars)
+            Thread.current[:graphql_dataloader_next_tick] = condition
+            pending_sources.each(&:run_pending_keys)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/graphql/dataloader/source.rb

@@ -88,6 +88,7 @@ module GraphQL
         raise "Implement `#{self.class}#fetch(#{keys.inspect}) to return a record for each of the keys"
       end
 
+      MAX_ITERATIONS = 1000
       # Wait for a batch, if there's anything to batch.
       # Then run the batch and update the cache.
       # @return [void]
@@ -96,8 +97,8 @@ module GraphQL
         iterations = 0
         while pending_result_keys.any? { |key| !@results.key?(key) }
           iterations += 1
-          if iterations > 1000
-            raise "#{self.class}#sync tried 1000 times to load pending keys (#{pending_result_keys}), but they still weren't loaded. There is likely a circular dependency."
+          if iterations > MAX_ITERATIONS
+            raise "#{self.class}#sync tried #{MAX_ITERATIONS} times to load pending keys (#{pending_result_keys}), but they still weren't loaded. There is likely a circular dependency."
           end
           @dataloader.yield
         end

data/lib/graphql/dataloader.rb

@@ -27,11 +27,12 @@ module GraphQL
       attr_accessor :default_nonblocking
     end
 
-    AsyncDataloader = Class.new(self) { self.default_nonblocking = true }
+    NonblockingDataloader = Class.new(self) { self.default_nonblocking = true }
 
     def self.use(schema, nonblocking: nil)
       schema.dataloader_class = if nonblocking
-        AsyncDataloader
+        warn("`nonblocking: true` is deprecated from `GraphQL::Dataloader`, please use `GraphQL::Dataloader::AsyncDataloader` instead. Docs: https://graphql-ruby.org/dataloader/async_dataloader.")
+        NonblockingDataloader
       else
         self
       end
@@ -118,7 +119,12 @@ module GraphQL
     #
     # @return [void]
     def yield
-      Fiber.yield
+      if use_fiber_resume?
+        Fiber.yield
+      else
+        parent_fiber = Thread.current[:parent_fiber]
+        parent_fiber.transfer
+      end
       nil
     end
 
@@ -167,120 +173,100 @@ module GraphQL
       end
     end
 
-    # @api private Move along, move along
     def run
-      if @nonblocking && !Fiber.scheduler
-        raise "`nonblocking: true` requires `Fiber.scheduler`, assign one with `Fiber.set_scheduler(...)` before executing GraphQL."
-      end
-      # 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 = []
-      pending_source_fibers = []
+      job_fibers = []
+      next_job_fibers = []
+      source_fibers = []
       next_source_fibers = []
       first_pass = true
-
-      while first_pass || (f = pending_fibers.shift)
-        if first_pass
+      manager = spawn_fiber do
+        while first_pass || job_fibers.any?
           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 = spawn_fiber {
-            while (job = @pending_jobs.shift)
-              job.call
+          while (f = job_fibers.shift || spawn_job_fiber)
+            if f.alive?
+              finished = run_fiber(f)
+              if !finished
+                next_job_fibers << f
+              end
             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.
-          #
-          # This is where an evented approach would be even better -- can we tell which
-          # fibers are ready to continue, and continue execution there?
-          #
-          if (first_source_fiber = create_source_fiber)
-            pending_source_fibers << first_source_fiber
           end
+          join_queues(job_fibers, next_job_fibers)
 
-          while pending_source_fibers.any?
-            while (outer_source_fiber = pending_source_fibers.pop)
-              resume(outer_source_fiber)
-              if outer_source_fiber.alive?
-                next_source_fibers << outer_source_fiber
-              end
-              if (next_source_fiber = create_source_fiber)
-                pending_source_fibers << next_source_fiber
+          while source_fibers.any? || @source_cache.each_value.any? { |group_sources| group_sources.each_value.any?(&:pending?) }
+            while (f = source_fibers.shift || spawn_source_fiber)
+              if f.alive?
+                finished = run_fiber(f)
+                if !finished
+                  next_source_fibers << f
+                end
               end
             end
-            join_queues(pending_source_fibers, next_source_fibers)
-            next_source_fibers.clear
+            join_queues(source_fibers, next_source_fibers)
           end
-          # 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.
-          join_queues(pending_fibers, next_fibers)
-          next_fibers.clear
+
         end
       end
 
-      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
+      run_fiber(manager)
+
+    rescue UncaughtThrowError => e
+      throw e.tag, e.value
     end
 
-    def join_queues(previous_queue, next_queue)
-      if @nonblocking
-        Fiber.scheduler.run
-        next_queue.select!(&:alive?)
+    def run_fiber(f)
+      if use_fiber_resume?
+        f.resume
+      else
+        f.transfer
       end
-      previous_queue.concat(next_queue)
+    end
+
+    def spawn_fiber
+      fiber_vars = get_fiber_variables
+      parent_fiber = use_fiber_resume? ? nil : Fiber.current
+      Fiber.new(blocking: !@nonblocking) {
+        set_fiber_variables(fiber_vars)
+        Thread.current[:parent_fiber] = parent_fiber
+        yield
+        # With `.transfer`, you have to explicitly pass back to the parent --
+        # if the fiber is allowed to terminate normally, control is passed to the main fiber instead.
+        if parent_fiber
+          parent_fiber.transfer(true)
+        else
+          true
+        end
+      }
     end
 
     private
 
-    # If there are pending sources, return a fiber for running them.
-    # Otherwise, return `nil`.
-    #
-    # @return [Fiber, nil]
-    def create_source_fiber
+    def join_queues(prev_queue, new_queue)
+      @nonblocking && Fiber.scheduler.run
+      prev_queue.concat(new_queue)
+      new_queue.clear
+    end
+
+    def use_fiber_resume?
+      Fiber.respond_to?(:scheduler) &&
+        (
+          (defined?(::DummyScheduler) && Fiber.scheduler.is_a?(::DummyScheduler)) ||
+          (defined?(::Evt) && ::Evt::Scheduler.singleton_class::BACKENDS.any? { |be| Fiber.scheduler.is_a?(be) }) ||
+          (defined?(::Libev) && Fiber.scheduler.is_a?(::Libev::Scheduler))
+        )
+    end
+
+    def spawn_job_fiber
+      if @pending_jobs.any?
+        spawn_fiber do
+          while job = @pending_jobs.shift
+            job.call
+          end
+        end
+      end
+    end
+
+    def spawn_source_fiber
       pending_sources = nil
       @source_cache.each_value do |source_by_batch_params|
         source_by_batch_params.each_value do |source|
@@ -292,48 +278,12 @@ 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 = spawn_fiber do
+        spawn_fiber do
           pending_sources.each(&:run_pending_keys)
         end
       end
-
-      source_fiber
-    end
-
-    def resume(fiber)
-      fiber.resume
-    rescue UncaughtThrowError => e
-      throw e.tag, e.value
-    end
-
-    # Copies the thread local vars into the fiber thread local vars. Many
-    # gems (such as RequestStore, MiniRacer, etc.) rely on thread local vars
-    # to keep track of execution context, and without this they do not
-    # behave as expected.
-    #
-    # @see https://github.com/rmosolgo/graphql-ruby/issues/3449
-    def spawn_fiber
-      fiber_vars = get_fiber_variables
-
-      if @nonblocking
-        Fiber.new(blocking: false) do
-          set_fiber_variables(fiber_vars)
-          yield
-        end
-      else
-        Fiber.new do
-          set_fiber_variables(fiber_vars)
-          yield
-        end
-      end
     end
   end
 end
+
+require "graphql/dataloader/async_dataloader"