Merge pull request #2634 from lancelafontaine/master

Adds scoped context for propagating values specific to a field and its children

Author: Robert Mosolgo

lib/graphql/execution/interpreter/runtime.rb

@@ -58,7 +58,7 @@ def run_eager
             write_in_response(path, nil)
             nil
           else
-            evaluate_selections(path, object_proxy, root_type, root_operation.selections, root_operation_type: root_op_type)
+            evaluate_selections(path, context.scoped_context, object_proxy, root_type, root_operation.selections, root_operation_type: root_op_type)
             nil
           end
         end
@@ -118,7 +118,7 @@ def gather_selections(owner_object, owner_type, selections, selections_by_name)
           end
         end
 
-        def evaluate_selections(path, owner_object, owner_type, selections, root_operation_type: nil)
+        def evaluate_selections(path, scoped_context, owner_object, owner_type, selections, root_operation_type: nil)
           @interpreter_context[:current_object] = owner_object
           @interpreter_context[:current_path] = path
           selections_by_name = {}
@@ -163,6 +163,7 @@ def evaluate_selections(path, owner_object, owner_type, selections, root_operati
             @interpreter_context[:current_path] = next_path
             @interpreter_context[:current_field] = field_defn
 
+            context.scoped_context = scoped_context
             object = owner_object
 
             if is_introspection
@@ -221,7 +222,7 @@ def evaluate_selections(path, owner_object, owner_type, selections, root_operati
               rescue GraphQL::ExecutionError => err
                 err
               end
-              after_lazy(app_result, owner: owner_type, field: field_defn, path: next_path, owner_object: object, arguments: kwarg_arguments) do |inner_result|
+              after_lazy(app_result, owner: owner_type, field: field_defn, path: next_path, scoped_context: context.scoped_context, owner_object: object, arguments: kwarg_arguments) do |inner_result|
                 continue_value = continue_value(next_path, inner_result, field_defn, return_type.non_null?, ast_node)
                 if HALT != continue_value
                   continue_field(next_path, continue_value, field_defn, return_type, ast_node, next_selections, false, object, kwarg_arguments)
@@ -295,7 +296,7 @@ def continue_field(path, value, field, type, ast_node, next_selections, is_non_n
             r
           when "UNION", "INTERFACE"
             resolved_type_or_lazy = query.resolve_type(type, value)
-            after_lazy(resolved_type_or_lazy, owner: type, path: path, field: field, owner_object: owner_object, arguments: arguments) do |resolved_type|
+            after_lazy(resolved_type_or_lazy, owner: type, path: path, scoped_context: context.scoped_context, field: field, owner_object: owner_object, arguments: arguments) do |resolved_type|
               possible_types = query.possible_types(type)
 
               if !possible_types.include?(resolved_type)
@@ -315,12 +316,12 @@ def continue_field(path, value, field, type, ast_node, next_selections, is_non_n
             rescue GraphQL::ExecutionError => err
               err
             end
-            after_lazy(object_proxy, owner: type, path: path, field: field, owner_object: owner_object, arguments: arguments) do |inner_object|
+            after_lazy(object_proxy, owner: type, path: path, scoped_context: context.scoped_context, field: field, owner_object: owner_object, arguments: arguments) do |inner_object|
               continue_value = continue_value(path, inner_object, field, is_non_null, ast_node)
               if HALT != continue_value
                 response_hash = {}
                 write_in_response(path, response_hash)
-                evaluate_selections(path, continue_value, type, next_selections)
+                evaluate_selections(path, context.scoped_context, continue_value, type, next_selections)
                 response_hash
               end
             end
@@ -329,14 +330,15 @@ def continue_field(path, value, field, type, ast_node, next_selections, is_non_n
             write_in_response(path, response_list)
             inner_type = type.of_type
             idx = 0
+            scoped_context = context.scoped_context
             value.each do |inner_value|
               next_path = path.dup
               next_path << idx
               next_path.freeze
               idx += 1
               set_type_at_path(next_path, inner_type)
               # This will update `response_list` with the lazy
-              after_lazy(inner_value, owner: inner_type, path: next_path, field: field, owner_object: owner_object, arguments: arguments) do |inner_inner_value|
+              after_lazy(inner_value, owner: inner_type, path: next_path, scoped_context: scoped_context, field: field, owner_object: owner_object, arguments: arguments) do |inner_inner_value|
                 # reset `is_non_null` here and below, because the inner type will have its own nullability constraint
                 continue_value = continue_value(next_path, inner_inner_value, field, false, ast_node)
                 if HALT != continue_value
@@ -402,7 +404,7 @@ def resolve_if_late_bound_type(type)
         # @param field [GraphQL::Schema::Field]
         # @param eager [Boolean] Set to `true` for mutation root fields only
         # @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:, owner_object:, arguments:, eager: false)
+        def after_lazy(lazy_obj, owner:, field:, path:, scoped_context:, owner_object:, arguments:, eager: false)
           @interpreter_context[:current_object] = owner_object
           @interpreter_context[:current_arguments] = arguments
           @interpreter_context[:current_path] = path
@@ -413,6 +415,7 @@ def after_lazy(lazy_obj, owner:, field:, path:, owner_object:, arguments:, eager
               @interpreter_context[:current_field] = field
               @interpreter_context[:current_object] = owner_object
               @interpreter_context[:current_arguments] = arguments
+              context.scoped_context = scoped_context
               # Wrap the execution of _this_ method with tracing,
               # but don't wrap the continuation below
               inner_obj = begin
@@ -424,7 +427,7 @@ def after_lazy(lazy_obj, owner:, field:, path:, owner_object:, arguments:, eager
                 rescue GraphQL::ExecutionError, GraphQL::UnauthorizedError => err
                   yield(err)
               end
-              after_lazy(inner_obj, owner: owner, field: field, path: path, owner_object: owner_object, arguments: arguments, eager: eager) do |really_inner_obj|
+              after_lazy(inner_obj, owner: owner, field: field, path: path, scoped_context: context.scoped_context, owner_object: owner_object, arguments: arguments, eager: eager) do |really_inner_obj|
                 yield(really_inner_obj)
               end
             end

lib/graphql/query/context.rb

@@ -155,6 +155,7 @@ def initialize(query:, values: , object:)
         @path = []
         @value = nil
         @context = self # for SharedMethods
+        @scoped_context = {}
       end
 
       # @api private
@@ -163,15 +164,30 @@ def initialize(query:, values: , object:)
       # @api private
       attr_writer :value
 
-      def_delegators :@provided_values, :[], :[]=, :to_h, :to_hash, :key?, :fetch, :dig
-      def_delegators :@query, :trace, :interpreter?
+      # @api private
+      attr_accessor :scoped_context
 
-      # @!method [](key)
-      #   Lookup `key` from the hash passed to {Schema#execute} as `context:`
+      def_delegators :@provided_values, :[]=
+      def_delegators :to_h, :fetch, :dig
+      def_delegators :@query, :trace, :interpreter?
 
       # @!method []=(key, value)
       #   Reassign `key` to the hash passed to {Schema#execute} as `context:`
 
+      # 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]
+      end
+
+      def to_h
+        @provided_values.merge(@scoped_context)
+      end
+      alias :to_hash :to_h
+
+      def key?(key)
+        @scoped_context.key?(key) || @provided_values.key?(key)
+      end
 
       # @return [GraphQL::Schema::Warden]
       def warden
@@ -195,6 +211,15 @@ def received_null_child
         @value = nil
       end
 
+      def scoped_merge!(hash)
+        @scoped_context = @scoped_context.merge(hash)
+      end
+
+      def scoped_set!(key, value)
+        scoped_merge!(key => value)
+        nil
+      end
+
       class FieldResolutionContext
         include SharedMethods
         include Tracing::Traceable

spec/graphql/query/context_spec.rb

@@ -289,4 +289,233 @@
       assert_equal expected_values_with_nil, res["data"]["find"]["inspectContext"]
     end
   end
+
+  describe "scoped context" do
+    class LazyBlock
+      def initialize
+        @get_value = Proc.new
+      end
+
+      def value
+        @get_value.call
+      end
+    end
+
+    class ContextQuery < GraphQL::Schema::Object
+      field :get_scoped_context, String, null: true do
+        argument :key, String, required: true
+        argument :lazy, Boolean, required: false, default_value: false
+      end
+
+      def get_scoped_context(key:, lazy:)
+        result = LazyBlock.new {
+          context[key]
+        }
+        return result if lazy
+        result.value
+      end
+
+      field :set_scoped_context, ContextQuery, null: false do
+        argument :key, String, required: true
+        argument :value, String, required: true
+        argument :lazy, Boolean, required: false, default_value: false
+      end
+
+      def set_scoped_context(key:, value:, lazy:)
+        if lazy
+          LazyBlock.new {
+            context.scoped_merge!(key => value)
+            LazyBlock.new {
+              self
+            }
+          }
+        else
+          context.scoped_merge!(key => value)
+          self
+        end
+      end
+    end
+
+    class ContextSchema < GraphQL::Schema
+      use GraphQL::Execution::Interpreter
+      use GraphQL::Analysis::AST
+      query(ContextQuery)
+      lazy_resolve(LazyBlock, :value)
+    end
+
+    it "can be set and does not leak to sibling fields" do
+      query_str = %|
+        {
+          before: getScopedContext(key: "a")
+          firstSetOuter: setScopedContext(key: "a", value: "1") {
+            before: getScopedContext(key: "a")
+            setInner: setScopedContext(key: "a", value: "2") {
+              only: getScopedContext(key: "a")
+            }
+            after: getScopedContext(key: "a")
+          }
+          secondSetOuter: setScopedContext(key: "a", value: "3") {
+            before: getScopedContext(key: "a")
+            setInner: setScopedContext(key: "a", value: "4") {
+              only: getScopedContext(key: "a")
+            }
+            after: getScopedContext(key: "a")
+          }
+          after: getScopedContext(key: "a")
+        }
+      |
+
+      expected = {
+        'before' => nil,
+        'firstSetOuter' => {
+          'before' => '1',
+          'setInner' => {
+            'only' => '2',
+          },
+          'after' => '1',
+        },
+        'secondSetOuter' => {
+          'before' => '3',
+          'setInner' => {
+            'only' => '4',
+          },
+          'after' => '3',
+        },
+        'after' => nil,
+      }
+      result = ContextSchema.execute(query_str).to_h['data']
+      assert_equal(expected, result)
+    end
+
+    it "can be set and does not leak to sibling fields when all resolvers are lazy values" do
+      query_str = %|
+        {
+          before: getScopedContext(key: "a", lazy: true)
+          setOuter: setScopedContext(key: "a", value: "1", lazy: true) {
+            before: getScopedContext(key: "a", lazy: true)
+            setInner: setScopedContext(key: "a", value: "2", lazy: true) {
+              only: getScopedContext(key: "a", lazy: true)
+            }
+            after: getScopedContext(key: "a", lazy: true)
+          }
+          after: getScopedContext(key: "a", lazy: true)
+        }
+      |
+      expected = {
+        'before' => nil,
+        'setOuter' => {
+          'before' => '1',
+          'setInner' => {
+            'only' => '2',
+          },
+          'after' => '1',
+        },
+        'after' => nil,
+      }
+
+      result = ContextSchema.execute(query_str).to_h['data']
+      assert_equal(expected, result)
+    end
+
+    it "can be set and does not leak to sibling fields when all get resolvers are lazy values" do
+      query_str = %|
+        {
+          before: getScopedContext(key: "a", lazy: true)
+          setOuter: setScopedContext(key: "a", value: "1") {
+            before: getScopedContext(key: "a", lazy: true)
+            setInner: setScopedContext(key: "a", value: "2") {
+              only: getScopedContext(key: "a", lazy: true)
+            }
+            after: getScopedContext(key: "a", lazy: true)
+          }
+          after: getScopedContext(key: "a", lazy: true)
+        }
+      |
+      expected = {
+        'before' => nil,
+        'setOuter' => {
+          'before' => '1',
+          'setInner' => {
+            'only' => '2',
+          },
+          'after' => '1',
+        },
+        'after' => nil,
+      }
+
+      result = ContextSchema.execute(query_str).to_h['data']
+      assert_equal(expected, result)
+    end
+
+    it "can be set and does not leak to sibling fields when all set resolvers are lazy values" do
+      query_str = %|
+        {
+          before: getScopedContext(key: "a")
+          setOuter: setScopedContext(key: "a", value: "1", lazy: true) {
+            before: getScopedContext(key: "a")
+            setInner: setScopedContext(key: "a", value: "2", lazy: true) {
+              only: getScopedContext(key: "a")
+            }
+            after: getScopedContext(key: "a")
+          }
+          after: getScopedContext(key: "a")
+        }
+      |
+      expected = {
+        'before' => nil,
+        'setOuter' => {
+          'before' => '1',
+          'setInner' => {
+            'only' => '2',
+          },
+          'after' => '1',
+        },
+        'after' => nil,
+      }
+
+      result = ContextSchema.execute(query_str).to_h['data']
+      assert_equal(expected, result)
+    end
+
+    it "always retrieves a scoped context value if set" do
+      context = GraphQL::Query::Context.new(query: OpenStruct.new(schema: schema), values: nil, object: nil)
+      expected_key = :a
+      expected_value = :test
+
+      assert_equal(nil, context[expected_key])
+      assert_equal({}, context.to_h)
+      refute(context.key?(expected_key))
+      assert_raises(KeyError) { context.fetch(expected_key) }
+      assert_nil(context.fetch(expected_key, nil))
+      assert_nil(context.dig(expected_key)) if RUBY_VERSION >= '2.3.0'
+
+      context.scoped_merge!(expected_key => nil)
+      context[expected_key] = expected_value
+
+      assert_nil(context[expected_key])
+      assert_equal({ expected_key => nil }, context.to_h)
+      assert(context.key?(expected_key))
+      assert_nil(context.fetch(expected_key))
+      assert_nil(context.dig(expected_key)) if RUBY_VERSION >= '2.3.0'
+
+      context.scoped_context = {}
+
+      assert_equal(expected_value, context[expected_key])
+      assert_equal({ expected_key => expected_value}, context.to_h)
+      assert(context.key?(expected_key))
+      assert_equal(expected_value, context.fetch(expected_key))
+      assert_equal(expected_value, context.dig(expected_key)) if RUBY_VERSION >= '2.3.0'
+    end
+
+    it "sets a value using #scoped_set!" do
+      expected_key = :a
+      expected_value = :test
+
+      context = GraphQL::Query::Context.new(query: OpenStruct.new(schema: schema), values: nil, object: nil)
+      assert_nil(context[expected_key])
+
+      context.scoped_set!(expected_key, expected_value)
+      assert_equal(expected_value, context[expected_key])
+    end
+  end
 end