graphql 2.4.5 → 2.5.21

data/lib/graphql/dataloader/source.rb

@@ -21,7 +21,7 @@ module GraphQL
       def request(value)
         res_key = result_key_for(value)
         if !@results.key?(res_key)
-          @pending[res_key] ||= value
+          @pending[res_key] ||= normalize_fetch_key(value)
         end
         Dataloader::Request.new(self, value)
       end
@@ -35,12 +35,24 @@ module GraphQL
         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.
+      #
+      # 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}.
+      #
+      # @param value [Object] The value passed to {load}, {load_all}, {request}, or {request_all}
+      # @return [Object] The value given to {fetch}
+      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.
       def request_all(values)
         values.each do |v|
           res_key = result_key_for(v)
           if !@results.key?(res_key)
-            @pending[res_key] ||= v
+            @pending[res_key] ||= normalize_fetch_key(v)
           end
         end
         Dataloader::RequestAll.new(self, values)
@@ -53,7 +65,7 @@ module GraphQL
         if @results.key?(result_key)
           result_for(result_key)
         else
-          @pending[result_key] ||= value
+          @pending[result_key] ||= normalize_fetch_key(value)
           sync([result_key])
           result_for(result_key)
         end
@@ -68,7 +80,7 @@ module GraphQL
           k = result_key_for(v)
           result_keys << k
           if !@results.key?(k)
-            @pending[k] ||= v
+            @pending[k] ||= normalize_fetch_key(v)
             pending_keys << k
           end
         }
@@ -93,14 +105,14 @@ module GraphQL
       # Then run the batch and update the cache.
       # @return [void]
       def sync(pending_result_keys)
-        @dataloader.yield
+        @dataloader.yield(self)
         iterations = 0
         while pending_result_keys.any? { |key| !@results.key?(key) }
           iterations += 1
           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#{@dataloader.fiber_limit ? " or `fiber_limit: #{@dataloader.fiber_limit}` is set too low" : ""}."
           end
-          @dataloader.yield
+          @dataloader.yield(self)
         end
         nil
       end

data/lib/graphql/dataloader.rb

@@ -4,6 +4,8 @@ require "graphql/dataloader/null_dataloader"
 require "graphql/dataloader/request"
 require "graphql/dataloader/request_all"
 require "graphql/dataloader/source"
+require "graphql/dataloader/active_record_association_source"
+require "graphql/dataloader/active_record_source"
 
 module GraphQL
   # This plugin supports Fiber-based concurrency, along with {GraphQL::Dataloader::Source}.
@@ -62,6 +64,7 @@ module GraphQL
         @nonblocking = nonblocking
       end
       @fiber_limit = fiber_limit
+      @lazies_at_depth = Hash.new { |h, k| h[k] = [] }
     end
 
     # @return [Integer, nil]
@@ -129,16 +132,19 @@ module GraphQL
     # Dataloader will resume the fiber after the requested data has been loaded (by another Fiber).
     #
     # @return [void]
-    def yield
+    def yield(source = Fiber[:__graphql_current_dataloader_source])
+      trace = Fiber[:__graphql_current_multiplex]&.current_trace
+      trace&.dataloader_fiber_yield(source)
       Fiber.yield
+      trace&.dataloader_fiber_resume(source)
       nil
     end
 
     # @api private Nothing to see here
-    def append_job(&job)
+    def append_job(callable = nil, &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)
+      # (If the dataloader is already running, then a Fiber will pick this up later.)
+      @pending_jobs.push(callable || job)
       nil
     end
 
@@ -155,6 +161,10 @@ module GraphQL
     def run_isolated
       prev_queue = @pending_jobs
       prev_pending_keys = {}
+      prev_lazies_at_depth = @lazies_at_depth
+      @lazies_at_depth = @lazies_at_depth.dup.clear
+      # 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|
         batched_sources.each do |batch_args, batched_source_instance|
           if batched_source_instance.pending?
@@ -174,6 +184,7 @@ module GraphQL
       res
     ensure
       @pending_jobs = prev_queue
+      @lazies_at_depth = prev_lazies_at_depth
       prev_pending_keys.each do |source_instance, pending|
         pending.each do |key, value|
           if !source_instance.results.key?(key)
@@ -183,7 +194,9 @@ module GraphQL
       end
     end
 
-    def run
+    # @param trace_query_lazy [nil, Execution::Multiplex]
+    def run(trace_query_lazy: nil)
+      trace = Fiber[:__graphql_current_multiplex]&.current_trace
       jobs_fiber_limit, total_fiber_limit = calculate_fiber_limit
       job_fibers = []
       next_job_fibers = []
@@ -191,31 +204,21 @@ module GraphQL
       next_source_fibers = []
       first_pass = true
       manager = spawn_fiber do
+        trace&.begin_dataloader(self)
         while first_pass || !job_fibers.empty?
           first_pass = false
 
-          while (f = (job_fibers.shift || (((next_job_fibers.size + job_fibers.size) < jobs_fiber_limit) && spawn_job_fiber)))
-            if f.alive?
-              finished = run_fiber(f)
-              if !finished
-                next_job_fibers << f
-              end
-            end
-          end
-          join_queues(job_fibers, next_job_fibers)
-
-          while (!source_fibers.empty? || @source_cache.each_value.any? { |group_sources| group_sources.each_value.any?(&:pending?) })
-            while (f = source_fibers.shift || (((job_fibers.size + source_fibers.size + next_source_fibers.size + next_job_fibers.size) < total_fiber_limit) && spawn_source_fiber))
-              if f.alive?
-                finished = run_fiber(f)
-                if !finished
-                  next_source_fibers << f
-                end
-              end
+          run_pending_steps(trace, job_fibers, next_job_fibers, jobs_fiber_limit, source_fibers, next_source_fibers, total_fiber_limit)
+
+          if !@lazies_at_depth.empty?
+            with_trace_query_lazy(trace_query_lazy) do
+              run_next_pending_lazies(job_fibers, trace)
+              run_pending_steps(trace, job_fibers, next_job_fibers, jobs_fiber_limit, source_fibers, next_source_fibers, total_fiber_limit)
             end
-            join_queues(source_fibers, next_source_fibers)
           end
         end
+
+        trace&.end_dataloader(self)
       end
 
       run_fiber(manager)
@@ -230,6 +233,7 @@ module GraphQL
       if !source_fibers.empty?
         raise "Invariant: source fibers should have exited but #{source_fibers.size} remained"
       end
+
     rescue UncaughtThrowError => e
       throw e.tag, e.value
     end
@@ -238,6 +242,11 @@ module GraphQL
       f.resume
     end
 
+    # @api private
+    def lazy_at_depth(depth, lazy)
+      @lazies_at_depth[depth] << lazy
+    end
+
     def spawn_fiber
       fiber_vars = get_fiber_variables
       Fiber.new(blocking: !@nonblocking) {
@@ -247,8 +256,77 @@ module GraphQL
       }
     end
 
+    # Pre-warm the Dataloader cache with ActiveRecord objects which were loaded elsewhere.
+    # These will be used by {Dataloader::ActiveRecordSource}, {Dataloader::ActiveRecordAssociationSource} and their helper
+    # methods, `dataload_record` and `dataload_association`.
+    # @param records [Array<ActiveRecord::Base>] Already-loaded records to warm the cache with
+    # @param index_by [Symbol] The attribute to use as the cache key. (Should match `find_by:` when using {ActiveRecordSource})
+    # @return [void]
+    def merge_records(records, index_by: :id)
+      records_by_class = Hash.new { |h, k| h[k] = {} }
+      records.each do |r|
+        records_by_class[r.class][r.public_send(index_by)] = r
+      end
+      records_by_class.each do |r_class, records|
+        with(ActiveRecordSource, r_class).merge(records)
+      end
+    end
+
     private
 
+    def run_next_pending_lazies(job_fibers, trace)
+      smallest_depth = nil
+      @lazies_at_depth.each_key do |depth_key|
+        smallest_depth ||= depth_key
+        if depth_key < smallest_depth
+          smallest_depth = depth_key
+        end
+      end
+
+      if smallest_depth
+        lazies = @lazies_at_depth.delete(smallest_depth)
+        if !lazies.empty?
+          lazies.each_with_index do |l, idx|
+            append_job { l.value }
+          end
+          job_fibers.unshift(spawn_job_fiber(trace))
+        end
+      end
+    end
+
+    def run_pending_steps(trace, job_fibers, next_job_fibers, jobs_fiber_limit, source_fibers, next_source_fibers, total_fiber_limit)
+      while (f = (job_fibers.shift || (((next_job_fibers.size + job_fibers.size) < jobs_fiber_limit) && spawn_job_fiber(trace))))
+        if f.alive?
+          finished = run_fiber(f)
+          if !finished
+            next_job_fibers << f
+          end
+        end
+      end
+      join_queues(job_fibers, next_job_fibers)
+
+      while (!source_fibers.empty? || @source_cache.each_value.any? { |group_sources| group_sources.each_value.any?(&:pending?) })
+        while (f = source_fibers.shift || (((job_fibers.size + source_fibers.size + next_source_fibers.size + next_job_fibers.size) < total_fiber_limit) && spawn_source_fiber(trace)))
+          if f.alive?
+            finished = run_fiber(f)
+            if !finished
+              next_source_fibers << f
+            end
+          end
+        end
+        join_queues(source_fibers, next_source_fibers)
+      end
+    end
+
+    def with_trace_query_lazy(multiplex_or_nil, &block)
+      if (multiplex = multiplex_or_nil)
+        query = multiplex.queries.length == 1 ? multiplex.queries[0] : nil
+        multiplex.current_trace.execute_query_lazy(query: query, multiplex: multiplex, &block)
+      else
+        yield
+      end
+    end
+
     def calculate_fiber_limit
       total_fiber_limit = @fiber_limit || Float::INFINITY
       if total_fiber_limit < 4
@@ -266,17 +344,19 @@ module GraphQL
       new_queue.clear
     end
 
-    def spawn_job_fiber
+    def spawn_job_fiber(trace)
       if !@pending_jobs.empty?
         spawn_fiber do
+          trace&.dataloader_spawn_execution_fiber(@pending_jobs)
           while job = @pending_jobs.shift
             job.call
           end
+          trace&.dataloader_fiber_exit
         end
       end
     end
 
-    def spawn_source_fiber
+    def spawn_source_fiber(trace)
       pending_sources = nil
       @source_cache.each_value do |source_by_batch_params|
         source_by_batch_params.each_value do |source|
@@ -289,10 +369,14 @@ module GraphQL
 
       if pending_sources
         spawn_fiber do
+          trace&.dataloader_spawn_source_fiber(pending_sources)
           pending_sources.each do |source|
             Fiber[:__graphql_current_dataloader_source] = source
+            trace&.begin_dataloader_source(source)
             source.run_pending_keys
+            trace&.end_dataloader_source(source)
           end
+          trace&.dataloader_fiber_exit
         end
       end
     end

data/lib/graphql/date_encoding_error.rb

@@ -10,7 +10,7 @@ module GraphQL
 
     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.")
+      super("Date cannot be parsed: #{value}. \nDate must be able to be parsed as a Ruby Date object.")
     end
   end
 end

data/lib/graphql/dig.rb

@@ -5,7 +5,8 @@ module GraphQL
     # 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
+    # @param own_key [String, Symbol] A key to retrieve
+    # @param rest_keys [Array<[String, Symbol>] Retrieves the value object corresponding to the each key objects repeatedly
     # @return [Object]
     def dig(own_key, *rest_keys)
       val = self[own_key]

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

@@ -6,12 +6,17 @@ module GraphQL
       module Resolve
         # Continue field results in `results` until there's nothing else to continue.
         # @return [void]
+        # @deprecated Call `dataloader.run` instead
         def self.resolve_all(results, dataloader)
+          warn "#{self}.#{__method__} is deprecated; Use `dataloader.run` instead.#{caller(1, 5).map { |l| "\n    #{l}"}.join}"
           dataloader.append_job { resolve(results, dataloader) }
           nil
         end
 
+        # @deprecated Call `dataloader.run` instead
         def self.resolve_each_depth(lazies_at_depth, dataloader)
+          warn "#{self}.#{__method__} is deprecated; Use `dataloader.run` instead.#{caller(1, 5).map { |l| "\n    #{l}"}.join}"
+
           smallest_depth = nil
           lazies_at_depth.each_key do |depth_key|
             smallest_depth ||= depth_key
@@ -23,9 +28,9 @@ module GraphQL
           if smallest_depth
             lazies = lazies_at_depth.delete(smallest_depth)
             if !lazies.empty?
-              dataloader.append_job {
-                lazies.each(&:value) # resolve these Lazy instances
-              }
+              lazies.each do |l|
+                dataloader.append_job { l.value }
+              end
               # Run lazies _and_ dataloader, see if more are enqueued
               dataloader.run
               resolve_each_depth(lazies_at_depth, dataloader)
@@ -34,20 +39,9 @@ module GraphQL
           nil
         end
 
-        # After getting `results` back from an interpreter evaluation,
-        # continue it until you get a response-ready Ruby value.
-        #
-        # `results` is one level of _depth_ of a query or multiplex.
-        #
-        # Resolve all lazy values in that depth before moving on
-        # to the next level.
-        #
-        # It's assumed that the lazies will
-        # return {Lazy} instances if there's more work to be done,
-        # or return {Hash}/{Array} if the query should be continued.
-        #
-        # @return [void]
+        # @deprecated Call `dataloader.run` instead
         def self.resolve(results, dataloader)
+          warn "#{self}.#{__method__} is deprecated; Use `dataloader.run` instead.#{caller(1, 5).map { |l| "\n    #{l}"}.join}"
           # There might be pending jobs here that _will_ write lazies
           # into the result hash. We should run them out, so we
           # can be sure that all lazies will be present in the result hashes.

data/lib/graphql/execution/interpreter/runtime/graphql_result.rb

@@ -5,7 +5,10 @@ module GraphQL
     class Interpreter
       class Runtime
         module GraphQLResult
-          def initialize(result_name, result_type, application_value, parent_result, is_non_null_in_parent, selections, is_eager)
+          def initialize(result_name, result_type, application_value, parent_result, is_non_null_in_parent, selections, is_eager, ast_node, graphql_arguments, graphql_field) # rubocop:disable Metrics/ParameterLists
+            @ast_node = ast_node
+            @graphql_arguments = graphql_arguments
+            @graphql_field = graphql_field
             @graphql_parent = parent_result
             @graphql_application_value = application_value
             @graphql_result_type = result_type
@@ -18,31 +21,52 @@ module GraphQL
             @graphql_metadata = nil
             @graphql_selections = selections
             @graphql_is_eager = is_eager
+            @base_path = nil
           end
 
+          # TODO test full path in Partial
+          attr_writer :base_path
+
           def path
             @path ||= build_path([])
           end
 
           def build_path(path_array)
             graphql_result_name && path_array.unshift(graphql_result_name)
-            @graphql_parent ? @graphql_parent.build_path(path_array) : path_array
+            if @graphql_parent
+              @graphql_parent.build_path(path_array)
+            elsif @base_path
+              @base_path + path_array
+            else
+              path_array
+            end
+          end
+
+          def depth
+            @depth ||= if @graphql_parent
+              @graphql_parent.depth + 1
+            else
+              1
+            end
           end
 
           attr_accessor :graphql_dead
           attr_reader :graphql_parent, :graphql_result_name, :graphql_is_non_null_in_parent,
-            :graphql_application_value, :graphql_result_type, :graphql_selections, :graphql_is_eager
+            :graphql_application_value, :graphql_result_type, :graphql_selections, :graphql_is_eager, :ast_node, :graphql_arguments, :graphql_field
 
           # @return [Hash] Plain-Ruby result data (`@graphql_metadata` contains Result wrapper objects)
           attr_accessor :graphql_result_data
         end
 
         class GraphQLResultHash
-          def initialize(_result_name, _result_type, _application_value, _parent_result, _is_non_null_in_parent, _selections, _is_eager)
+          def initialize(_result_name, _result_type, _application_value, _parent_result, _is_non_null_in_parent, _selections, _is_eager, _ast_node, _graphql_arguments, graphql_field) # rubocop:disable Metrics/ParameterLists
             super
             @graphql_result_data = {}
+            @ordered_result_keys = nil
           end
 
+          attr_accessor :ordered_result_keys
+
           include GraphQLResult
 
           attr_accessor :graphql_merged_into
@@ -60,7 +84,13 @@ module GraphQL
               t.set_leaf(key, value)
             end
 
+            before_size = @graphql_result_data.size
             @graphql_result_data[key] = value
+            after_size = @graphql_result_data.size
+            if after_size > before_size && @ordered_result_keys[before_size] != key
+              fix_result_order
+            end
+
             # keep this up-to-date if it's been initialized
             @graphql_metadata && @graphql_metadata[key] = value
 
@@ -71,7 +101,13 @@ module GraphQL
             if (t = @graphql_merged_into)
               t.set_child_result(key, value)
             end
+            before_size = @graphql_result_data.size
             @graphql_result_data[key] = value.graphql_result_data
+            after_size = @graphql_result_data.size
+            if after_size > before_size && @ordered_result_keys[before_size] != key
+              fix_result_order
+            end
+
             # If we encounter some part of this response that requires metadata tracking,
             # then create the metadata hash if necessary. It will be kept up-to-date after this.
             (@graphql_metadata ||= @graphql_result_data.dup)[key] = value
@@ -121,12 +157,25 @@ module GraphQL
             end
             @graphql_merged_into = into_result
           end
+
+          def fix_result_order
+            @ordered_result_keys.each do |k|
+              if @graphql_result_data.key?(k)
+                @graphql_result_data[k] = @graphql_result_data.delete(k)
+              end
+            end
+          end
+
+          # hook for breadth-first implementations to signal when collecting results.
+          def collect_result(result_name, result_value)
+            false
+          end
         end
 
         class GraphQLResultArray
           include GraphQLResult
 
-          def initialize(_result_name, _result_type, _application_value, _parent_result, _is_non_null_in_parent, _selections, _is_eager)
+          def initialize(_result_name, _result_type, _application_value, _parent_result, _is_non_null_in_parent, _selections, _is_eager, _ast_node, _graphql_arguments, graphql_field) # rubocop:disable Metrics/ParameterLists
             super
             @graphql_result_data = []
           end
@@ -168,6 +217,10 @@ module GraphQL
           def values
             (@graphql_metadata || @graphql_result_data)
           end
+
+          def [](idx)
+            (@graphql_metadata || @graphql_result_data)[idx]
+          end
         end
       end
     end