refactor breadth interface to support argument errors.

Author: gmac

lib/graphql/execution/interpreter/runtime.rb

@@ -376,6 +376,8 @@ def evaluate_selection(result_name, field_ast_nodes_or_ast_node, selections_resu
         def evaluate_selection_with_args(arguments, field_defn, ast_node, field_ast_nodes, object, result_name, selection_result, runtime_state)  # rubocop:disable Metrics/ParameterLists
           after_lazy(arguments, field: field_defn, ast_node: ast_node, owner_object: object, arguments: arguments, result_name: result_name, result: selection_result, runtime_state: runtime_state) do |resolved_arguments, runtime_state|
             if resolved_arguments.is_a?(GraphQL::ExecutionError) || resolved_arguments.is_a?(GraphQL::UnauthorizedError)
+              next if selection_result.collect_result(result_name, resolved_arguments)
+
               return_type_non_null = field_defn.type.non_null?
               continue_value(resolved_arguments, field_defn, return_type_non_null, ast_node, result_name, selection_result)
               next
@@ -475,7 +477,8 @@ def evaluate_selection_with_resolved_keyword_args(kwarg_arguments, resolved_argu
             end
             @current_trace.end_execute_field(field_defn, object, kwarg_arguments, query, app_result)
             after_lazy(app_result, field: field_defn, ast_node: ast_node, owner_object: object, arguments: resolved_arguments, result_name: result_name, result: selection_result, runtime_state: runtime_state) do |inner_result, runtime_state|
-              next if exit_with_inner_result?(inner_result, result_name, selection_result)
+              next if selection_result.collect_result(result_name, inner_result)
+
               owner_type = selection_result.graphql_result_type
               return_type = field_defn.type
               continue_value = continue_value(inner_result, field_defn, return_type.non_null?, ast_node, result_name, selection_result)
@@ -496,11 +499,6 @@ def evaluate_selection_with_resolved_keyword_args(kwarg_arguments, resolved_argu
           end
         end
 
-        # Hook for breadth-first implementations to exit after a single resolver generation.
-        def exit_with_inner_result?(inner_result, result_name, selection_result)
-          false
-        end
-
         def set_result(selection_result, result_name, value, is_child_result, is_non_null)
           if !selection_result.graphql_dead
             if value.nil? && is_non_null

lib/graphql/execution/interpreter/runtime/graphql_result.rb

@@ -157,6 +157,11 @@ def fix_result_order
               end
             end
           end
+
+          # hook for breadth-first implementations to signal when collecting results.
+          def collect_result(result_name, result_value)
+            false
+          end
         end
 
         class GraphQLResultArray

spec/graphql/execution/breadth_runtime_spec.rb

@@ -8,6 +8,12 @@
   class SimpleBreadthRuntime < GraphQL::Execution::Interpreter::Runtime
     class BreadthObject < GraphQL::Execution::Interpreter::Runtime::GraphQLResultHash
       attr_accessor :breadth_index
+      attr_accessor :results_by_key
+
+      def collect_result(result_name, result_value)
+        results_by_key[result_name][breadth_index] = result_value
+        true
+      end
     end
 
     def initialize(query:)
@@ -22,26 +28,24 @@ def initialize(query:)
       @breadth_results_by_key = {}
     end
 
-    def run
-      result = nil
+    def run(&block)
       query.current_trace.execute_multiplex(multiplex: query.multiplex) do
-        query.current_trace.execute_query(query: query) do
-          result = yield
-        end
+        query.current_trace.execute_query(query: query, &block)
       end
-      result
     ensure
       delete_all_interpreter_context
     end
 
     def evaluate_breadth_selection(objects, parent_type, node)
       result_key = node.alias || node.name
       @breadth_results_by_key[result_key] = Array.new(objects.size)
+
       objects.each_with_index do |object, index|
         app_value = parent_type.wrap(object, query.context)
         breadth_object = BreadthObject.new(nil, parent_type, app_value, nil, false, node.selections, false, node, nil, nil)
         breadth_object.ordered_result_keys = []
         breadth_object.breadth_index = index
+        breadth_object.results_by_key = @breadth_results_by_key
 
         state = get_current_runtime_state
         state.current_result_name = nil
@@ -53,11 +57,6 @@ def evaluate_breadth_selection(objects, parent_type, node)
 
       @breadth_results_by_key[result_key]
     end
-
-    def exit_with_inner_result?(inner_result, result_key, breadth_object)
-      @breadth_results_by_key[result_key][breadth_object.breadth_index] = inner_result
-      true
-    end
   end
 
   class PassthroughLoader < GraphQL::Batch::Loader
@@ -169,6 +168,14 @@ def args(a:, b:)
       "#{a}#{b}"
     end
 
+    field :valid_args, String do |f|
+      f.argument :a, String, validates: { length: { is: 1 } }
+    end
+
+    def valid_args(a:)
+      a
+    end
+
     field :range, String do |f|
       f.argument :input, RangeInput
     end
@@ -268,6 +275,13 @@ def test_maps_basic_arguments_with_variables
     assert_equal ["fizzbuzz"], result
   end
 
+  def test_maps_invalidated_arguments
+    doc = %|query { validArgs(a: "boo") }|
+    result = map_breadth_objects([{}], doc)
+    assert result.first.is_a?(GraphQL::ExecutionError)
+    assert_equal "a is the wrong length (should be 1)", result.first.message
+  end
+
   def test_maps_prepared_input_object
     doc = %|{ range(input: { min: 1, max: 2 }) }|
     result = map_breadth_objects([{}], doc)