graphql 1.12.12 → 2.2.14

data/lib/graphql/dataloader.rb

@@ -23,23 +23,69 @@ module GraphQL
   #   end
   #
   class Dataloader
-    def self.use(schema)
-      schema.dataloader_class = self
+    class << self
+      attr_accessor :default_nonblocking
     end
 
-    def initialize
-      @source_cache = Hash.new { |h, source_class| h[source_class] = Hash.new { |h2, batch_parameters|
-          source = if RUBY_VERSION < "3"
-            source_class.new(*batch_parameters)
-          else
-            batch_args, batch_kwargs = batch_parameters
-            source_class.new(*batch_args, **batch_kwargs)
-          end
-          source.setup(self)
-          h2[batch_parameters] = source
-        }
+    NonblockingDataloader = Class.new(self) { self.default_nonblocking = true }
+
+    def self.use(schema, nonblocking: nil)
+      schema.dataloader_class = if nonblocking
+        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
+    end
+
+    # Call the block with a Dataloader instance,
+    # then run all enqueued jobs and return the result of the block.
+    def self.with_dataloading(&block)
+      dataloader = self.new
+      result = nil
+      dataloader.append_job {
+        result = block.call(dataloader)
       }
+      dataloader.run
+      result
+    end
+
+    def initialize(nonblocking: self.class.default_nonblocking)
+      @source_cache = Hash.new { |h, k| h[k] = {} }
       @pending_jobs = []
+      if !nonblocking.nil?
+        @nonblocking = nonblocking
+      end
+    end
+
+    def nonblocking?
+      @nonblocking
+    end
+
+    # This is called before the fiber is spawned, from the parent context (i.e. from
+    # the thread or fiber that it is scheduled from).
+    #
+    # @return [Hash<Symbol, Object>] Current fiber-local variables
+    def get_fiber_variables
+      fiber_vars = {}
+      Thread.current.keys.each do |fiber_var_key|
+        # This variable should be fresh in each new fiber
+        if fiber_var_key != :__graphql_runtime_info
+          fiber_vars[fiber_var_key] = Thread.current[fiber_var_key]
+        end
+      end
+      fiber_vars
+    end
+
+    # Set up the fiber variables in a new fiber.
+    #
+    # This is called within the fiber, right after it is spawned.
+    #
+    # @param vars [Hash<Symbol, Object>] Fiber-local variables from {get_fiber_variables}
+    # @return [void]
+    def set_fiber_variables(vars)
+      vars.each { |k, v| Thread.current[k] = v }
+      nil
     end
 
     # Get a Source instance from this dataloader, for calling `.load(...)` or `.request(...)` on.
@@ -48,17 +94,25 @@ module GraphQL
     # @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}.
-    if RUBY_VERSION < "3"
-      def with(source_class, *batch_parameters)
-        @source_cache[source_class][batch_parameters]
+    if RUBY_VERSION < "3" || RUBY_ENGINE != "ruby" # truffle-ruby wasn't doing well with the implementation below
+      def with(source_class, *batch_args)
+        batch_key = source_class.batch_key_for(*batch_args)
+        @source_cache[source_class][batch_key] ||= begin
+          source = source_class.new(*batch_args)
+          source.setup(self)
+          source
+        end
       end
     else
       def with(source_class, *batch_args, **batch_kwargs)
-        batch_parameters = [batch_args, batch_kwargs]
-        @source_cache[source_class][batch_parameters]
+        batch_key = source_class.batch_key_for(*batch_args, **batch_kwargs)
+        @source_cache[source_class][batch_key] ||= begin
+          source = source_class.new(*batch_args, **batch_kwargs)
+          source.setup(self)
+          source
+        end
       end
     end
-
     # Tell the dataloader that this fiber is waiting for data.
     #
     # Dataloader will resume the fiber after the requested data has been loaded (by another Fiber).
@@ -77,9 +131,28 @@ module GraphQL
       nil
     end
 
+    # Clear any already-loaded objects from {Source} caches
+    # @return [void]
+    def clear_cache
+      @source_cache.each do |_source_class, batched_sources|
+        batched_sources.each_value(&:clear_cache)
+      end
+      nil
+    end
+
     # Use a self-contained queue for the work in the block.
     def run_isolated
       prev_queue = @pending_jobs
+      prev_pending_keys = {}
+      @source_cache.each do |source_class, batched_sources|
+        batched_sources.each do |batch_args, batched_source_instance|
+          if batched_source_instance.pending?
+            prev_pending_keys[batched_source_instance] = batched_source_instance.pending.dup
+            batched_source_instance.pending.clear
+          end
+        end
+      end
+
       @pending_jobs = []
       res = nil
       # Make sure the block is inside a Fiber, so it can `Fiber.yield`
@@ -90,113 +163,99 @@ module GraphQL
       res
     ensure
       @pending_jobs = prev_queue
+      prev_pending_keys.each do |source_instance, pending|
+        pending.each do |key, value|
+          if !source_instance.results.key?(key)
+            source_instance.pending[key] = value
+          end
+        end
+      end
     end
 
-    # @api private Move along, move along
     def run
-      # 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 = []
+      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?
-          #
-          source_fiber_queue = if (first_source_fiber = create_source_fiber)
-            [first_source_fiber]
-          else
-            nil
           end
+          join_queues(job_fibers, next_job_fibers)
 
-          if source_fiber_queue
-            while (outer_source_fiber = source_fiber_queue.shift)
-              resume(outer_source_fiber)
-
-              # 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
-                source_fiber_queue << next_source_fiber
-              end
-
-              if outer_source_fiber.alive?
-                source_fiber_queue << outer_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(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.
-          pending_fibers.concat(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"
+      run_fiber(manager)
+
+      if manager.alive?
+        raise "Invariant: Manager fiber didn't terminate properly."
       end
-      nil
+
+      if job_fibers.any?
+        raise "Invariant: job fibers should have exited but #{job_fibers.size} remained"
+      end
+      if source_fibers.any?
+        raise "Invariant: source fibers should have exited but #{source_fibers.size} remained"
+      end
+    rescue UncaughtThrowError => e
+      throw e.tag, e.value
+    end
+
+    def run_fiber(f)
+      f.resume
+    end
+
+    def spawn_fiber
+      fiber_vars = get_fiber_variables
+      Fiber.new(blocking: !@nonblocking) {
+        set_fiber_variables(fiber_vars)
+        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.
+        true
+      }
     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 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|
@@ -208,45 +267,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_locals = {}
-
-      Thread.current.keys.each do |fiber_var_key|
-        fiber_locals[fiber_var_key] = Thread.current[fiber_var_key]
-      end
-
-      Fiber.new do
-        fiber_locals.each { |k, v| Thread.current[k] = v }
-        yield
-      end
     end
   end
 end
+
+require "graphql/dataloader/async_dataloader"

data/lib/graphql/date_encoding_error.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+module GraphQL
+  # This error is raised when `Types::ISO8601Date` is asked to return a value
+  # that cannot be parsed to a Ruby Date.
+  #
+  # @see GraphQL::Types::ISO8601Date which raises this error
+  class DateEncodingError < GraphQL::RuntimeTypeError
+    # The value which couldn't be encoded
+    attr_reader :date_value
+
+    def initialize(value)
+      @date_value = value
+      super("Date cannot be parsed: #{value}. \nDate must be be able to be parsed as a Ruby Date object.")
+    end
+  end
+end

data/lib/graphql/dig.rb

@@ -2,7 +2,7 @@
 module GraphQL
   module Dig
     # implemented using the old activesupport #dig instead of the ruby built-in
-    # so we can use some of the magic in Schema::InputObject and Query::Arguments
+    # so we can use some of the magic in Schema::InputObject and Interpreter::Arguments
     # to handle stringified/symbolized keys.
     #
     # @param args [Array<[String, Symbol>] Retrieves the value object corresponding to the each key objects repeatedly

data/lib/graphql/duration_encoding_error.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+module GraphQL
+  # This error is raised when `Types::ISO8601Duration` is asked to return a value
+  # that cannot be parsed as an ISO8601-formatted duration by ActiveSupport::Duration.
+  #
+  # @see GraphQL::Types::ISO8601Duration which raises this error
+  class DurationEncodingError < GraphQL::RuntimeTypeError
+    # The value which couldn't be encoded
+    attr_reader :duration_value
+
+    def initialize(value)
+      @duration_value = value
+      super("Duration cannot be parsed: #{value}. \nDuration must be an ISO8601-formatted duration.")
+    end
+  end
+end

data/lib/graphql/execution/errors.rb

@@ -2,59 +2,15 @@
 
 module GraphQL
   module Execution
-    # A plugin that wraps query execution with error handling.
-    # Supports class-based schemas and the new {Interpreter} runtime only.
-    #
-    # @example Handling ActiveRecord::NotFound
-    #
-    #   class MySchema < GraphQL::Schema
-    #     use GraphQL::Execution::Errors
-    #
-    #     rescue_from(ActiveRecord::NotFound) do |err, obj, args, ctx, field|
-    #       ErrorTracker.log("Not Found: #{err.message}")
-    #       nil
-    #     end
-    #   end
-    #
     class Errors
-      def self.use(schema)
-        definition_line = caller(2, 1).first
-        GraphQL::Deprecation.warn("GraphQL::Execution::Errors is now installed by default, remove `use GraphQL::Execution::Errors` from #{definition_line}")
-      end
-
-      NEW_HANDLER_HASH = ->(h, k) {
-        h[k] = {
-          class: k,
-          handler: nil,
-          subclass_handlers: Hash.new(&NEW_HANDLER_HASH),
-         }
-      }
-
-      def initialize(schema)
-        @schema = schema
-        @handlers = {
-          class: nil,
-          handler: nil,
-          subclass_handlers: Hash.new(&NEW_HANDLER_HASH),
-        }
-      end
-
-      # @api private
-      def each_rescue
-        handlers = @handlers.values
-        while (handler = handlers.shift) do
-          yield(handler[:class], handler[:handler])
-          handlers.concat(handler[:subclass_handlers].values)
-        end
-      end
-
       # Register this handler, updating the
       # internal handler index to maintain least-to-most specific.
       #
       # @param error_class [Class<Exception>]
+      # @param error_handlers [Hash]
       # @param error_handler [Proc]
       # @return [void]
-      def rescue_from(error_class, error_handler)
+      def self.register_rescue_from(error_class, error_handlers, error_handler)
         subclasses_handlers = {}
         this_level_subclasses = []
         # During this traversal, do two things:
@@ -62,13 +18,12 @@ module GraphQL
         #   and gather them up to be inserted _under_ this class
         # - Find the point in the index where this handler should be inserted
         #   (That is, _under_ any superclasses, or at top-level, if there are no superclasses registered)
-        handlers = @handlers[:subclass_handlers]
-        while (handlers) do
+        while (error_handlers) do
           this_level_subclasses.clear
           # First, identify already-loaded handlers that belong
           # _under_ this one. (That is, they're handlers
           # for subclasses of `error_class`.)
-          handlers.each do |err_class, handler|
+          error_handlers.each do |err_class, handler|
             if err_class < error_class
               subclasses_handlers[err_class] = handler
               this_level_subclasses << err_class
@@ -76,13 +31,13 @@ module GraphQL
           end
           # Any handlers that we'll be moving, delete them from this point in the index
           this_level_subclasses.each do |err_class|
-            handlers.delete(err_class)
+            error_handlers.delete(err_class)
           end
 
           # See if any keys in this hash are superclasses of this new class:
-          next_index_point = handlers.find { |err_class, handler| error_class < err_class }
+          next_index_point = error_handlers.find { |err_class, handler| error_class < err_class }
           if next_index_point
-            handlers = next_index_point[1][:subclass_handlers]
+            error_handlers = next_index_point[1][:subclass_handlers]
           else
             # this new handler doesn't belong to any sub-handlers,
             # so insert it in the current set of `handlers`
@@ -91,39 +46,15 @@ module GraphQL
         end
         # Having found the point at which to insert this handler,
         # register it and merge any subclass handlers back in at this point.
-        this_class_handlers = handlers[error_class]
+        this_class_handlers = error_handlers[error_class]
         this_class_handlers[:handler] = error_handler
         this_class_handlers[:subclass_handlers].merge!(subclasses_handlers)
         nil
       end
 
-      # Call the given block with the schema's configured error handlers.
-      #
-      # If the block returns a lazy value, it's not wrapped with error handling. That area will have to be wrapped itself.
-      #
-      # @param ctx [GraphQL::Query::Context]
-      # @return [Object] Either the result of the given block, or some object to replace the result, in case of error handling.
-      def with_error_handling(ctx)
-        yield
-      rescue StandardError => err
-        handler = find_handler_for(err.class)
-        if handler
-          runtime_info = ctx.namespace(:interpreter) || {}
-          obj = runtime_info[:current_object]
-          args = runtime_info[:current_arguments]
-          field = runtime_info[:current_field]
-          if obj.is_a?(GraphQL::Schema::Object)
-            obj = obj.object
-          end
-          handler[:handler].call(err, obj, args, ctx, field)
-        else
-          raise err
-        end
-      end
-
       # @return [Proc, nil] The handler for `error_class`, if one was registered on this schema or inherited
-      def find_handler_for(error_class)
-        handlers = @handlers[:subclass_handlers]
+      def self.find_handler_for(schema, error_class)
+        handlers = schema.error_handlers[:subclass_handlers]
         handler = nil
         while (handlers) do
           _err_class, next_handler = handlers.find { |err_class, handler| error_class <= err_class }
@@ -138,8 +69,8 @@ module GraphQL
         end
 
         # check for a handler from a parent class:
-        if @schema.superclass.respond_to?(:error_handler) && (parent_errors = @schema.superclass.error_handler)
-          parent_handler = parent_errors.find_handler_for(error_class)
+        if schema.superclass.respond_to?(:error_handlers)
+          parent_handler = find_handler_for(schema.superclass, error_class)
         end
 
         # If the inherited handler is more specific than the one defined here,

data/lib/graphql/execution/interpreter/arguments.rb

@@ -59,7 +59,7 @@ module GraphQL
           @empty
         end
 
-        def_delegators :keyword_arguments, :key?, :[], :fetch, :keys, :each, :values
+        def_delegators :keyword_arguments, :key?, :[], :fetch, :keys, :each, :values, :size, :to_h
         def_delegators :argument_values, :each_value
 
         def inspect
@@ -80,7 +80,7 @@ module GraphQL
           )
         end
 
-        NO_ARGS = {}.freeze
+        NO_ARGS = GraphQL::EmptyObjects::EMPTY_HASH
         EMPTY = self.new(argument_values: nil, keyword_arguments: NO_ARGS).freeze
       end
     end