Merge pull request #3950 from rmosolgo/scoped-context-refactor

Refactor & fix scoped context with dataloader

Author: rmosolgo

guides/queries/executing_queries.md

@@ -123,6 +123,53 @@ end
 
 Note that `context` is _not_ the hash that you passed it. It's an instance of {{ "GraphQL::Query::Context" | api_doc }}, but it delegates `#[]`, `#[]=`, and a few other methods to the hash you provide.
 
+### Scoped Context
+
+`context` is shared by the whole query. Anything you add to `context` will be accessible by any other field in the query (although GraphQL-Ruby's order of execution can vary).
+
+However, "scoped context" is can be used to assign values into `context` that are only available in the current field and the _children_ of the current field. For example, in this query:
+
+```graphql
+{
+  posts {
+    comments {
+      author
+      isOriginalPoster
+    }
+  }
+}
+```
+
+You could use "scoped context" to implement `isOriginalPoster`, based on the parent `comments` field.
+
+In `def comments`, add `:current_post` to scoped context using `context.scoped_set!`:
+
+```ruby
+class Types::Post < Types::BaseObject
+  # ...
+  def comments
+    context.scoped_set!(:current_post, object)
+    object.comments
+  end
+end
+```
+
+Then, inside `User`, you can check `context[:current_post]`:
+
+```ruby
+class Types::User < Types::BaseObject
+  # ...
+  def is_original_poster
+    current_post = context[:current_post]
+    current_post && current_post.author == object
+  end
+end
+```
+
+`context[:current_post]` will be present if an "upstream" field assigned it with `scoped_set!`.
+
+`context.scoped_merge!({ ... })` is also available for setting multiple keys at once.
+
 ## Root Value
 
 You can provide a root `object` value with `root_value:`. For example, to base the query off of the current organization:

lib/graphql/execution/interpreter/runtime.rb

@@ -230,7 +230,6 @@ def run_eager
                   call_method_on_directives(:resolve, object_proxy, selections.graphql_directives) do
                     evaluate_selections(
                       path,
-                      context.scoped_context,
                       object_proxy,
                       root_type,
                       root_op_type == "mutation",
@@ -349,15 +348,15 @@ def gather_selections(owner_object, owner_type, selections, selections_to_run =
         NO_ARGS = {}.freeze
 
         # @return [void]
-        def evaluate_selections(path, scoped_context, owner_object, owner_type, is_eager_selection, gathered_selections, selections_result, target_result, parent_object) # rubocop:disable Metrics/ParameterLists
+        def evaluate_selections(path, owner_object, owner_type, is_eager_selection, gathered_selections, selections_result, target_result, parent_object) # rubocop:disable Metrics/ParameterLists
           set_all_interpreter_context(owner_object, nil, nil, path)
 
           finished_jobs = 0
           enqueued_jobs = gathered_selections.size
           gathered_selections.each do |result_name, field_ast_nodes_or_ast_node|
             @dataloader.append_job {
               evaluate_selection(
-                path, result_name, field_ast_nodes_or_ast_node, scoped_context, owner_object, owner_type, is_eager_selection, selections_result, parent_object
+                path, result_name, field_ast_nodes_or_ast_node, owner_object, owner_type, is_eager_selection, selections_result, parent_object
               )
               finished_jobs += 1
               if target_result && finished_jobs == enqueued_jobs
@@ -372,7 +371,7 @@ def evaluate_selections(path, scoped_context, owner_object, owner_type, is_eager
         attr_reader :progress_path
 
         # @return [void]
-        def evaluate_selection(path, result_name, field_ast_nodes_or_ast_node, scoped_context, owner_object, owner_type, is_eager_field, selections_result, parent_object) # rubocop:disable Metrics/ParameterLists
+        def evaluate_selection(path, result_name, field_ast_nodes_or_ast_node, owner_object, owner_type, is_eager_field, selections_result, parent_object) # rubocop:disable Metrics/ParameterLists
           return if dead_result?(selections_result)
           # As a performance optimization, the hash key will be a `Node` if
           # there's only one selection of the field. But if there are multiple
@@ -414,8 +413,6 @@ def evaluate_selection(path, result_name, field_ast_nodes_or_ast_node, scoped_co
           end
           # Set this before calling `run_with_directives`, so that the directive can have the latest path
           set_all_interpreter_context(nil, field_defn, nil, next_path)
-
-          context.scoped_context = scoped_context
           object = owner_object
 
           if is_introspection
@@ -425,19 +422,18 @@ def evaluate_selection(path, result_name, field_ast_nodes_or_ast_node, scoped_co
           total_args_count = field_defn.arguments(context).size
           if total_args_count == 0
             resolved_arguments = GraphQL::Execution::Interpreter::Arguments::EMPTY
-            evaluate_selection_with_args(resolved_arguments, field_defn, next_path, ast_node, field_ast_nodes, scoped_context, owner_type, object, is_eager_field, result_name, selections_result, parent_object)
+            evaluate_selection_with_args(resolved_arguments, field_defn, next_path, ast_node, field_ast_nodes, owner_type, object, is_eager_field, result_name, selections_result, parent_object)
           else
             # TODO remove all arguments(...) usages?
             @query.arguments_cache.dataload_for(ast_node, field_defn, object) do |resolved_arguments|
-              evaluate_selection_with_args(resolved_arguments, field_defn, next_path, ast_node, field_ast_nodes, scoped_context, owner_type, object, is_eager_field, result_name, selections_result, parent_object)
+              evaluate_selection_with_args(resolved_arguments, field_defn, next_path, ast_node, field_ast_nodes, owner_type, object, is_eager_field, result_name, selections_result, parent_object)
             end
           end
         end
 
-        def evaluate_selection_with_args(arguments, field_defn, next_path, ast_node, field_ast_nodes, scoped_context, owner_type, object, is_eager_field, result_name, selection_result, parent_object)  # rubocop:disable Metrics/ParameterLists
-          context.scoped_context = scoped_context
+        def evaluate_selection_with_args(arguments, field_defn, next_path, ast_node, field_ast_nodes, owner_type, object, is_eager_field, result_name, selection_result, parent_object)  # rubocop:disable Metrics/ParameterLists
           return_type = field_defn.type
-          after_lazy(arguments, owner: owner_type, field: field_defn, path: next_path, ast_node: ast_node, scoped_context: context.scoped_context, owner_object: object, arguments: arguments, result_name: result_name, result: selection_result) do |resolved_arguments|
+          after_lazy(arguments, owner: owner_type, field: field_defn, path: next_path, ast_node: ast_node, owner_object: object, arguments: arguments, result_name: result_name, result: selection_result) do |resolved_arguments|
             if resolved_arguments.is_a?(GraphQL::ExecutionError) || resolved_arguments.is_a?(GraphQL::UnauthorizedError)
               continue_value(next_path, resolved_arguments, owner_type, field_defn, return_type.non_null?, ast_node, result_name, selection_result)
               next
@@ -510,7 +506,7 @@ def evaluate_selection_with_args(arguments, field_defn, next_path, ast_node, fie
               rescue GraphQL::ExecutionError => err
                 err
               end
-              after_lazy(app_result, owner: owner_type, field: field_defn, path: next_path, ast_node: ast_node, scoped_context: context.scoped_context, owner_object: object, arguments: resolved_arguments, result_name: result_name, result: selection_result) do |inner_result|
+              after_lazy(app_result, owner: owner_type, field: field_defn, path: next_path, ast_node: ast_node, owner_object: object, arguments: resolved_arguments, result_name: result_name, result: selection_result) do |inner_result|
                 continue_value = continue_value(next_path, inner_result, owner_type, field_defn, return_type.non_null?, ast_node, result_name, selection_result)
                 if HALT != continue_value
                   continue_field(next_path, continue_value, owner_type, field_defn, return_type, ast_node, next_selections, false, object, resolved_arguments, result_name, selection_result)
@@ -688,7 +684,7 @@ def continue_field(path, value, owner_type, field, current_type, ast_node, next_
             resolved_type_or_lazy, resolved_value = resolve_type(current_type, value, path)
             resolved_value ||= value
 
-            after_lazy(resolved_type_or_lazy, owner: current_type, path: path, ast_node: ast_node, scoped_context: context.scoped_context, field: field, owner_object: owner_object, arguments: arguments, trace: false, result_name: result_name, result: selection_result) do |resolved_type|
+            after_lazy(resolved_type_or_lazy, owner: current_type, path: path, ast_node: ast_node, field: field, owner_object: owner_object, arguments: arguments, trace: false, result_name: result_name, result: selection_result) do |resolved_type|
               possible_types = query.possible_types(current_type)
 
               if !possible_types.include?(resolved_type)
@@ -708,7 +704,7 @@ def continue_field(path, value, owner_type, field, current_type, ast_node, next_
             rescue GraphQL::ExecutionError => err
               err
             end
-            after_lazy(object_proxy, owner: current_type, path: path, ast_node: ast_node, scoped_context: context.scoped_context, field: field, owner_object: owner_object, arguments: arguments, trace: false, result_name: result_name, result: selection_result) do |inner_object|
+            after_lazy(object_proxy, owner: current_type, path: path, ast_node: ast_node, field: field, owner_object: owner_object, arguments: arguments, trace: false, result_name: result_name, result: selection_result) do |inner_object|
               continue_value = continue_value(path, inner_object, owner_type, field, is_non_null, ast_node, result_name, selection_result)
               if HALT != continue_value
                 response_hash = GraphQLResultHash.new(result_name, selection_result)
@@ -734,7 +730,6 @@ def continue_field(path, value, owner_type, field, current_type, ast_node, next_
                   call_method_on_directives(:resolve, continue_value, selections.graphql_directives) do
                     evaluate_selections(
                       path,
-                      context.scoped_context,
                       continue_value,
                       current_type,
                       false,
@@ -757,7 +752,6 @@ def continue_field(path, value, owner_type, field, current_type, ast_node, next_
             set_result(selection_result, result_name, response_list)
 
             idx = 0
-            scoped_context = context.scoped_context
             begin
               value.each do |inner_value|
                 break if dead_result?(response_list)
@@ -768,10 +762,10 @@ def continue_field(path, value, owner_type, field, current_type, ast_node, next_
                 idx += 1
                 if use_dataloader_job
                   @dataloader.append_job do
-                    resolve_list_item(inner_value, inner_type, next_path, ast_node, scoped_context, field, owner_object, arguments, this_idx, response_list, next_selections, owner_type)
+                    resolve_list_item(inner_value, inner_type, next_path, ast_node, field, owner_object, arguments, this_idx, response_list, next_selections, owner_type)
                   end
                 else
-                  resolve_list_item(inner_value, inner_type, next_path, ast_node, scoped_context, field, owner_object, arguments, this_idx, response_list, next_selections, owner_type)
+                  resolve_list_item(inner_value, inner_type, next_path, ast_node, field, owner_object, arguments, this_idx, response_list, next_selections, owner_type)
                 end
               end
             rescue NoMethodError => err
@@ -791,11 +785,11 @@ def continue_field(path, value, owner_type, field, current_type, ast_node, next_
           end
         end
 
-        def resolve_list_item(inner_value, inner_type, next_path, ast_node, scoped_context, field, owner_object, arguments, this_idx, response_list, next_selections, owner_type) # rubocop:disable Metrics/ParameterLists
+        def resolve_list_item(inner_value, inner_type, next_path, ast_node, field, owner_object, arguments, this_idx, response_list, next_selections, owner_type) # rubocop:disable Metrics/ParameterLists
           set_all_interpreter_context(nil, nil, nil, next_path)
           call_method_on_directives(:resolve_each, owner_object, ast_node.directives) do
             # This will update `response_list` with the lazy
-            after_lazy(inner_value, owner: inner_type, path: next_path, ast_node: ast_node, scoped_context: scoped_context, field: field, owner_object: owner_object, arguments: arguments, result_name: this_idx, result: response_list) do |inner_inner_value|
+            after_lazy(inner_value, owner: inner_type, path: next_path, ast_node: ast_node, field: field, owner_object: owner_object, arguments: arguments, result_name: this_idx, result: response_list) do |inner_inner_value|
               continue_value = continue_value(next_path, inner_inner_value, owner_type, field, inner_type.non_null?, ast_node, this_idx, response_list)
               if HALT != continue_value
                 continue_field(next_path, continue_value, owner_type, field, inner_type, ast_node, next_selections, false, owner_object, arguments, this_idx, response_list)
@@ -870,11 +864,10 @@ def set_all_interpreter_context(object, field, arguments, path)
         # @param eager [Boolean] Set to `true` for mutation root fields only
         # @param trace [Boolean] If `false`, don't wrap this with field tracing
         # @return [GraphQL::Execution::Lazy, Object] If loading `object` will be deferred, it's a wrapper over it.
-        def after_lazy(lazy_obj, owner:, field:, path:, scoped_context:, owner_object:, arguments:, ast_node:, result:, result_name:, eager: false, trace: true, &block)
+        def after_lazy(lazy_obj, owner:, field:, path:, owner_object:, arguments:, ast_node:, result:, result_name:, eager: false, trace: true, &block)
           if lazy?(lazy_obj)
             lazy = GraphQL::Execution::Lazy.new(path: path, field: field) do
               set_all_interpreter_context(owner_object, field, arguments, path)
-              context.scoped_context = scoped_context
               # Wrap the execution of _this_ method with tracing,
               # but don't wrap the continuation below
               inner_obj = begin

lib/graphql/query/context.rb

@@ -86,8 +86,83 @@ def initialize(query:, schema: query.schema, values:, object:)
         @errors = []
         @path = []
         @value = nil
-        @context = self # for SharedMethods
-        @scoped_context = {}
+        @context = self # for SharedMethods TODO delete sharedmethods
+        @scoped_context = ScopedContext.new(self)
+      end
+
+      class ScopedContext
+        def initialize(query_context)
+          @query_context = query_context
+          @path_contexts = {}
+          @no_path = [].freeze
+        end
+
+        def merged_context
+          merged_ctx = {}
+          each_present_path_ctx do |path_ctx|
+            merged_ctx = path_ctx.merge(merged_ctx)
+          end
+          merged_ctx
+        end
+
+        def merge!(hash)
+          current_ctx = @path_contexts[current_path] ||= {}
+          current_ctx.merge!(hash)
+        end
+
+        def current_path
+          @query_context.namespace(:interpreter)[:current_path] || @no_path
+        end
+
+        def key?(key)
+          each_present_path_ctx do |path_ctx|
+            if path_ctx.key?(key)
+              return true
+            end
+          end
+          false
+        end
+
+        def [](key)
+          each_present_path_ctx do |path_ctx|
+            if path_ctx.key?(key)
+              return path_ctx[key]
+            end
+          end
+          nil
+        end
+
+        def dig(key, *other_keys)
+          each_present_path_ctx do |path_ctx|
+            if path_ctx.key?(key)
+              found_value = path_ctx[key]
+              if other_keys.any?
+                return found_value.dig(*other_keys)
+              else
+                return found_value
+              end
+            end
+          end
+          nil
+        end
+
+        private
+
+        # Start at the current location,
+        # but look up the tree for previously-assigned scoped values
+        def each_present_path_ctx
+          search_path = current_path.dup
+          if (current_path_ctx = @path_contexts[search_path])
+            yield(current_path_ctx)
+          end
+
+          while search_path.size > 0
+            search_path.pop # look one level higher
+            if (search_path_ctx = @path_contexts[search_path])
+              yield(search_path_ctx)
+            end
+          end
+        end
       end
 
       # @return [Hash] A hash that will be added verbatim to the result hash, as `"extensions" => { ... }`
@@ -106,7 +181,7 @@ def dataloader
       attr_writer :value
 
       # @api private
-      attr_accessor :scoped_context
+      attr_reader :scoped_context
 
       def []=(key, value)
         @provided_values[key] = value
@@ -119,8 +194,11 @@ def []=(key, value)
 
       # Lookup `key` from the hash passed to {Schema#execute} as `context:`
       def [](key)
-        return @scoped_context[key] if @scoped_context.key?(key)
-        @provided_values[key]
+        if @scoped_context.key?(key)
+          @scoped_context[key]
+        else
+          @provided_values[key]
+        end
       end
 
       def delete(key)
@@ -135,7 +213,7 @@ def delete(key)
 
       def fetch(key, default = UNSPECIFIED_FETCH_DEFAULT)
         if @scoped_context.key?(key)
-          @scoped_context[key]
+          scoped_context[key]
         elsif @provided_values.key?(key)
           @provided_values[key]
         elsif default != UNSPECIFIED_FETCH_DEFAULT
@@ -148,12 +226,21 @@ def fetch(key, default = UNSPECIFIED_FETCH_DEFAULT)
       end
 
       def dig(key, *other_keys)
-        @scoped_context.key?(key) ? @scoped_context.dig(key, *other_keys) : @provided_values.dig(key, *other_keys)
+        if @scoped_context.key?(key)
+          @scoped_context.dig(key, *other_keys)
+        else
+          @provided_values.dig(key, *other_keys)
+        end
       end
 
       def to_h
-        @provided_values.merge(@scoped_context)
+        if (current_scoped_context = @scoped_context.merged_context)
+          @provided_values.merge(current_scoped_context)
+        else
+          @provided_values
+        end
       end
+
       alias :to_hash :to_h
 
       def key?(key)
@@ -185,7 +272,7 @@ def inspect
       end
 
       def scoped_merge!(hash)
-        @scoped_context = @scoped_context.merge(hash)
+        @scoped_context.merge!(hash)
       end
 
       def scoped_set!(key, value)