graphql 2.6.9 → 2.6.14

data/lib/graphql/dataloader/async_dataloader.rb

@@ -1,4 +1,5 @@
 # frozen_string_literal: true
+# typed: true
 
 module GraphQL
   class Dataloader
@@ -23,8 +24,7 @@ module GraphQL
         create_pending_run
       end
 
-      # @api private
-      attr_reader :pending_sources
+      attr_reader :pending_sources # :nodoc:
 
       def create_pending_run
         jobs_fiber_limit, total_fiber_limit = calculate_fiber_limit
@@ -36,10 +36,14 @@ module GraphQL
         run = task.graphql_async_dataloader_run
         trace = run.trace
         trace&.dataloader_fiber_yield(source)
-        run.tasks_channel.push([:paused_task, task])
+        if !run.push_task_message(:paused_task, task)
+          task.stop
+        end
         condition = task.graphql_async_dataloader_condition
         condition.wait
-        run.tasks_channel.push([:resumed_task, task])
+        if !run.push_task_message(:resumed_task, task)
+          task.stop
+        end
         trace&.dataloader_fiber_resume(source)
         nil
       end
@@ -69,7 +73,7 @@ module GraphQL
 
         attr_accessor :trace, :root_task
 
-        attr_reader :jobs, :lazies_at_depth, :jobs_fiber_limit,  :snoozed_jobs_condition, :snoozed_sources_condition, :tasks_channel
+        attr_reader :dataloader, :jobs, :lazies_at_depth, :jobs_fiber_limit,  :snoozed_jobs_condition, :snoozed_sources_condition
 
         def jobs_bandwidth?
           running_count < @jobs_fiber_limit
@@ -84,6 +88,20 @@ module GraphQL
           @tasks_channel_task.cancel
         end
 
+        # Push to the tasks_channel, tolerating a closed channel: on the error path, `run_queue`
+        # closes the channel while sibling tasks can still run one more slice before
+        # `root_task.cancel` reaches them. Record `:task_error` payloads so they aren't lost, and
+        # return false so the caller can stop the task instead of raising `ClosedError` into user code.
+        def push_task_message(msg, data)
+          @tasks_channel.push([msg, data])
+          true
+        rescue Async::Queue::ClosedError
+          if msg == :task_error
+            @task_error ||= data
+          end
+          false
+        end
+
         def wait_for_activity
           @activity.wait
         end
@@ -175,12 +193,20 @@ module GraphQL
       end
 
       def active_run
-        @pending_run || Async::Task.current?&.graphql_async_dataloader_run || raise(GraphQL::Error, "No available Run to append to, GraphQL-Ruby bug")
+        @pending_run || current_task_run || raise(GraphQL::Error, "No available Run to append to, GraphQL-Ruby bug")
+      end
+
+      # The current task's run, but only if it belongs to this dataloader. A different
+      # dataloader may be running inside one of our tasks (or vice versa), e.g. a query
+      # executed from a resolver or a subscription trigger; its run must not be reused.
+      def current_task_run
+        run = Async::Task.current?&.graphql_async_dataloader_run
+        run if run&.dataloader.equal?(self)
       end
 
       def run_isolated
-        previous_run = Async::Task.current?&.graphql_async_dataloader_run
-        prev_pending_keys = {}
+        previous_run = current_task_run
+        prev_pending_keys = {} #: Hash[GraphQL::Dataloader::Source, Hash[untyped, untyped]]
         # Clear pending loads but keep already-cached records
         # in case they are useful to the given block.
         @source_cache.each do |source_class, batched_sources|
@@ -192,7 +218,7 @@ module GraphQL
           end
         end
 
-        res = nil
+        res = nil #: untyped
         create_pending_run
         @pending_run.jobs << -> { res = yield }
         run
@@ -203,6 +229,7 @@ module GraphQL
           # clear the one created in #run:
           @pending_run = nil
         end
+        prev_pending_keys = prev_pending_keys #: as !nil
         prev_pending_keys.each do |source_instance, pending|
           pending.each do |key, value|
             next if source_instance.results.key?(key)
@@ -215,19 +242,21 @@ module GraphQL
 
       def run(trace_query_lazy: nil)
         trace = Fiber[:__graphql_current_multiplex]&.current_trace
-        run = @pending_run || Async::Task.current?&.graphql_async_dataloader_run || raise(GraphQL::Error, "No available Run, GraphQL-Ruby internal bug")
+        run = @pending_run || current_task_run || raise(GraphQL::Error, "No available Run, GraphQL-Ruby internal bug")
         @pending_run = nil
         run.trace = trace
-        first_pass = true
+        first_pass = true #: bool
         trace&.begin_dataloader(self)
         fiber_vars = get_fiber_variables
-        raised_error = nil
+        raised_error = nil #: StandardError?
         jobs = run.jobs
         Sync do |_maybe_new_task|
           # Make sure there's a new task instance to hold `.graphql_...` state:
           task = Async::Task.new do |root_task|
             run.root_task = root_task
             root_task.graphql_async_dataloader_run = run
+            # Tasks inherit the spawning fiber's storage; give this run its own execution state.
+            Fiber[:__graphql_runtime_info] = nil
             set_fiber_variables(fiber_vars)
 
             while first_pass || run.running? || !jobs.empty?
@@ -263,7 +292,7 @@ module GraphQL
       private
 
       def run_queue(run, condition, mode)
-        opened_queues = false
+        opened_queues = false #: bool
 
         if condition.waiting?
           opened_queues = true
@@ -336,14 +365,14 @@ module GraphQL
             end
             nil
           rescue StandardError => err
-            run.tasks_channel.push([:task_error, err])
+            run.push_task_message(:task_error, err)
           else
-            run.tasks_channel.push([:finished_task, task])
+            run.push_task_message(:finished_task, task)
           ensure
             cleanup_fiber
             trace&.dataloader_fiber_exit
           end
-          run.tasks_channel.push([:started_task, new_task])
+          run.push_task_message(:started_task, new_task)
         end
       end
     end

data/lib/graphql/dataloader/null_dataloader.rb

@@ -1,11 +1,12 @@
 # frozen_string_literal: true
+# typed: true
 
 module GraphQL
   class Dataloader
     # GraphQL-Ruby uses this when Dataloader isn't enabled.
     #
     # It runs execution code inline and gathers lazy objects (eg. Promises)
-    # and resolves them during {#run}.
+    # and resolves them during [run](rdoc-ref:#run).
     class NullDataloader < Dataloader
       def initialize(*)
         @lazies_at_depth = Hash.new { |h,k| h[k] = [] }
@@ -20,7 +21,7 @@ module GraphQL
       def run(trace_query_lazy: nil)
         with_trace_query_lazy(trace_query_lazy) do
           while !@lazies_at_depth.empty?
-            smallest_depth = nil
+            smallest_depth = nil #: Integer?
             @lazies_at_depth.each_key do |depth_key|
               smallest_depth ||= depth_key
               if depth_key < smallest_depth
@@ -40,7 +41,7 @@ module GraphQL
         # Reuse this instance because execution code may already have a reference to _this_ `dataloader` inside the given block.
         prev_lazies_at_depth = @lazies_at_depth
         @lazies_at_depth = @lazies_at_depth.dup.clear
-        res = nil
+        res = nil #: untyped
         append_job {
           res = yield
         }

data/lib/graphql/dataloader/request.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
+# typed: true
 module GraphQL
   class Dataloader
-    # @see Source#request which returns an instance of this
+    # See [Source#request](rdoc-ref:Source#request) which returns an instance of this
     class Request
       def initialize(source, key)
         @source = source
@@ -10,7 +11,12 @@ module GraphQL
 
       # Call this method to cause the current Fiber to wait for the results of this request.
       #
-      # @return [Object] the object loaded for `key`
+      # **Returns**
+      #
+      # - `Object` — the object loaded for `key`
+      #
+      # :call-seq:
+      #   load() -> Object
       def load
         @source.load(@key)
       end

data/lib/graphql/dataloader/request_all.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
+# typed: true
 module GraphQL
   class Dataloader
-    # @see Source#request_all which returns an instance of this.
+    # See [Source#request_all](rdoc-ref:Source#request_all) which returns an instance of this.
     class RequestAll < Request
       def initialize(source, keys)
         @source = source
@@ -10,7 +11,12 @@ module GraphQL
 
       # Call this method to cause the current Fiber to wait for the results of this request.
       #
-      # @return [Array<Object>] One object for each of `keys`
+      # **Returns**
+      #
+      # - `Array<Object>` — One object for each of `keys`
+      #
+      # :call-seq:
+      #   load() -> Array[Object]
       def load
         @source.load_all(@keys)
       end

data/lib/graphql/dataloader/source.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
+# typed: true
 
 module GraphQL
   class Dataloader
     class Source
-      # Called by {Dataloader} to prepare the {Source}'s internal state
-      # @api private
-      def setup(dataloader)
+      # Called by [Dataloader](rdoc-ref:Dataloader) to prepare the [Source](rdoc-ref:Source)'s internal state
+      def setup(dataloader) # :nodoc:
         # These keys have been requested but haven't been fetched yet
         @pending = {}
         # These keys have been passed to `fetch` but haven't been finished yet
@@ -17,7 +17,12 @@ 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.
+      # **Returns**
+      #
+      # - `Dataloader::Request` — a pending request for a value from `key`. Call `.load` on that object to wait for the result.
+      #
+      # :call-seq:
+      #   request(value) -> Dataloader::Request
       def request(value)
         res_key = result_key_for(value)
         add_pending_key(res_key, value)
@@ -27,25 +32,46 @@ module GraphQL
       # 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
+      # **Parameters**
+      #
+      # - `value` (`Object`) — A value passed to `.request` or `.load`, for which a value will be loaded
+      #
+      # **Returns**
+      #
+      # - `Object` — The key for tracking this pending data
+      #
+      # :call-seq:
+      #   result_key_for(Object value) -> Object
       def result_key_for(value)
         value
       end
 
-      # Implement this method if varying values given to {load} (etc) should be consolidated
-      # or normalized before being handed off to your {fetch} implementation.
+      # Implement this method if varying values given to [load](rdoc-ref:load) (etc) should be consolidated
+      # or normalized before being handed off to your [fetch](rdoc-ref:fetch) implementation.
       #
-      # This is different than {result_key_for} because _that_ method handles unification inside Dataloader's cache,
-      # but this method changes the value passed into {fetch}.
+      # This is different than [result_key_for](rdoc-ref:result_key_for) because _that_ method handles unification inside Dataloader's cache,
+      # but this method changes the value passed into [fetch](rdoc-ref:fetch).
       #
-      # @param value [Object] The value passed to {load}, {load_all}, {request}, or {request_all}
-      # @return [Object] The value given to {fetch}
+      # **Parameters**
+      #
+      # - `value` (`Object`) — The value passed to [load](rdoc-ref:load), [load_all](rdoc-ref:load_all), [request](rdoc-ref:request), or [request_all](rdoc-ref:request_all)
+      #
+      # **Returns**
+      #
+      # - `Object` — The value given to [fetch](rdoc-ref:fetch)
+      #
+      # :call-seq:
+      #   normalize_fetch_key(Object value) -> Object
       def normalize_fetch_key(value)
         value
       end
 
-      # @return [Dataloader::Request] a pending request for a values from `keys`. Call `.load` on that object to wait for the results.
+      # **Returns**
+      #
+      # - `Dataloader::Request` — a pending request for a values from `keys`. Call `.load` on that object to wait for the results.
+      #
+      # :call-seq:
+      #   request_all(values) -> Dataloader::Request
       def request_all(values)
         values.each do |v|
           res_key = result_key_for(v)
@@ -54,8 +80,16 @@ module GraphQL
         Dataloader::RequestAll.new(self, values)
       end
 
-      # @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.
+      # **Parameters**
+      #
+      # - `value` (`Object`) — A loading value which will be passed to [fetch](rdoc-ref:#fetch) if it isn't already in the internal cache.
+      #
+      # **Returns**
+      #
+      # - `Object` — The result from [fetch](rdoc-ref:#fetch) for `key`. If `key` hasn't been loaded yet, the Fiber will yield until it's loaded.
+      #
+      # :call-seq:
+      #   load(Object value) -> Object
       def load(value)
         result_key = result_key_for(value)
         if @results.key?(result_key)
@@ -67,8 +101,16 @@ module GraphQL
         end
       end
 
-      # @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.
+      # **Parameters**
+      #
+      # - `values` (`Array<Object>`) — Loading keys which will be passed to `#fetch` (or read from the internal cache).
+      #
+      # **Returns**
+      #
+      # - `Object` — The result from [fetch](rdoc-ref:#fetch) for `keys`. If `keys` haven't been loaded yet, the Fiber will yield until they're loaded.
+      #
+      # :call-seq:
+      #   load_all(Array[Object] values) -> Object
       def load_all(values)
         result_keys = []
         pending_keys = []
@@ -89,8 +131,17 @@ module GraphQL
       end
 
       # Subclasses must implement this method to return a value for each of `keys`
-      # @param keys [Array<Object>] keys passed to {#load}, {#load_all}, {#request}, or {#request_all}
-      # @return [Array<Object>] A loaded value for each of `keys`. The array must match one-for-one to the list of `keys`.
+      #
+      # **Parameters**
+      #
+      # - `keys` (`Array<Object>`) — keys passed to [load](rdoc-ref:#load), [load all](rdoc-ref:#load_all), [request](rdoc-ref:#request), or [request all](rdoc-ref:#request_all)
+      #
+      # **Returns**
+      #
+      # - `Array<Object>` — A loaded value for each of `keys`. The array must match one-for-one to the list of `keys`.
+      #
+      # :call-seq:
+      #   fetch(Array[Object] keys) -> Array[Object]
       def fetch(keys)
         # somehow retrieve these from the backend
         raise "Implement `#{self.class}#fetch(#{keys.inspect}) to return a record for each of the keys"
@@ -99,7 +150,13 @@ module GraphQL
       MAX_ITERATIONS = 1000
       # Wait for a batch, if there's anything to batch.
       # Then run the batch and update the cache.
-      # @return [void]
+      #
+      # **Returns**
+      #
+      # - `void`
+      #
+      # :call-seq:
+      #   sync(pending_result_keys) -> void
       def sync(pending_result_keys)
         @dataloader.queue_pending_source(self) if pending?
         @dataloader.yield(self)
@@ -114,15 +171,29 @@ module GraphQL
         nil
       end
 
-      # @return [Boolean] True if this source has any pending requests for data.
+      # **Returns**
+      #
+      # - `Boolean` — True if this source has any pending requests for data.
+      #
+      # :call-seq:
+      #   pending?() -> bool
       def pending?
         !@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]
+      #
+      # **Parameters**
+      #
+      # - `new_results` (`Hash<Object => Object>`) — key-value pairs to cache in this source
+      #
+      # **Returns**
+      #
+      # - `void`
+      #
+      # :call-seq:
+      #   merge(Hash[Object, Object] new_results) -> void
       def merge(new_results)
         new_results.each do |new_k, new_v|
           key = result_key_for(new_k)
@@ -131,10 +202,12 @@ module GraphQL
         nil
       end
 
-      # Called by {GraphQL::Dataloader} to resolve and pending requests to this source.
-      # @api private
-      # @return [void]
-      def run_pending_keys
+      # Called by [GraphQL::Dataloader](rdoc-ref:GraphQL::Dataloader) to resolve and pending requests to this source.
+      #
+      # **Returns**
+      #
+      # - `void`
+      def run_pending_keys # :nodoc:
         @fetching.each_key { |k| @pending.delete(k) }
         return if @pending.empty?
         fetch_h = @pending
@@ -167,9 +240,17 @@ module GraphQL
       # this method to call `.to_sql` on them, thus merging `.load(...)` calls when they apply
       # to equivalent relations.
       #
-      # @param batch_args [Array<Object>]
-      # @param batch_kwargs [Hash]
-      # @return [Object]
+      # **Parameters**
+      #
+      # - `batch_args` (`Array<Object>`)
+      # - `batch_kwargs` (`Hash`)
+      #
+      # **Returns**
+      #
+      # - `Object`
+      #
+      # :call-seq:
+      #   batch_key_for(Array[Object] *batch_args, Hash **batch_kwargs) -> Object
       def self.batch_key_for(*batch_args, **batch_kwargs)
         if batch_kwargs.any? # rubocop:disable Development/NoneWithoutBlockCop
           [*batch_args, **batch_kwargs]
@@ -179,7 +260,13 @@ module GraphQL
       end
 
       # Clear any already-loaded objects for this source
-      # @return [void]
+      #
+      # **Returns**
+      #
+      # - `void`
+      #
+      # :call-seq:
+      #   clear_cache() -> void
       def clear_cache
         @results.clear
         nil
@@ -199,10 +286,15 @@ module GraphQL
       end
 
       # Reads and returns the result for the key from the internal cache, or raises an error if the result was an error
-      # @param key [Object] key passed to {#load} or {#load_all}
-      # @return [Object] The result from {#fetch} for `key`.
-      # @api private
-      def result_for(key)
+      #
+      # **Parameters**
+      #
+      # - `key` (`Object`) — key passed to [load](rdoc-ref:#load) or [load all](rdoc-ref:#load_all)
+      #
+      # **Returns**
+      #
+      # - `Object` — The result from [fetch](rdoc-ref:#fetch) for `key`.
+      def result_for(key) # :nodoc:
         if !@results.key?(key)
           raise GraphQL::InvariantError, <<-ERR
 Fetching result for a key on #{self.class} that hasn't been loaded yet (#{key.inspect}, loaded: #{@results.keys})