graphql 1.10.2 → 2.0.21

data/lib/graphql/backtrace/trace.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+module GraphQL
+  class Backtrace
+    module Trace
+      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.
+        multiplex_context = multiplex.context
+        potential_context = multiplex_context[:last_graphql_backtrace_context]
+
+        if potential_context.is_a?(GraphQL::Query::Context) ||
+            potential_context.is_a?(Backtrace::Frame)
+          raise TracedError.new(err, potential_context)
+        else
+          raise
+        end
+      ensure
+        multiplex_context = multiplex.context
+        multiplex_context.delete(:graphql_backtrace_contexts)
+        multiplex_context.delete(:last_graphql_backtrace_context)
+      end
+
+      private
+
+      def push_query_backtrace_context(query)
+        push_data = query
+        multiplex = query.multiplex
+        push_key = []
+        push_storage = multiplex.context[:graphql_backtrace_contexts] ||= {}
+        push_storage[push_key] = push_data
+        multiplex.context[:last_graphql_backtrace_context] = push_data
+      end
+
+      def push_field_backtrace_context(field, query, ast_node, arguments, object)
+        multiplex = query.multiplex
+        push_key = query.context[:current_path]
+        push_storage = multiplex.context[:graphql_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
+        multiplex.context[:last_graphql_backtrace_context] = push_data
+      end
+    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,45 +1,75 @@
 # 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"
-          metadata[:context]
+          query = metadata[:query]
+          multiplex = query.multiplex
+          push_key = query.context[:current_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?(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

@@ -3,19 +3,19 @@ require "graphql/backtrace/inspect_result"
 require "graphql/backtrace/table"
 require "graphql/backtrace/traced_error"
 require "graphql/backtrace/tracer"
+require "graphql/backtrace/trace"
 module GraphQL
   # Wrap unhandled errors with {TracedError}.
   #
   # {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,8 @@ 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)
+      schema_defn.trace_with(self::Trace)
     end
 
     def initialize(context, value: nil)
@@ -51,5 +40,24 @@ 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
+
+    class DefaultBacktraceTrace < GraphQL::Tracing::Trace
+      include GraphQL::Backtrace::Trace
+    end
   end
 end

data/lib/graphql/dataloader/null_dataloader.rb

@@ -0,0 +1,24 @@
+# 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
+        raise GraphQL::Error, "GraphQL::Dataloader is not running -- add `use GraphQL::Dataloader` to your schema to use Dataloader sources."
+      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,164 @@
+# 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
+
+      # Add these key-value pairs to this source's cache
+      # (future loads will use these merged values).
+      # @param results [Hash<Object => Object>] key-value pairs to cache in this source
+      # @return [void]
+      def merge(results)
+        @results.merge!(results)
+        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
+        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