Add dedicated object-related hooks

Author: rmosolgo

cop/development/trace_methods_cop.rb

@@ -36,6 +36,8 @@ class TraceMethodsCop < RuboCop::Cop::Base
         :execute_query,
         :execute_query_lazy,
         :lex,
+        :object_loaded,
+        :objects,
         :parse,
         :resolve_type,
         :resolve_type_lazy,

lib/graphql/execution/next/field_resolve_step.rb

@@ -598,6 +598,8 @@ def enqueue_next_steps
           if !@all_next_results.empty?
             @all_next_objects.compact!
 
+            query = @selections_step.query
+            ctx = query.context
             if @static_type.kind.abstract?
               next_objects_by_type = Hash.new { |h, obj_t| h[obj_t] = [] }.compare_by_identity
               next_results_by_type = Hash.new { |h, obj_t| h[obj_t] = [] }.compare_by_identity
@@ -607,33 +609,35 @@ def enqueue_next_steps
                 if (object_type = @runner.runtime_type_at[result])
                   # OK
                 else
-                  object_type = @runner.resolve_type(@static_type, next_object, @selections_step.query)
+                  object_type = @runner.resolve_type(@static_type, next_object, query)
                   @runner.runtime_type_at[result] = object_type
                 end
                 next_objects_by_type[object_type] << next_object
                 next_results_by_type[object_type] << result
               end
 
               next_objects_by_type.each do |obj_type, next_objects|
+                query.current_trace.objects(obj_type, next_objects, ctx)
                 @runner.add_step(SelectionsStep.new(
                   path: path,
                   parent_type: obj_type,
                   selections: @next_selections,
                   objects: next_objects,
                   results: next_results_by_type[obj_type],
                   runner: @runner,
-                  query: @selections_step.query,
+                  query: query,
                 ))
               end
             else
+              query.current_trace.objects(@static_type, @all_next_objects, ctx)
               @runner.add_step(SelectionsStep.new(
                 path: path,
                 parent_type: @static_type,
                 selections: @next_selections,
                 objects: @all_next_objects,
                 results: @all_next_results,
                 runner: @runner,
-                query: @selections_step.query,
+                query: query,
               ))
             end
           end

lib/graphql/execution/next/load_argument_step.rb

@@ -49,6 +49,8 @@ def assign_value
             @loaded_value.path = @field_resolve_step.path
             @field_resolve_step.arguments = @loaded_value
           else
+            query = @field_resolve_step.selections_step.query
+            query.current_trace.object_loaded(@argument_definition, @loaded_value, query.context)
             @arguments[@argument_key] = @loaded_value
           end
 

lib/graphql/execution/next/runner.rb

@@ -261,11 +261,14 @@ def begin_execute(isolated_steps, results, query, root_type, root_value)
 
             results << { "data" => data }
 
+            objects = [root_value]
+            query.current_trace.objects(root_type, objects, query.context)
+
             if query.query?
               isolated_steps[0] << SelectionsStep.new(
                 parent_type: root_type,
                 selections: query.selected_operation.selections,
-                objects: [root_value],
+                objects: objects,
                 results: [data],
                 path: beginning_path,
                 runner: self,
@@ -284,7 +287,7 @@ def begin_execute(isolated_steps, results, query, root_type, root_value)
                   clobber: false, # `data` is being shared among several selections steps
                   parent_type: root_type,
                   selections: field_resolve_step.ast_nodes || Array(field_resolve_step.ast_node),
-                  objects: [root_value],
+                  objects: objects,
                   results: [data],
                   path: beginning_path,
                   runner: self,
@@ -299,7 +302,7 @@ def begin_execute(isolated_steps, results, query, root_type, root_value)
               isolated_steps[0] << SelectionsStep.new(
                 parent_type: root_type,
                 selections: selected_operation.selections,
-                objects: [root_value],
+                objects: objects,
                 results: [data],
                 path: beginning_path,
                 runner: self,
@@ -318,7 +321,7 @@ def begin_execute(isolated_steps, results, query, root_type, root_value)
             isolated_steps[0] << SelectionsStep.new(
               parent_type: resolved_type,
               selections: query.selected_operation.selections,
-              objects: [root_value],
+              objects: objects,
               results: [data],
               path: beginning_path,
               runner: self,

lib/graphql/tracing/trace.rb

@@ -98,6 +98,12 @@ def authorized(query:, type:, object:)
         yield
       end
 
+      def objects(type, object, context)
+      end
+
+      def object_loaded(argument_definition, object, context)
+      end
+
       # A call to `.authorized?` is starting
       # @param type [Class<GraphQL::Schema::Object>]
       # @param object [Object]

spec/graphql/tracing/trace_spec.rb

@@ -8,4 +8,78 @@
     superable_methods_source = superable_methods.map { |m| "        #{m.inspect},\n" }.join
     assert_includes trace_source, superable_methods_source
   end
+
+
+  describe "object hooks" do
+    class ObjectHooksSchema < GraphQL::Schema
+      class Thing < GraphQL::Schema::Object
+        field :name, String
+      end
+
+      class Query < GraphQL::Schema::Object
+        field :things, [Thing], resolve_static: true
+
+        def self.things(context)
+          [OpenStruct.new(name: "Thing One"), OpenStruct.new(name: "Thing Two")]
+        end
+
+        field :thing, Thing, resolve_static: true do
+          argument :id, ID, loads: Thing, as: :thing
+        end
+
+        def self.thing(context, thing:)
+          thing
+        end
+
+        field :thing_name, String, resolve_static: true do
+          argument :thing_id, ID, loads: Thing
+        end
+
+        def self.thing_name(context, thing:)
+          thing.name
+        end
+      end
+
+      query(Query)
+      use GraphQL::Execution::Next
+
+      def self.object_from_id(id, ctx)
+        OpenStruct.new(name: "Thing ##{id}")
+      end
+
+      def self.resolve_type(abs_type, obj, ctx)
+        Thing
+      end
+
+      module LogTrace
+        def objects(type, objects, context)
+          context[:log] ||= []
+          context[:log] << "#{objects.size} objects as #{type.graphql_name}"
+          super
+        end
+
+        def object_loaded(argument_definition, object, context)
+          context[:log] ||= []
+          context[:log] << "#{argument_definition.path} loaded #{object.class}"
+          super
+        end
+      end
+
+      trace_with(LogTrace)
+    end
+
+    it "calls hooks with errors encountered during execution" do
+      res = ObjectHooksSchema.execute_next("{ things { name } }")
+      assert_equal ["Thing One", "Thing Two"], res["data"]["things"].map { |t| t["name"] }
+      assert_equal ["1 objects as Query", "2 objects as Thing"], res.context[:log]
+
+      res = ObjectHooksSchema.execute_next("{ thing(id: \"5\") { name } }")
+      assert_equal "Thing #5", res["data"]["thing"]["name"]
+      assert_equal ["1 objects as Query", "Query.thing.id loaded OpenStruct", "1 objects as Thing"], res.context[:log]
+
+      res = ObjectHooksSchema.execute_next("{ thingName(thingId: \"77\") }")
+      assert_equal "Thing #77", res["data"]["thingName"]
+      assert_equal ["1 objects as Query", "Query.thingName.thingId loaded OpenStruct"], res.context[:log]
+    end
+  end
 end