Merge pull request #4399 from rmosolgo/simplify-runtime-state

rmosolgo · web-flow · commit cb8a6f9e05ec · 2023-04-07T12:37:57.000-04:00
Use a dedicated object for runtime state
diff --git a/lib/graphql/execution/interpreter/runtime.rb b/lib/graphql/execution/interpreter/runtime.rb
@@ -8,6 +8,18 @@ class Interpreter
       #
       # @api private
       class Runtime
+        class CurrentState
+          def initialize
+            @current_object = nil
+            @current_field = nil
+            @current_arguments = nil
+            @current_result_name = nil
+            @current_result = nil
+          end
+
+          attr_accessor :current_result, :current_result_name,
+            :current_arguments, :current_field, :current_object
+        end
 
         module GraphQLResult
           def initialize(result_name, parent_result)
@@ -157,15 +169,6 @@ class GraphQLSelectionSet < Hash
         # @return [GraphQL::Query::Context]
         attr_reader :context
 
-        def thread_info
-          info = Thread.current[:__graphql_runtime_info]
-          if !info
-            new_ti = {}
-            info = Thread.current[:__graphql_runtime_info] = new_ti
-          end
-          info
-        end
-
         def initialize(query:, lazies_at_depth:)
           @query = query
           @dataloader = query.multiplex.dataloader
@@ -218,7 +221,9 @@ def run_eager
           root_operation = query.selected_operation
           root_op_type = root_operation.operation_type || "query"
           root_type = schema.root_type_for_operation(root_op_type)
-          set_all_interpreter_context(query.root_value, nil, nil, nil, @response)
+          st = get_current_runtime_state
+          st.current_object = query.root_value
+          st.current_result = @response
           object_proxy = authorized_new(root_type, query.root_value, context)
           object_proxy = schema.sync_lazy(object_proxy)
 
@@ -245,7 +250,10 @@ def run_eager
                 end
 
                 @dataloader.append_job {
-                  set_all_interpreter_context(query.root_value, nil, nil, nil, selection_response)
+                  st = get_current_runtime_state
+                  st.current_object = query.root_value
+                  st.current_result = selection_response
+
                   call_method_on_directives(:resolve, object_proxy, selections.graphql_directives) do
                     evaluate_selections(
                       object_proxy,
@@ -364,7 +372,10 @@ def gather_selections(owner_object, owner_type, selections, selections_to_run =
 
         # @return [void]
         def evaluate_selections(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, nil, selections_result)
+          st = get_current_runtime_state
+          st.current_object = owner_object
+          st.current_result_name = nil
+          st.current_result = selections_result
 
           finished_jobs = 0
           enqueued_jobs = gathered_selections.size
@@ -422,7 +433,11 @@ def evaluate_selection(result_name, field_ast_nodes_or_ast_node, owner_object, o
             (selections_result.graphql_non_null_field_names ||= []).push(result_name)
           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, result_name, selections_result)
+          st = get_current_runtime_state
+          st.current_field = field_defn
+          st.current_result = selections_result
+          st.current_result_name = result_name
+
           object = owner_object
 
           if is_introspection
@@ -489,8 +504,12 @@ def evaluate_selection_with_args(arguments, field_defn, ast_node, field_ast_node
               resolved_arguments.keyword_arguments
             end
 
-            set_all_interpreter_context(nil, nil, resolved_arguments, result_name, selection_result)
-
+            st = get_current_runtime_state
+            st.current_field = field_defn
+            st.current_object = object
+            st.current_arguments = resolved_arguments
+            st.current_result_name = result_name
+            st.current_result = selection_result
             # Optimize for the case that field is selected only once
             if field_ast_nodes.nil? || field_ast_nodes.size == 1
               next_selections = ast_node.selections
@@ -588,11 +607,10 @@ def set_graphql_dead(selection_result)
         end
 
         def current_path
-          ti = thread_info
-          path = ti &&
-            (result = ti[:current_result]) &&
-            (result.path)
-          if path && (rn = ti[:current_result_name])
+          st = get_current_runtime_state
+          result = st.current_result
+          path = result && result.path
+          if path && (rn = st.current_result_name)
             path = path.dup
             path.push(rn)
           end
@@ -769,8 +787,13 @@ def continue_field(value, owner_type, field, current_type, ast_node, next_select
                     this_result = response_hash
                     final_result = nil
                   end
-                  # Don't pass `result_name` here because it's already included in the new response hash
-                  set_all_interpreter_context(continue_value, nil, nil, nil, this_result) # reset this mutable state
+                  # reset this mutable state
+                  # Unset `result_name` here because it's already included in the new response hash
+                  st = get_current_runtime_state
+                  st.current_object = continue_value
+                  st.current_result_name = nil
+                  st.current_result = this_result
+
                   call_method_on_directives(:resolve, continue_value, selections.graphql_directives) do
                     evaluate_selections(
                       continue_value,
@@ -835,7 +858,9 @@ def continue_field(value, owner_type, field, current_type, ast_node, next_select
         end
 
         def resolve_list_item(inner_value, inner_type, 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, this_idx, response_list)
+          st = get_current_runtime_state
+          st.current_result_name = this_idx
+          st.current_result = response_list
           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, ast_node: ast_node, field: field, owner_object: owner_object, arguments: arguments, result_name: this_idx, result: response_list) do |inner_inner_value|
@@ -891,21 +916,8 @@ def directives_include?(node, graphql_object, parent_type)
           true
         end
 
-        def set_all_interpreter_context(object, field, arguments, result_name, result)
-          ti = thread_info
-          if object
-            ti[:current_object] = object
-          end
-          if field
-            ti[:current_field] = field
-          end
-          if arguments
-            ti[:current_arguments] = arguments
-          end
-          ti[:current_result_name] = result_name
-          if result
-            ti[:current_result] = result
-          end
+        def get_current_runtime_state
+          Thread.current[:__graphql_runtime_info] ||= CurrentState.new
         end
 
         # @param obj [Object] Some user-returned value that may want to be batched
@@ -917,7 +929,12 @@ def after_lazy(lazy_obj, owner:, field:, owner_object:, arguments:, ast_node:, r
           if lazy?(lazy_obj)
             orig_result = result
             lazy = GraphQL::Execution::Lazy.new(field: field) do
-              set_all_interpreter_context(owner_object, field, arguments, result_name, orig_result)
+              st = get_current_runtime_state
+              st.current_object = owner_object
+              st.current_field = field
+              st.current_arguments = arguments
+              st.current_result_name = result_name
+              st.current_result = orig_result
               # Wrap the execution of _this_ method with tracing,
               # but don't wrap the continuation below
               inner_obj = begin
@@ -953,7 +970,7 @@ def after_lazy(lazy_obj, owner:, field:, owner_object:, arguments:, ast_node:, r
               lazy
             end
           else
-            set_all_interpreter_context(owner_object, field, arguments, result_name, result)
+            # Don't need to reset state here because it _wasn't_ lazy.
             yield(lazy_obj)
           end
         end
@@ -968,13 +985,7 @@ def arguments(graphql_object, arg_owner, ast_node)
         end
 
         def delete_all_interpreter_context
-          if (ti = thread_info)
-            ti.delete(:current_result)
-            ti.delete(:current_result_name)
-            ti.delete(:current_field)
-            ti.delete(:current_object)
-            ti.delete(:current_arguments)
-          end
+          Thread.current[:__graphql_runtime_info] = nil
         end
 
         def resolve_type(type, value)
diff --git a/lib/graphql/query/context.rb b/lib/graphql/query/context.rb
@@ -226,8 +226,8 @@ def [](key)
           if key == :current_path
             current_path
           else
-            thread_info = Thread.current[:__graphql_runtime_info]
-            thread_info && thread_info[key]
+            (current_runtime_state = Thread.current[:__graphql_runtime_info]) &&
+              (current_runtime_state.public_send(key))
           end
         else
           # not found
@@ -236,11 +236,11 @@ def [](key)
       end
 
       def current_path
-        thread_info = Thread.current[:__graphql_runtime_info]
-        path = thread_info &&
-          (result = thread_info[:current_result]) &&
+        current_runtime_state = Thread.current[:__graphql_runtime_info]
+        path = current_runtime_state &&
+          (result = current_runtime_state.current_result) &&
           (result.path)
-        if path && (rn = thread_info[:current_result_name])
+        if path && (rn = current_runtime_state.current_result_name)
           path = path.dup
           path.push(rn)
         end
@@ -259,8 +259,8 @@ def delete(key)
 
       def fetch(key, default = UNSPECIFIED_FETCH_DEFAULT)
         if RUNTIME_METADATA_KEYS.include?(key)
-          (thread_info = Thread.current[:__graphql_runtime_info]) &&
-            thread_info[key]
+          (runtime = Thread.current[:__graphql_runtime_info]) &&
+            (runtime.public_send(key))
         elsif @scoped_context.key?(key)
           scoped_context[key]
         elsif @provided_values.key?(key)
@@ -276,8 +276,9 @@ def fetch(key, default = UNSPECIFIED_FETCH_DEFAULT)
 
       def dig(key, *other_keys)
         if RUNTIME_METADATA_KEYS.include?(key)
-          (thread_info = Thread.current[:__graphql_runtime_info]).key?(key) &&
-            thread_info.dig(key, *other_keys)
+          (current_runtime_state = Thread.current[:__graphql_runtime_info]) &&
+            (obj = current_runtime_state.public_send(key)) &&
+            obj.dig(*other_keys)
         elsif @scoped_context.key?(key)
           @scoped_context.dig(key, *other_keys)
         else
diff --git a/lib/graphql/schema/field.rb b/lib/graphql/schema/field.rb
@@ -608,15 +608,16 @@ def authorized?(object, args, context)
           # The resolver _instance_ will check itself during `resolve()`
           @resolver_class.authorized?(object, context)
         else
-          if (arg_values = context[:current_arguments])
-            # ^^ that's provided by the interpreter at runtime, and includes info about whether the default value was used or not.
-            using_arg_values = true
-            arg_values = arg_values.argument_values
-          else
-            arg_values = args
-            using_arg_values = false
-          end
           if args.size > 0
+            if (arg_values = context[:current_arguments])
+              # ^^ that's provided by the interpreter at runtime, and includes info about whether the default value was used or not.
+              using_arg_values = true
+              arg_values = arg_values.argument_values
+            else
+              arg_values = args
+              using_arg_values = false
+            end
+
             args = context.warden.arguments(self)
             args.each do |arg|
               arg_key = arg.keyword
diff --git a/spec/graphql/query/context_spec.rb b/spec/graphql/query/context_spec.rb
@@ -94,7 +94,7 @@ def push_query_error
 
     it "allows you to read values of contexts using dig" do
       assert_equal(1, context.dig(:a, :b))
-      Thread.current[:__graphql_runtime_info][:current_arguments] = { c: 1 }
+      Thread.current[:__graphql_runtime_info] = OpenStruct.new(current_arguments: {c: 1})
       assert_equal 1, context.dig(:current_arguments, :c)
     end
   end
@@ -111,7 +111,7 @@ def push_query_error
 
   it "can override values set by runtime" do
     context = GraphQL::Query::Context.new(query: OpenStruct.new(schema: schema), values: {a: {b: 1}}, object: nil)
-    Thread.current[:__graphql_runtime_info] = { current_object: :runtime_value }
+    Thread.current[:__graphql_runtime_info] = OpenStruct.new({ current_object: :runtime_value })
     assert_equal :runtime_value, context[:current_object]
     context[:current_object] = :override_value
     assert_equal :override_value, context[:current_object]
@@ -383,8 +383,9 @@ class ContextSchema < GraphQL::Schema
 
     it "always retrieves a scoped context value if set" do
       context = GraphQL::Query::Context.new(query: OpenStruct.new(schema: schema), values: nil, object: nil)
-      runtime_info = Thread.current[:__graphql_runtime_info] ||= {}
-      runtime_info[:current_result] = OpenStruct.new(path: ["somewhere"])
+      dummy_runtime = OpenStruct.new(current_result: nil)
+      Thread.current[:__graphql_runtime_info] = dummy_runtime
+      dummy_runtime.current_result = OpenStruct.new(path: ["somewhere"])
       expected_key = :a
       expected_value = :test
 
@@ -404,7 +405,7 @@ class ContextSchema < GraphQL::Schema
       assert_nil(context.fetch(expected_key))
       assert_nil(context.dig(expected_key)) if RUBY_VERSION >= '2.3.0'
 
-      runtime_info[:current_result] = OpenStruct.new(path: ["something", "new"])
+      dummy_runtime.current_result = OpenStruct.new(path: ["something", "new"])
 
       assert_equal(expected_value, context[expected_key])
       assert_equal({ expected_key => expected_value}, context.to_h)
@@ -413,15 +414,15 @@ class ContextSchema < GraphQL::Schema
       assert_equal(expected_value, context.dig(expected_key)) if RUBY_VERSION >= '2.3.0'
 
       # Enter a child field:
-      runtime_info[:current_result] = OpenStruct.new(path: ["somewhere", "child"])
+      dummy_runtime.current_result = OpenStruct.new(path: ["somewhere", "child"])
       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'
 
       # And a grandchild field
-      runtime_info[:current_result] = OpenStruct.new(path: ["somewhere", "child", "grandchild"])
+      dummy_runtime.current_result = OpenStruct.new(path: ["somewhere", "child", "grandchild"])
       context.scoped_set!(expected_key, :something_else)
       context.scoped_set!(:another_key, :another_value)
       assert_equal(:something_else, context[expected_key])
@@ -445,7 +446,7 @@ class ContextSchema < GraphQL::Schema
     it "has a #current_path method" do
       context = GraphQL::Query::Context.new(query: OpenStruct.new(schema: schema), values: nil, object: nil)
       current_result = OpenStruct.new(path: ["somewhere", "child", "grandchild"])
-      Thread.current[:__graphql_runtime_info][:current_result] = current_result
+      Thread.current[:__graphql_runtime_info] = OpenStruct.new(current_result: current_result)
       assert_equal ["somewhere", "child", "grandchild"], context.scoped_context.current_path
     end
   end
