graphql 2.0.20 → 2.0.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7b2e44f17a5ec90e92b165e06f843931585a3775096c7404966a51703a65fdb9
-  data.tar.gz: b79ce54109470f38f6cd50cd8ff79af7beaefbea4564ec7e876c3a58ffd0249f
+  metadata.gz: 2564f5f0788db163950385832a4255c88b47b72ddb45175ec30f0f42c6dc0b04
+  data.tar.gz: c1760c1a43453ece3baed09bde3e30f6012bd4357ec597781e4616a7c67a2bc4
 SHA512:
-  metadata.gz: 59c16753d159b0d25862dfa72e84a72037e19da288db049297d90ede697d4b4eb0456b5bd9b65b7517ef1f375a94c9d0d3cb246a34f5b6100fc347665f94f688
-  data.tar.gz: 96fb931b54905ee12fd04ac76847e7f20c69f66023b6241e39e69b6de862b7cb8b7ff2dc4db53725e11b0625c55c2c73fbe070a4278ce6eb839a99c2847ac306
+  metadata.gz: 4e1d1747ceb4450228b9b7cb9b123f61585fe8eea3d6442627b56818f4a146e2b507e5a0b8665e25334a64dca79eb8a089c2aa0ff3e8d710fb6adec080623da0
+  data.tar.gz: f1ec3b93d97f4546184496aed5bc03d5ba1a5af1655aaeeb40ac20461e7c722431a116ca8e1a019d8b7e7eda59e7748f862985ea1dd131b3005ceb9ca3c9fa7c

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.rb

@@ -3,6 +3,7 @@ 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}.
   #
@@ -23,7 +24,7 @@ module GraphQL
     def_delegators :to_a, :each, :[]
 
     def self.use(schema_defn)
-      schema_defn.tracer(self::Tracer)
+      schema_defn.trace_with(self::Trace)
     end
 
     def initialize(context, value: nil)
@@ -54,5 +55,9 @@ module GraphQL
         @parent_frame = parent_frame
       end
     end
+
+    class DefaultBacktraceTrace < GraphQL::Tracing::Trace
+      include GraphQL::Backtrace::Trace
+    end
   end
 end

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

@@ -80,7 +80,7 @@ module GraphQL
           )
         end
 
-        NO_ARGS = {}.freeze
+        NO_ARGS = GraphQL::EmptyObjects::EMPTY_HASH
         EMPTY = self.new(argument_values: nil, keyword_arguments: NO_ARGS).freeze
       end
     end

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

@@ -7,57 +7,57 @@ module GraphQL
         def initialize(query)
           @query = query
           @dataloader = query.context.dataloader
-          @storage = Hash.new do |h, ast_node|
-            h[ast_node] = Hash.new do |h2, arg_owner|
-              h2[arg_owner] = Hash.new do |h3, parent_object|
-                dataload_for(ast_node, arg_owner, parent_object) do |kwarg_arguments|
-                  h3[parent_object] = @query.schema.after_lazy(kwarg_arguments) do |resolved_args|
-                    h3[parent_object] = resolved_args
-                  end
-                end
-
-                if !h3.key?(parent_object)
-                  # TODO should i bother putting anything here?
-                  h3[parent_object] = NO_ARGUMENTS
-                else
-                  h3[parent_object]
-                end
+          @storage = Hash.new do |h, argument_owner|
+            args_by_parent = if argument_owner.arguments_statically_coercible?
+              shared_values_cache = {}
+              Hash.new do |h2, ignored_parent_object|
+                h2[ignored_parent_object] = shared_values_cache
+              end
+            else
+              Hash.new do |h2, parent_object|
+                args_by_node = {}
+                args_by_node.compare_by_identity
+                h2[parent_object] = args_by_node
               end
             end
+            args_by_parent.compare_by_identity
+            h[argument_owner] = args_by_parent
           end
+          @storage.compare_by_identity
         end
 
         def fetch(ast_node, argument_owner, parent_object)
-          # If any jobs were enqueued, run them now,
-          # since this might have been called outside of execution.
-          # (The jobs are responsible for updating `result` in-place.)
-          if !@storage.key?(ast_node) || !@storage[ast_node].key?(argument_owner)
-            @dataloader.run_isolated do
-              @storage[ast_node][argument_owner][parent_object]
+          # This runs eagerly if no block is given
+          @storage[argument_owner][parent_object][ast_node] ||= begin
+            args_hash = self.class.prepare_args_hash(@query, ast_node)
+            kwarg_arguments = argument_owner.coerce_arguments(parent_object, args_hash, @query.context)
+            @query.after_lazy(kwarg_arguments) do |resolved_args|
+              @storage[argument_owner][parent_object][ast_node] = resolved_args
             end
           end
-          # Ack, the _hash_ is updated, but the key is eventually
-          # overridden with an immutable arguments instance.
-          # The first call queues up the job,
-          # then this call fetches the result.
-          # TODO this should be better, find a solution
-          # that works with merging the runtime.rb code
-          @storage[ast_node][argument_owner][parent_object]
+
         end
 
         # @yield [Interpreter::Arguments, Lazy<Interpreter::Arguments>] The finally-loaded arguments
         def dataload_for(ast_node, argument_owner, parent_object, &block)
           # First, normalize all AST or Ruby values to a plain Ruby hash
-          args_hash = self.class.prepare_args_hash(@query, ast_node)
-          argument_owner.coerce_arguments(parent_object, args_hash, @query.context, &block)
+          arg_storage = @storage[argument_owner][parent_object]
+          if (args = arg_storage[ast_node])
+            yield(args)
+          else
+            args_hash = self.class.prepare_args_hash(@query, ast_node)
+            argument_owner.coerce_arguments(parent_object, args_hash, @query.context) do |resolved_args|
+              arg_storage[ast_node] = resolved_args
+              yield(resolved_args)
+            end
+          end
           nil
         end
 
         private
 
-        NO_ARGUMENTS = {}.freeze
-
-        NO_VALUE_GIVEN = Object.new
+        NO_ARGUMENTS = GraphQL::EmptyObjects::EMPTY_HASH
+        NO_VALUE_GIVEN = NOT_CONFIGURED
 
         def self.prepare_args_hash(query, ast_arg_or_hash_or_value)
           case ast_arg_or_hash_or_value