graphql 1.11.6 → 1.13.19

data/lib/graphql/backtrace/table.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# test_via: ../backtrace.rb
 module GraphQL
   class Backtrace
     # A class for turning a context into a human-readable table or array
@@ -79,6 +78,25 @@ module GraphQL
       # @return [Array] 5 items for a backtrace table (not `key`)
       def build_rows(context_entry, rows:, top: false)
         case context_entry
+        when Backtrace::Frame
+          field_alias = context_entry.ast_node.respond_to?(:alias) && context_entry.ast_node.alias
+          value = if top && @override_value
+            @override_value
+          else
+            value_at(@context.query.context.namespace(:interpreter)[: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, # rubocop:disable Development/ContextIsPassedCop -- unrelated method
+            Backtrace::InspectResult.inspect_result(value),
+          ]
+          if (parent = context_entry.parent_frame)
+            build_rows(parent, rows: rows)
+          else
+            rows
+          end
         when GraphQL::Query::Context::FieldResolutionContext
           ctx = context_entry
           field_name = "#{ctx.irep_node.owner_type.name}.#{ctx.field.name}"
@@ -112,16 +130,29 @@ module GraphQL
           if object.is_a?(GraphQL::Schema::Object)
             object = object.object
           end
+          value = value_at(context_entry.namespace(:interpreter)[:runtime], [])
           rows << [
             "#{position}",
             "#{op_type}#{op_name ? " #{op_name}" : ""}",
             "#{object.inspect}",
             query.variables.to_h.inspect,
-            Backtrace::InspectResult.inspect_result(query.context.value),
+            Backtrace::InspectResult.inspect_result(value),
           ]
         else
-          raise "Unexpected get_rows subject #{context_entry.inspect}"
+          raise "Unexpected get_rows subject #{context_entry.class} (#{context_entry.inspect})"
+        end
+      end
+
+      def value_at(runtime, path)
+        response = runtime.final_result
+        path.each do |key|
+          if response && (response = response[key])
+            next
+          else
+            break
+          end
         end
+        response
       end
     end
   end

data/lib/graphql/backtrace/traced_error.rb

@@ -1,5 +1,4 @@
 # frozen_string_literal: true
-# test_via: ../backtrace.rb
 module GraphQL
   class Backtrace
     # When {Backtrace} is enabled, raised errors are wrapped with {TracedError}.

data/lib/graphql/backtrace/tracer.rb

@@ -1,46 +1,76 @@
 # frozen_string_literal: true
 module GraphQL
   class Backtrace
+    # TODO this is not fiber-friendly
     module Tracer
       module_function
 
       # Implement the {GraphQL::Tracing} API.
       def trace(key, metadata)
-        push_data = case key
+        case key
         when "lex", "parse"
           # No context here, don't have a query yet
           nil
         when "execute_multiplex", "analyze_multiplex"
-          metadata[:multiplex].queries
+          # No query context yet
+          nil
         when "validate", "analyze_query", "execute_query", "execute_query_lazy"
-          metadata[:query] || metadata[:queries]
+          push_key = []
+          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"
-          # The interpreter passes `query:`, legacy passes `context:`
-          metadata[:context] || ((q = metadata[:query]) && q.context)
+          query = metadata[:query] || raise(ArgumentError, "Add `legacy: true` to use GraphQL::Backtrace without the interpreter runtime.")
+          multiplex = query.multiplex
+          push_key = metadata[:path]
+          parent_frame = multiplex.context[:graphql_backtrace_contexts][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: metadata[:ast_node],
+            field: metadata[:field],
+            object: metadata[:object],
+            arguments: metadata[:arguments],
+            parent_frame: parent_frame,
+          )
         else
           # Custom key, no backtrace data for this
           nil
         end
 
-        if push_data
-          Thread.current[:last_graphql_backtrace_context] = push_data
+        if push_data && multiplex
+          push_storage = multiplex.context[:graphql_backtrace_contexts] ||= {}
+          push_storage[push_key] = push_data
+          multiplex.context[:last_graphql_backtrace_context] = push_data
         end
 
         if key == "execute_multiplex"
+          multiplex_context = metadata[:multiplex].context
           begin
             yield
           rescue StandardError => err
             # This is an unhandled error from execution,
             # Re-raise it with a GraphQL trace.
-            potential_context = Thread.current[:last_graphql_backtrace_context]
+            potential_context = multiplex_context[:last_graphql_backtrace_context]
 
-            if potential_context.is_a?(GraphQL::Query::Context) || potential_context.is_a?(GraphQL::Query::Context::FieldResolutionContext)
+            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
               raise
             end
           ensure
-            Thread.current[:last_graphql_backtrace_context] = nil
+            multiplex_context.delete(:graphql_backtrace_contexts)
+            multiplex_context.delete(:last_graphql_backtrace_context)
           end
         else
           yield

data/lib/graphql/backtrace.rb

@@ -1,5 +1,6 @@
 # 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"
@@ -9,13 +10,12 @@ module GraphQL
   # {TracedError} provides a GraphQL backtrace with arguments and return values.
   # The underlying error is available as {TracedError#cause}.
   #
-  # WARNING: {.enable} is not threadsafe because {GraphQL::Tracing.install} is not threadsafe.
-  #
   # @example toggling backtrace annotation
-  #   # to enable:
-  #   GraphQL::Backtrace.enable
-  #   # later, to disable:
-  #   GraphQL::Backtrace.disable
+  #   class MySchema < GraphQL::Schema
+  #     if Rails.env.development? || Rails.env.test?
+  #       use GraphQL::Backtrace
+  #     end
+  #   end
   #
   class Backtrace
     include Enumerable
@@ -23,19 +23,13 @@ module GraphQL
 
     def_delegators :to_a, :each, :[]
 
-    def self.enable
-      warn("GraphQL::Backtrace.enable is deprecated, add `use GraphQL::Backtrace` to your schema definition instead.")
-      GraphQL::Tracing.install(Backtrace::Tracer)
-      nil
-    end
-
-    def self.disable
-      GraphQL::Tracing.uninstall(Backtrace::Tracer)
-      nil
-    end
-
-    def self.use(schema_defn)
-      schema_defn.tracer(self::Tracer)
+    def self.use(schema_defn, legacy: false)
+      tracer = if legacy
+        self::LegacyTracer
+      else
+        self::Tracer
+      end
+      schema_defn.tracer(tracer)
     end
 
     def initialize(context, value: nil)
@@ -51,5 +45,20 @@ module GraphQL
     def to_a
       @table.to_backtrace
     end
+
+    # Used for internal bookkeeping
+    # @api private
+    class Frame
+      attr_reader :path, :query, :ast_node, :object, :field, :arguments, :parent_frame
+      def initialize(path:, query:, ast_node:, object:, field:, arguments:, parent_frame:)
+        @path = path
+        @query = query
+        @ast_node = ast_node
+        @field = field
+        @object = object
+        @arguments = arguments
+        @parent_frame = parent_frame
+      end
+    end
   end
 end

data/lib/graphql/backwards_compatibility.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 module GraphQL
   # Helpers for migrating in a backwards-compatible way
+  # Remove this in GraphQL-Ruby 2.0, when all users of it will be gone.
   # @api private
   module BackwardsCompatibility
     module_function
@@ -21,7 +22,7 @@ module GraphQL
         backtrace = caller(0, 20)
         # Find the first line in the trace that isn't library internals:
         user_line = backtrace.find {|l| l !~ /lib\/graphql/ }
-        warn(message + "\n" + user_line + "\n")
+        GraphQL::Deprecation.warn(message + "\n" + user_line + "\n")
         wrapper = last ? LastArgumentsWrapper : FirstArgumentsWrapper
         wrapper.new(callable, from)
       else

data/lib/graphql/base_type.rb

@@ -8,7 +8,7 @@ module GraphQL
     include GraphQL::Define::InstanceDefinable
     include GraphQL::Relay::TypeExtensions
 
-    accepts_definitions :name, :description,
+    deprecated_accepts_definitions :name, :description,
         :introspection,
         :default_scalar,
         :default_relay,
@@ -41,7 +41,9 @@ module GraphQL
     alias :graphql_name :name
     # Future-compatible alias
     # @see {GraphQL::SchemaMember}
-    alias :graphql_definition :itself
+    def graphql_definition(silence_deprecation_warning: false)
+      itself
+    end
 
     def type_class
       metadata[:type_class]
@@ -194,7 +196,7 @@ module GraphQL
         resolve_related_type(Object.const_get(type_arg))
       else
         if type_arg.respond_to?(:graphql_definition)
-          type_arg.graphql_definition
+          type_arg.graphql_definition(silence_deprecation_warning: true)
         else
           type_arg
         end
@@ -224,7 +226,7 @@ module GraphQL
     private
 
     def warn_deprecated_coerce(alt_method_name)
-      warn("Coercing without a context is deprecated; use `#{alt_method_name}` if you don't want context-awareness")
+      GraphQL::Deprecation.warn("Coercing without a context is deprecated; use `#{alt_method_name}` if you don't want context-awareness")
     end
   end
 end

data/lib/graphql/boolean_type.rb

@@ -1,2 +1,2 @@
 # frozen_string_literal: true
-GraphQL::BOOLEAN_TYPE = GraphQL::Types::Boolean.graphql_definition
+GraphQL::BOOLEAN_TYPE = GraphQL::Types::Boolean.graphql_definition(silence_deprecation_warning: true)

data/lib/graphql/compatibility/execution_specification.rb

@@ -32,6 +32,7 @@ module GraphQL
       # @param execution_strategy [<#new, #execute>] An execution strategy class
       # @return [Class<Minitest::Test>] A test suite for this execution strategy
       def self.build_suite(execution_strategy)
+        GraphQL::Deprecation.warn "#{self} will be removed from GraphQL-Ruby 2.0. There is no replacement, please open an issue on GitHub if you need support."
         Class.new(Minitest::Test) do
           class << self
             attr_accessor :counter_schema, :specification_schema

data/lib/graphql/compatibility/lazy_execution_specification.rb

@@ -7,6 +7,8 @@ module GraphQL
       # @param execution_strategy [<#new, #execute>] An execution strategy class
       # @return [Class<Minitest::Test>] A test suite for this execution strategy
       def self.build_suite(execution_strategy)
+        GraphQL::Deprecation.warn "#{self} will be removed from GraphQL-Ruby 2.0. There is no replacement, please open an issue on GitHub if you need support."
+
         Class.new(Minitest::Test) do
           class << self
             attr_accessor :lazy_schema

data/lib/graphql/compatibility/query_parser_specification.rb

@@ -11,6 +11,8 @@ module GraphQL
       # @yieldreturn [GraphQL::Language::Nodes::Document]
       # @return [Class<Minitest::Test>] A test suite for this parse function
       def self.build_suite(&block)
+        GraphQL::Deprecation.warn "#{self} will be removed from GraphQL-Ruby 2.0. There is no replacement, please open an issue on GitHub if you need support."
+
         Class.new(Minitest::Test) do
           include QueryAssertions
           include ParseErrorSpecification

data/lib/graphql/compatibility/schema_parser_specification.rb

@@ -8,6 +8,8 @@ module GraphQL
       # @yieldreturn [GraphQL::Language::Nodes::Document]
       # @return [Class<Minitest::Test>] A test suite for this parse function
       def self.build_suite(&block)
+        GraphQL::Deprecation.warn "#{self} will be removed from GraphQL-Ruby 2.0. There is no replacement, please open an issue on GitHub if you need support."
+
         Class.new(Minitest::Test) do
           @@parse_fn = block
 

data/lib/graphql/dataloader/null_dataloader.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Dataloader
+    # The default implementation of dataloading -- all no-ops.
+    #
+    # The Dataloader interface isn't public, but it enables
+    # simple internal code while adding the option to add Dataloader.
+    class NullDataloader < Dataloader
+      # These are all no-ops because code was
+      # executed sychronously.
+      def run; end
+      def run_isolated; yield; end
+      def yield; end
+
+      def append_job
+        yield
+        nil
+      end
+    end
+  end
+end

data/lib/graphql/dataloader/request.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+module GraphQL
+  class Dataloader
+    # @see Source#request which returns an instance of this
+    class Request
+      def initialize(source, key)
+        @source = source
+        @key = key
+      end
+
+      # Call this method to cause the current Fiber to wait for the results of this request.
+      #
+      # @return [Object] the object loaded for `key`
+      def load
+        @source.load(@key)
+      end
+    end
+  end
+end

data/lib/graphql/dataloader/request_all.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+module GraphQL
+  class Dataloader
+    # @see Source#request_all which returns an instance of this.
+    class RequestAll < Request
+      def initialize(source, keys)
+        @source = source
+        @keys = keys
+      end
+
+      # 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`
+      def load
+        @source.load_all(@keys)
+      end
+    end
+  end
+end

data/lib/graphql/dataloader/source.rb

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+module GraphQL
+  class Dataloader
+    class Source
+      # Called by {Dataloader} to prepare the {Source}'s internal state
+      # @api private
+      def setup(dataloader)
+        # These keys have been requested but haven't been fetched yet
+        @pending_keys = []
+        # These keys have been passed to `fetch` but haven't been finished yet
+        @fetching_keys = []
+        # { key => result }
+        @results = {}
+        @dataloader = dataloader
+      end
+
+      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
+        end
+        Dataloader::Request.new(self, key)
+      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)
+      end
+
+      # @param key [Object] A loading key 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)
+        else
+          @pending_keys << key
+          sync
+          result_for(key)
+        end
+      end
+
+      # @param keys [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
+        end
+
+        keys.map { |k| result_for(k) }
+      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`.
+      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"
+      end
+
+      # 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
+        @dataloader.yield
+        iterations = 0
+        while pending_keys.any? { |k| !@results.key?(k) }
+          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."
+          end
+          @dataloader.yield
+        end
+        nil
+      end
+
+      # @return [Boolean] True if this source has any pending requests for data.
+      def pending?
+        !@pending_keys.empty?
+      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
+        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|
+          @results[key] = results[idx]
+        end
+        nil
+      rescue StandardError => error
+        fetch_keys.each { |key| @results[key] = error }
+      ensure
+        if fetch_keys
+          @fetching_keys -= fetch_keys
+        end
+      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
+
+      attr_reader :pending_keys
+
+      private
+
+      # 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)
+        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
+
+        result
+      end
+    end
+  end
+end