graphql 1.12.12 → 2.2.14

data/lib/graphql/backtrace/table.rb

@@ -83,13 +83,13 @@ module GraphQL
           value = if top && @override_value
             @override_value
           else
-            value_at(@context.query.context.namespace(:interpreter)[:runtime], context_entry.path)
+            value_at(@context.query.context.namespace(:interpreter_runtime)[:runtime], context_entry.path)
           end
           rows << [
             "#{context_entry.ast_node ? context_entry.ast_node.position.join(":") : ""}",
             "#{context_entry.field.path}#{field_alias ? " as #{field_alias}" : ""}",
             "#{context_entry.object.object.inspect}",
-            context_entry.arguments.to_h.inspect,
+            context_entry.arguments.to_h.inspect, # rubocop:disable Development/ContextIsPassedCop -- unrelated method
             Backtrace::InspectResult.inspect_result(value),
           ]
           if (parent = context_entry.parent_frame)
@@ -97,24 +97,6 @@ module GraphQL
           else
             rows
           end
-        when GraphQL::Query::Context::FieldResolutionContext
-          ctx = context_entry
-          field_name = "#{ctx.irep_node.owner_type.name}.#{ctx.field.name}"
-          position = "#{ctx.ast_node.line}:#{ctx.ast_node.col}"
-          field_alias = ctx.ast_node.alias
-          object = ctx.object
-          if object.is_a?(GraphQL::Schema::Object)
-            object = object.object
-          end
-          rows << [
-            "#{position}",
-            "#{field_name}#{field_alias ? " as #{field_alias}" : ""}",
-            "#{object.inspect}",
-            ctx.irep_node.arguments.to_h.inspect,
-            Backtrace::InspectResult.inspect_result(top && @override_value ? @override_value : ctx.value),
-          ]
-
-          build_rows(ctx.parent, rows: rows)
         when GraphQL::Query::Context
           query = context_entry.query
           op = query.selected_operation
@@ -130,7 +112,7 @@ module GraphQL
           if object.is_a?(GraphQL::Schema::Object)
             object = object.object
           end
-          value = value_at(context_entry.namespace(:interpreter)[:runtime], [])
+          value = value_at(context_entry.namespace(:interpreter_runtime)[:runtime], [])
           rows << [
             "#{position}",
             "#{op_type}#{op_name ? " #{op_name}" : ""}",
@@ -144,7 +126,7 @@ module GraphQL
       end
 
       def value_at(runtime, path)
-        response = runtime.response
+        response = runtime.final_result
         path.each do |key|
           if response && (response = response[key])
             next

data/lib/graphql/backtrace/trace.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+module GraphQL
+  class Backtrace
+    module Trace
+      def initialize(*args, **kwargs, &block)
+        @__backtrace_contexts = {}
+        @__backtrace_last_context = nil
+        super
+      end
+
+      def validate(query:, validate:)
+        if query.multiplex
+          push_query_backtrace_context(query)
+        end
+        super
+      end
+
+      def analyze_query(query:)
+        if query.multiplex # missing for stand-alone static validation
+          push_query_backtrace_context(query)
+        end
+        super
+      end
+
+      def execute_query(query:)
+        push_query_backtrace_context(query)
+        super
+      end
+
+      def execute_query_lazy(query:, multiplex:)
+        query ||= multiplex.queries.first
+        push_query_backtrace_context(query)
+        super
+      end
+
+      def execute_field(field:, query:, ast_node:, arguments:, object:)
+        push_field_backtrace_context(field, query, ast_node, arguments, object)
+        super
+      end
+
+      def execute_field_lazy(field:, query:, ast_node:, arguments:, object:)
+        push_field_backtrace_context(field, query, ast_node, arguments, object)
+        super
+      end
+
+      def execute_multiplex(multiplex:)
+        super
+      rescue StandardError => err
+        # This is an unhandled error from execution,
+        # Re-raise it with a GraphQL trace.
+        potential_context = @__backtrace_last_context
+        if potential_context.is_a?(GraphQL::Query::Context) ||
+            potential_context.is_a?(Backtrace::Frame)
+          raise TracedError.new(err, potential_context)
+        else
+          raise
+        end
+      end
+
+      private
+
+      def push_query_backtrace_context(query)
+        push_data = query
+        push_key = []
+        @__backtrace_contexts[push_key] = push_data
+        @__backtrace_last_context = push_data
+      end
+
+      def push_field_backtrace_context(field, query, ast_node, arguments, object)
+        push_key = query.context[:current_path]
+        push_storage = @__backtrace_contexts
+        parent_frame = push_storage[push_key[0..-2]]
+
+        if parent_frame.is_a?(GraphQL::Query)
+          parent_frame = parent_frame.context
+        end
+
+        push_data = Frame.new(
+          query: query,
+          path: push_key,
+          ast_node: ast_node,
+          field: field,
+          object: object,
+          arguments: arguments,
+          parent_frame: parent_frame,
+        )
+        push_storage[push_key] = push_data
+        @__backtrace_last_context = push_data
+      end
+
+    end
+  end
+end

data/lib/graphql/backtrace/tracer.rb

@@ -15,14 +15,17 @@ module GraphQL
           # No query context yet
           nil
         when "validate", "analyze_query", "execute_query", "execute_query_lazy"
-          query = metadata[:query] || metadata[:queries].first
           push_key = []
-          push_data = query
-          multiplex = query.multiplex
+          if (query = metadata[:query]) || ((queries = metadata[:queries]) && (query = queries.first))
+            push_data = query
+            multiplex = query.multiplex
+          elsif (multiplex = metadata[:multiplex])
+            push_data = multiplex.queries.first
+          end
         when "execute_field", "execute_field_lazy"
-          query = metadata[:query] || raise(ArgumentError, "Add `legacy: true` to use GraphQL::Backtrace without the interpreter runtime.")
+          query = metadata[:query]
           multiplex = query.multiplex
-          push_key = metadata[:path].reject { |i| i.is_a?(Integer) }
+          push_key = query.context[:current_path]
           parent_frame = multiplex.context[:graphql_backtrace_contexts][push_key[0..-2]]
 
           if parent_frame.is_a?(GraphQL::Query)
@@ -59,7 +62,6 @@ module GraphQL
             potential_context = multiplex_context[:last_graphql_backtrace_context]
 
             if potential_context.is_a?(GraphQL::Query::Context) ||
-                potential_context.is_a?(GraphQL::Query::Context::FieldResolutionContext) ||
                 potential_context.is_a?(Backtrace::Frame)
               raise TracedError.new(err, potential_context)
             else

data/lib/graphql/backtrace.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 require "graphql/backtrace/inspect_result"
-require "graphql/backtrace/legacy_tracer"
 require "graphql/backtrace/table"
 require "graphql/backtrace/traced_error"
 require "graphql/backtrace/tracer"
+require "graphql/backtrace/trace"
 module GraphQL
   # Wrap unhandled errors with {TracedError}.
   #
@@ -23,13 +23,8 @@ module GraphQL
 
     def_delegators :to_a, :each, :[]
 
-    def self.use(schema_defn, legacy: false)
-      tracer = if legacy
-        self::LegacyTracer
-      else
-        self::Tracer
-      end
-      schema_defn.tracer(tracer)
+    def self.use(schema_defn)
+      schema_defn.trace_with(self::Trace)
     end
 
     def initialize(context, value: nil)

data/lib/graphql/coercion_error.rb

@@ -1,13 +1,5 @@
 # frozen_string_literal: true
 module GraphQL
-  class CoercionError < GraphQL::Error
-    # @return [Hash] Optional custom data for error objects which will be added
-    # under the `extensions` key.
-    attr_accessor :extensions
-
-    def initialize(message, extensions: nil)
-      @extensions = extensions
-      super(message)
-    end
+  class CoercionError < GraphQL::ExecutionError
   end
 end

data/lib/graphql/dataloader/async_dataloader.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+module GraphQL
+  class Dataloader
+    class AsyncDataloader < Dataloader
+      def yield
+        if (condition = Thread.current[:graphql_dataloader_next_tick])
+          condition.wait
+        else
+          Fiber.yield
+        end
+        nil
+      end
+
+      def run
+        job_fibers = []
+        next_job_fibers = []
+        source_tasks = []
+        next_source_tasks = []
+        first_pass = true
+        sources_condition = Async::Condition.new
+        manager = spawn_fiber do
+          while first_pass || job_fibers.any?
+            first_pass = false
+
+            while (f = (job_fibers.shift || spawn_job_fiber))
+              if f.alive?
+                finished = run_fiber(f)
+                if !finished
+                  next_job_fibers << f
+                end
+              end
+            end
+            job_fibers.concat(next_job_fibers)
+            next_job_fibers.clear
+
+            Sync do |root_task|
+              while source_tasks.any? || @source_cache.each_value.any? { |group_sources| group_sources.each_value.any?(&:pending?) }
+                while (task = source_tasks.shift || spawn_source_task(root_task, sources_condition))
+                  if task.alive?
+                    root_task.yield # give the source task a chance to run
+                    next_source_tasks << task
+                  end
+                end
+                sources_condition.signal
+                source_tasks.concat(next_source_tasks)
+                next_source_tasks.clear
+              end
+            end
+          end
+        end
+
+        manager.resume
+        if manager.alive?
+          raise "Invariant: Manager didn't terminate successfully: #{manager}"
+        end
+
+      rescue UncaughtThrowError => e
+        throw e.tag, e.value
+      end
+
+      private
+
+      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/null_dataloader.rb

@@ -11,7 +11,9 @@ module GraphQL
       # executed sychronously.
       def run; end
       def run_isolated; yield; end
-      def yield; end
+      def yield
+        raise GraphQL::Error, "GraphQL::Dataloader is not running -- add `use GraphQL::Dataloader` to your schema to use Dataloader sources."
+      end
 
       def append_job
         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

@@ -6,7 +6,11 @@ module GraphQL
       # Called by {Dataloader} to prepare the {Source}'s internal state
       # @api private
       def setup(dataloader)
-        @pending_keys = []
+        # 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
+        @fetching = {}
+        # { key => result }
         @results = {}
         @dataloader = dataloader
       end
@@ -14,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`
@@ -60,35 +88,89 @@ 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
+      def sync(pending_result_keys)
         @dataloader.yield
+        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."
+          end
+          @dataloader.yield
+        end
+        nil
       end
 
       # @return [Boolean] True if this source has any pending requests for data.
       def pending?
-        @pending_keys.any?
+        !@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
-        return if @pending_keys.empty?
-        fetch_keys = @pending_keys.uniq
-        @pending_keys = []
-        results = fetch(fetch_keys)
-        fetch_keys.each_with_index do |key, idx|
+        if !@fetching.empty?
+          @fetching.each_key { |k| @pending.delete(k) }
+        end
+        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
+        fetch_h && fetch_h.each_key { |k| @fetching.delete(k) }
+      end
+
+      # These arguments are given to `dataloader.with(source_class, ...)`. The object
+      # returned from this method is used to de-duplicate batch loads under the hood
+      # by using it as a Hash key.
+      #
+      # By default, the arguments are all put in an Array. To customize how this source's
+      # batches are merged, override this method to return something else.
+      #
+      # For example, if you pass `ActiveRecord::Relation`s to `.with(...)`, you could override
+      # 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]
+      def self.batch_key_for(*batch_args, **batch_kwargs)
+        [*batch_args, **batch_kwargs]
+      end
+
+      # Clear any already-loaded objects for this source
+      # @return [void]
+      def clear_cache
+        @results.clear
         nil
       end
 
+      attr_reader :pending, :results
+
       private
 
       # Reads and returns the result for the key from the internal cache, or raises an error if the result was an error
@@ -96,6 +178,13 @@ module GraphQL
       # @return [Object] The result from {#fetch} for `key`.
       # @api private
       def result_for(key)
+        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})
+
+This key should have been loaded already. This is a bug in GraphQL::Dataloader, please report it on GitHub: https://github.com/rmosolgo/graphql-ruby/issues/new.
+ERR
+        end
         result = @results[key]
 
         raise result if result.class <= StandardError