graphql 2.0.13 → 2.3.10

data/lib/graphql/dataloader/null_dataloader.rb

@@ -8,7 +8,7 @@ module GraphQL
     # simple internal code while adding the option to add Dataloader.
     class NullDataloader < Dataloader
       # These are all no-ops because code was
-      # executed sychronously.
+      # executed synchronously.
       def run; end
       def run_isolated; yield; end
       def yield

data/lib/graphql/dataloader/request.rb

@@ -14,6 +14,11 @@ module GraphQL
       def load
         @source.load(@key)
       end
+
+      def load_with_deprecation_warning
+        warn("Returning `.request(...)` from GraphQL::Dataloader is deprecated, use `.load(...)` instead. (See usage of #{@source} with #{@key.inspect}).")
+        load
+      end
     end
   end
 end

data/lib/graphql/dataloader/source.rb

@@ -7,9 +7,9 @@ module GraphQL
       # @api private
       def setup(dataloader)
         # These keys have been requested but haven't been fetched yet
-        @pending_keys = []
+        @pending = {}
         # These keys have been passed to `fetch` but haven't been finished yet
-        @fetching_keys = []
+        @fetching = {}
         # { key => result }
         @results = {}
         @dataloader = dataloader
@@ -18,42 +18,66 @@ module GraphQL
       attr_reader :dataloader
 
       # @return [Dataloader::Request] a pending request for a value from `key`. Call `.load` on that object to wait for the result.
-      def request(key)
-        if !@results.key?(key)
-          @pending_keys << key
+      def request(value)
+        res_key = result_key_for(value)
+        if !@results.key?(res_key)
+          @pending[res_key] ||= value
         end
-        Dataloader::Request.new(self, key)
+        Dataloader::Request.new(self, value)
+      end
+
+      # Implement this method to return a stable identifier if different
+      # key objects should load the same data value.
+      #
+      # @param value [Object] A value passed to `.request` or `.load`, for which a value will be loaded
+      # @return [Object] The key for tracking this pending data
+      def result_key_for(value)
+        value
       end
 
       # @return [Dataloader::Request] a pending request for a values from `keys`. Call `.load` on that object to wait for the results.
-      def request_all(keys)
-        pending_keys = keys.select { |k| !@results.key?(k) }
-        @pending_keys.concat(pending_keys)
-        Dataloader::RequestAll.new(self, keys)
+      def request_all(values)
+        values.each do |v|
+          res_key = result_key_for(v)
+          if !@results.key?(res_key)
+            @pending[res_key] ||= v
+          end
+        end
+        Dataloader::RequestAll.new(self, values)
       end
 
-      # @param key [Object] A loading key which will be passed to {#fetch} if it isn't already in the internal cache.
+      # @param value [Object] A loading value which will be passed to {#fetch} if it isn't already in the internal cache.
       # @return [Object] The result from {#fetch} for `key`. If `key` hasn't been loaded yet, the Fiber will yield until it's loaded.
-      def load(key)
-        if @results.key?(key)
-          result_for(key)
+      def load(value)
+        result_key = result_key_for(value)
+        if @results.key?(result_key)
+          result_for(result_key)
         else
-          @pending_keys << key
-          sync
-          result_for(key)
+          @pending[result_key] ||= value
+          sync([result_key])
+          result_for(result_key)
         end
       end
 
-      # @param keys [Array<Object>] Loading keys which will be passed to `#fetch` (or read from the internal cache).
+      # @param values [Array<Object>] Loading keys which will be passed to `#fetch` (or read from the internal cache).
       # @return [Object] The result from {#fetch} for `keys`. If `keys` haven't been loaded yet, the Fiber will yield until they're loaded.
-      def load_all(keys)
-        if keys.any? { |k| !@results.key?(k) }
-          pending_keys = keys.select { |k| !@results.key?(k) }
-          @pending_keys.concat(pending_keys)
-          sync
+      def load_all(values)
+        result_keys = []
+        pending_keys = []
+        values.each { |v|
+          k = result_key_for(v)
+          result_keys << k
+          if !@results.key?(k)
+            @pending[k] ||= v
+            pending_keys << k
+          end
+        }
+
+        if pending_keys.any?
+          sync(pending_keys)
         end
 
-        keys.map { |k| result_for(k) }
+        result_keys.map { |k| result_for(k) }
       end
 
       # Subclasses must implement this method to return a value for each of `keys`
@@ -64,17 +88,17 @@ 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]
-      def sync
-        pending_keys = @pending_keys.dup
+      def sync(pending_result_keys)
         @dataloader.yield
         iterations = 0
-        while pending_keys.any? { |k| !@results.key?(k) }
+        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_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
@@ -83,31 +107,41 @@ module GraphQL
 
       # @return [Boolean] True if this source has any pending requests for data.
       def pending?
-        !@pending_keys.empty?
+        !@pending.empty?
+      end
+
+      # Add these key-value pairs to this source's cache
+      # (future loads will use these merged values).
+      # @param new_results [Hash<Object => Object>] key-value pairs to cache in this source
+      # @return [void]
+      def merge(new_results)
+        new_results.each do |new_k, new_v|
+          key = result_key_for(new_k)
+          @results[key] = new_v
+        end
+        nil
       end
 
       # Called by {GraphQL::Dataloader} to resolve and pending requests to this source.
       # @api private
       # @return [void]
       def run_pending_keys
-        if !@fetching_keys.empty?
-          @pending_keys -= @fetching_keys
+        if !@fetching.empty?
+          @fetching.each_key { |k| @pending.delete(k) }
         end
-        return if @pending_keys.empty?
-        fetch_keys = @pending_keys.uniq
-        @fetching_keys.concat(fetch_keys)
-        @pending_keys = []
-        results = fetch(fetch_keys)
-        fetch_keys.each_with_index do |key, idx|
+        return if @pending.empty?
+        fetch_h = @pending
+        @pending = {}
+        @fetching.merge!(fetch_h)
+        results = fetch(fetch_h.values)
+        fetch_h.each_with_index do |(key, _value), idx|
           @results[key] = results[idx]
         end
         nil
       rescue StandardError => error
-        fetch_keys.each { |key| @results[key] = error }
+        fetch_h.each_key { |key| @results[key] = error }
       ensure
-        if fetch_keys
-          @fetching_keys -= fetch_keys
-        end
+        fetch_h && fetch_h.each_key { |k| @fetching.delete(k) }
       end
 
       # These arguments are given to `dataloader.with(source_class, ...)`. The object
@@ -128,7 +162,14 @@ module GraphQL
         [*batch_args, **batch_kwargs]
       end
 
-      attr_reader :pending_keys
+      # Clear any already-loaded objects for this source
+      # @return [void]
+      def clear_cache
+        @results.clear
+        nil
+      end
+
+      attr_reader :pending, :results
 
       private
 
@@ -145,8 +186,11 @@ This key should have been loaded already. This is a bug in GraphQL::Dataloader,
 ERR
         end
         result = @results[key]
-
-        raise result if result.class <= StandardError
+        if result.is_a?(StandardError)
+          # Dup it because the rescuer may modify it.
+          # (This happens for GraphQL::ExecutionErrors, at least)
+          raise result.dup
+        end
 
         result
       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
@@ -61,6 +62,37 @@ module GraphQL
       @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
+
+    # This method is called when Dataloader is finished using a fiber.
+    # Use it to perform any cleanup, such as releasing database connections (if required manually)
+    def cleanup_fiber
+    end
+
     # Get a Source instance from this dataloader, for calling `.load(...)` or `.request(...)` on.
     #
     # @param source_class [Class<GraphQL::Dataloader::Source]
@@ -104,6 +136,15 @@ 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
@@ -111,8 +152,8 @@ module GraphQL
       @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_keys.dup
-            batched_source_instance.pending_keys.clear
+            prev_pending_keys[batched_source_instance] = batched_source_instance.pending.dup
+            batched_source_instance.pending.clear
           end
         end
       end
@@ -127,125 +168,97 @@ module GraphQL
       res
     ensure
       @pending_jobs = prev_queue
-      prev_pending_keys.each do |source_instance, pending_keys|
-        source_instance.pending_keys.concat(pending_keys)
+      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
-      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
+          join_queues(job_fibers, next_job_fibers)
 
-        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
-
-          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"
+      run_fiber(manager)
+
+      if manager.alive?
+        raise "Invariant: Manager fiber didn't terminate properly."
       end
-      nil
-    end
 
-    def join_queues(previous_queue, next_queue)
-      if @nonblocking
-        Fiber.scheduler.run
-        next_queue.select!(&:alive?)
+      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
-      previous_queue.concat(next_queue)
+    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
+        cleanup_fiber
+      }
     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|
@@ -257,52 +270,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
-
-      if @nonblocking
-        Fiber.new(blocking: false) do
-          fiber_locals.each { |k, v| Thread.current[k] = v }
-          yield
-        end
-      else
-        Fiber.new do
-          fiber_locals.each { |k, v| Thread.current[k] = v }
-          yield
-        end
-      end
     end
   end
 end
+
+require "graphql/dataloader/async_dataloader"

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/interpreter/argument_value.rb

@@ -6,15 +6,19 @@ module GraphQL
       # A container for metadata regarding arguments present in a GraphQL query.
       # @see Interpreter::Arguments#argument_values for a hash of these objects.
       class ArgumentValue
-        def initialize(definition:, value:, default_used:)
+        def initialize(definition:, value:, original_value:, default_used:)
           @definition = definition
           @value = value
+          @original_value = original_value
           @default_used = default_used
         end
 
         # @return [Object] The Ruby-ready value for this Argument
         attr_reader :value
 
+        # @return [Object] The value of this argument _before_ `prepare` is applied.
+        attr_reader :original_value
+
         # @return [GraphQL::Schema::Argument] The definition instance for this argument
         attr_reader :definition
 

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

@@ -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