Support finalizers which don't appear in the result; add some directive hooks; add Interface.resolver_methods

Author: rmosolgo

lib/graphql/execution.rb

@@ -14,7 +14,7 @@ class Skip < GraphQL::RuntimeError
       attr_accessor :path
       def ast_nodes=(_ignored); end
 
-      def assign_graphql_result(query, result_data, key)
+      def finalize_graphql_result(query, result_data, key)
         result_data.delete(key)
       end
     end

lib/graphql/execution/interpreter/handles_raw_value.rb

@@ -7,7 +7,7 @@ class Interpreter
       class RawValue
         include GraphQL::Execution::Next::Finalizer
 
-        def assign_graphql_result(query, result_data, result_key)
+        def finalize_graphql_result(query, result_data, result_key)
           result_data[result_key] = @object
         end
 

lib/graphql/execution/next.rb

@@ -70,7 +70,7 @@ def self.run_all(schema, query_options, context: {}, max_complexity: schema.max_
 
       module Finalizer
         attr_accessor :path
-        def assign_graphql_result(query, result_data, result_key)
+        def finalize_graphql_result(query, result_data, result_key)
           raise RequiredImplementationMissingError
         end
       end

lib/graphql/execution/next/field_resolve_step.rb

@@ -368,6 +368,37 @@ def execute_field
           end
 
           query.current_trace.begin_execute_field(@field_definition, @arguments, authorized_objects, query)
+
+          if @runner.uses_runtime_directives
+            if @ast_nodes.nil? || @ast_nodes.size == 1
+              directives = if @ast_node.directives.any?
+                @ast_node.directives
+              else
+                nil
+              end
+            else
+              directives = nil
+              @ast_nodes.each do |n|
+                if (d = n.directives).any? # rubocop:disable Development/NoneWithoutBlockCop
+                  directives ||= []
+                  directives.concat(d)
+                end
+              end
+            end
+
+            if directives
+              directives.each do |dir_node|
+                if (dir_defn = @runner.runtime_directives[dir_node.name])
+                  # Skip or include won't be present
+                  result = dir_defn.resolve_field(ast_nodes, @parent_type, field_definition, authorized_objects, @arguments, ctx)
+                  if result.is_a?(Finalizer)
+                    result.path = path
+                  end
+                end
+              end
+            end
+          end
+
           has_extensions = @field_definition.extensions.size > 0
           if has_extensions
             @extended = GraphQL::Schema::Field::ExtendedState.new(@arguments, authorized_objects)

lib/graphql/execution/next/runner.rb

@@ -12,6 +12,22 @@ def initialize(multiplex, authorization:)
           @selected_operation = nil
           @dataloader = multiplex.context[:dataloader] ||= @schema.dataloader_class.new
           @resolves_lazies = @schema.resolves_lazies?
+
+          @runtime_directives = nil
+          @schema.directives.each do |name, dir_class|
+            if dir_class.runtime? && name != "if" && name != "skip"
+              @runtime_directives ||= {}
+              @runtime_directives[dir_class.graphql_name] = dir_class
+            end
+          end
+
+          if @runtime_directives.nil?
+            @uses_runtime_directives = false
+            @runtime_directives = EmptyObjects::EMPTY_HASH
+          else
+            @uses_runtime_directives = true
+          end
+
           @lazy_cache = resolves_lazies ? {}.compare_by_identity : nil
           @authorization = authorization
           if @authorization
@@ -21,6 +37,8 @@ def initialize(multiplex, authorization:)
           end
         end
 
+        attr_reader :runtime_directives, :uses_runtime_directives
+
         def resolve_type(type, object, query)
           query.current_trace.begin_resolve_type(type, object, query.context)
           resolved_type, _ignored_new_value = query.resolve_type(type, object)
@@ -184,7 +202,7 @@ def execute
                 result
               else
                 data = result["data"]
-                data = run_finalizers(data, query)
+                data = run_finalizers(data, query, finalizers)
                 errors = []
                 query.context.errors.each do |err|
                   if err.respond_to?(:to_h)
@@ -207,9 +225,10 @@ def execute
           Fiber[:__graphql_current_multiplex] = nil
         end
 
-        def gather_selections(type_defn, ast_selections, selections_step, query, prototype_result, into:)
+        def gather_selections(type_defn, ast_selections, selections_step, query, all_selections, prototype_result, into:)
           ast_selections.each do |ast_selection|
             next if !directives_include?(query, ast_selection)
+
             case ast_selection
             when GraphQL::Language::Nodes::Field
               key = ast_selection.alias || ast_selection.name
@@ -227,13 +246,21 @@ def gather_selections(type_defn, ast_selections, selections_step, query, prototy
             when GraphQL::Language::Nodes::InlineFragment
               type_condition = ast_selection.type&.name
               if type_condition.nil? || type_condition_applies?(query.context, type_defn, type_condition)
-                gather_selections(type_defn, ast_selection.selections, selections_step, query, prototype_result, into: into)
+                if uses_runtime_directives && ast_selection.directives.any?
+                  all_selections << (into = { __node: ast_selection })
+                  all_selections << (prototype_result = {})
+                end
+                gather_selections(type_defn, ast_selection.selections, selections_step, query, all_selections, prototype_result, into: into)
               end
             when GraphQL::Language::Nodes::FragmentSpread
-              fragment_definition = query.document.definitions.find { |defn| defn.is_a?(GraphQL::Language::Nodes::FragmentDefinition) && defn.name == ast_selection.name }
+              fragment_definition = query.fragments[ast_selection.name]
               type_condition = fragment_definition.type.name
               if type_condition_applies?(query.context, type_defn, type_condition)
-                gather_selections(type_defn, fragment_definition.selections, selections_step, query, prototype_result, into: into)
+                if uses_runtime_directives && ast_selection.directives.any?
+                  all_selections << (into = { __node: ast_selection })
+                  all_selections << (prototype_result = {})
+                end
+                gather_selections(type_defn, fragment_definition.selections, selections_step, query, all_selections, prototype_result, into: into)
               end
             else
               raise ArgumentError, "Unsupported graphql selection node: #{ast_selection.class} (#{ast_selection.inspect})"
@@ -252,8 +279,8 @@ def lazy?(object)
 
         private
 
-        def run_finalizers(data, query)
-          paths_to_check = query.finalizers.map(&:path)
+        def run_finalizers(data, query, finalizers)
+          paths_to_check = finalizers.map(&:path)
           paths_to_check.compact! # root-level auth errors currently come without a path
           # TODO dry with above?
           # This is also where a query-level "Step" would be used?
@@ -266,11 +293,19 @@ def run_finalizers(data, query)
             when "subscription"
               query.schema.subscription
             end
-            check_object_result(query, data, root_type, selected_operation.selections, [], [], paths_to_check)
+            paths_to_check.each_with_index do |path_to_check, idx|
+              if path_to_check.empty?
+                finalizer = finalizers[idx]
+                # Path is already `[]`
+                finalizer.finalize_graphql_result(query, data, nil)
+                finalizers[idx] = nil
+              end
+            end
+            check_object_result(query, data, root_type, selected_operation.selections, [], [], paths_to_check, finalizers)
           end
         end
 
-        def check_object_result(query, result_h, static_type, ast_selections, current_exec_path, current_result_path, paths_to_check)
+        def check_object_result(query, result_h, static_type, ast_selections, current_exec_path, current_result_path, paths_to_check, finalizers) # rubocop:disable Metrics/ParameterLists
           current_path_len = current_exec_path.length
           ast_selections.each do |ast_selection|
             case ast_selection
@@ -279,7 +314,15 @@ def check_object_result(query, result_h, static_type, ast_selections, current_ex
                 key = ast_selection.alias || ast_selection.name
                 current_exec_path << key
                 current_result_path << key
-                if paths_to_check.any? { |path_to_check| path_to_check[current_path_len] == key }
+                this_finalizer_idx = nil
+                should_continue = false
+                paths_to_check.each_with_index do |path_to_check, idx|
+                  if this_finalizer_idx.nil? && current_exec_path == path_to_check
+                    this_finalizer_idx = idx
+                  end
+                  should_continue ||= path_to_check[current_path_len] == key
+                end
+                if should_continue
                   result_value = result_h[key]
                   field_defn = query.context.types.field(static_type, ast_selection.name)
                   result_type = field_defn.type
@@ -289,13 +332,20 @@ def check_object_result(query, result_h, static_type, ast_selections, current_ex
 
                   new_result_value = if result_value.is_a?(Finalizer)
                     result_value.path = current_result_path.dup
-                    result_value.assign_graphql_result(query, result_h, key)
+                    result_value.finalize_graphql_result(query, result_h, key)
                     result_h.key?(key) ? result_h[key] : :unassigned
+                  elsif this_finalizer_idx
+                    if (finalizer = finalizers[this_finalizer_idx])
+                      finalizer.path = current_result_path.dup
+                      finalizer.finalize_graphql_result(query, result_h, key)
+                      finalizers[this_finalizer_idx] = nil
+                    end
+                    result_value
                   else
                     if result_type.list?
-                      check_list_result(query, result_value, result_type.of_type, ast_selection.selections, current_exec_path, current_result_path, paths_to_check)
+                      check_list_result(query, result_value, result_type.of_type, ast_selection.selections, current_exec_path, current_result_path, paths_to_check, finalizers)
                     elsif !result_type.kind.leaf?
-                      check_object_result(query, result_value, result_type, ast_selection.selections, current_exec_path, current_result_path, paths_to_check)
+                      check_object_result(query, result_value, result_type, ast_selection.selections, current_exec_path, current_result_path, paths_to_check, finalizers)
                     else
                       result_value
                     end
@@ -315,22 +365,22 @@ def check_object_result(query, result_h, static_type, ast_selections, current_ex
               end
             when Language::Nodes::InlineFragment
               static_type_at_result = @static_type_at[result_h]
-              if static_type_at_result && type_condition_applies?(query.context, static_type_at_result, ast_selection.type.name)
-                result_h = check_object_result(query, result_h, static_type, ast_selection.selections, current_exec_path, current_result_path, paths_to_check)
+              if static_type_at_result && ((t = ast_selection.type).nil? || type_condition_applies?(query.context, static_type_at_result, t.name))
+                result_h = check_object_result(query, result_h, static_type, ast_selection.selections, current_exec_path, current_result_path, paths_to_check, finalizers)
               end
             when Language::Nodes::FragmentSpread
               fragment_defn = query.document.definitions.find { |defn| defn.is_a?(Language::Nodes::FragmentDefinition) && defn.name == ast_selection.name }
               static_type_at_result = @static_type_at[result_h]
               if static_type_at_result && type_condition_applies?(query.context, static_type_at_result, fragment_defn.type.name)
-                result_h = check_object_result(query, result_h, static_type, fragment_defn.selections, current_exec_path, current_result_path, paths_to_check)
+                result_h = check_object_result(query, result_h, static_type, fragment_defn.selections, current_exec_path, current_result_path, paths_to_check, finalizers)
               end
             end
           end
 
           result_h
         end
 
-        def check_list_result(query, result_arr, inner_type, ast_selections, current_exec_path, current_result_path, paths_to_check)
+        def check_list_result(query, result_arr, inner_type, ast_selections, current_exec_path, current_result_path, paths_to_check, finalizers) # rubocop:disable Metrics/ParameterLists
           inner_type_non_null = false
           if inner_type.non_null?
             inner_type_non_null = true
@@ -342,12 +392,12 @@ def check_list_result(query, result_arr, inner_type, ast_selections, current_exe
             current_result_path << idx
             new_result = if result_item.is_a?(Finalizer)
               result_item.path = current_result_path.dup
-              result_item.assign_graphql_result(query, result_arr, idx)
+              result_item.finalize_graphql_result(query, result_arr, idx)
               result_arr[idx]
             elsif inner_type.list?
-              check_list_result(query, result_item, inner_type.of_type, ast_selections, current_exec_path, current_result_path, paths_to_check)
+              check_list_result(query, result_item, inner_type.of_type, ast_selections, current_exec_path, current_result_path, paths_to_check, finalizers)
             elsif !inner_type.kind.leaf?
-              check_object_result(query, result_item, inner_type, ast_selections, current_exec_path, current_result_path, paths_to_check)
+              check_object_result(query, result_item, inner_type, ast_selections, current_exec_path, current_result_path, paths_to_check, finalizers)
             else
               result_item
             end

lib/graphql/execution/next/selections_step.rb

@@ -23,12 +23,39 @@ def graphql_objects
         end
 
         def call
-          grouped_selections = {}
-          prototype_result = @results.first
-          @runner.gather_selections(@parent_type, @selections, self, self.query, prototype_result, into: grouped_selections)
-          @results.each { |r| r.replace(prototype_result) }
-          grouped_selections.each_value do |frs|
-            @runner.add_step(frs)
+          all_selections = [{}, {}]
+          @runner.gather_selections(@parent_type, @selections, self, self.query, all_selections, all_selections[1], into: all_selections[0])
+          replaced = false
+          all_selections.each_slice(2) do |(grouped_selections, prototype_result)|
+            if !replaced
+              replaced = true
+              @results.each { |r| r.replace(prototype_result) }
+            else
+              # TODO -- this is here to keep response order the same.
+              # Should there only be a single prototype_result instead?
+              # Or should it not do this here?
+              @results.each { |r| r.merge!(prototype_result) }
+            end
+            if (directives_owner = grouped_selections.delete(:__node))
+              directives = directives_owner.directives
+              directives.each do |dir_node|
+                dir_defn = @runner.runtime_directives[dir_node.name]
+                result = case directives_owner
+                when Language::Nodes::FragmentSpread
+                  dir_defn.resolve_fragment_spread(directives_owner, @parent_type, @objects, self.query.context)
+                when Language::Nodes::InlineFragment
+                  dir_defn.resolve_inline_fragment(directives_owner, @parent_type, @objects, self.query.context)
+                else
+                  raise ArgumentError, "Unhandled directive owner (#{directives_owner.class}): #{directives_owner.inspect}"
+                end
+                if result.is_a?(Finalizer)
+                  result.path = path
+                end
+              end
+            end
+            grouped_selections.each_value do |frs|
+              @runner.add_step(frs)
+            end
           end
         end
       end

lib/graphql/execution_error.rb

@@ -36,7 +36,7 @@ def initialize(message, ast_node: nil, ast_nodes: nil, options: nil, extensions:
       super(message)
     end
 
-    def assign_graphql_result(query, result_data, key)
+    def finalize_graphql_result(query, result_data, key)
       result_data[key] = nil
     end
 

lib/graphql/schema/directive.rb

@@ -31,17 +31,25 @@ def default_graphql_name
 
         def locations(*new_locations)
           if !new_locations.empty?
+            is_runtime = false
             new_locations.each do |new_loc|
-              if !LOCATIONS.include?(new_loc.to_sym)
+              loc_sym = new_loc.to_sym
+              if !LOCATIONS.include?(loc_sym)
                 raise ArgumentError, "#{self} (#{self.graphql_name}) has an invalid directive location: `locations #{new_loc}` "
               end
+              is_runtime ||= RUNTIME_LOCATIONS.include?(loc_sym)
             end
             @locations = new_locations
+            @is_runtime = is_runtime
           else
             @locations ||= (superclass.respond_to?(:locations) ? superclass.locations : [])
           end
         end
 
+        def runtime?
+          @is_runtime
+        end
+
         def default_directive(new_default_directive = nil)
           if new_default_directive != nil
             @default_directive = new_default_directive
@@ -106,6 +114,9 @@ def inherited(subclass)
           super
           subclass.class_exec do
             @default_graphql_name ||= nil
+            @locations = locations
+            @is_runtime = runtime?
+            @repeatable = false
           end
         end
       end
@@ -177,13 +188,16 @@ def graphql_name
       end
 
       LOCATIONS = [
-        QUERY =                  :QUERY,
-        MUTATION =               :MUTATION,
-        SUBSCRIPTION =           :SUBSCRIPTION,
-        FIELD =                  :FIELD,
-        FRAGMENT_DEFINITION =    :FRAGMENT_DEFINITION,
-        FRAGMENT_SPREAD =        :FRAGMENT_SPREAD,
-        INLINE_FRAGMENT =        :INLINE_FRAGMENT,
+        *(RUNTIME_LOCATIONS = [
+          QUERY =                  :QUERY,
+          MUTATION =               :MUTATION,
+          SUBSCRIPTION =           :SUBSCRIPTION,
+          FIELD =                  :FIELD,
+          FRAGMENT_DEFINITION =    :FRAGMENT_DEFINITION,
+          FRAGMENT_SPREAD =        :FRAGMENT_SPREAD,
+          INLINE_FRAGMENT =        :INLINE_FRAGMENT,
+          VARIABLE_DEFINITION =    :VARIABLE_DEFINITION,
+        ]),
         SCHEMA =                 :SCHEMA,
         SCALAR =                 :SCALAR,
         OBJECT =                 :OBJECT,
@@ -195,7 +209,6 @@ def graphql_name
         ENUM_VALUE =             :ENUM_VALUE,
         INPUT_OBJECT =           :INPUT_OBJECT,
         INPUT_FIELD_DEFINITION = :INPUT_FIELD_DEFINITION,
-        VARIABLE_DEFINITION =    :VARIABLE_DEFINITION,
       ]
 
       DEFAULT_DEPRECATION_REASON = 'No longer supported'