Migrate to RuntimeError for error checks, add Finalizers API

Author: rmosolgo

lib/graphql.rb

@@ -21,9 +21,6 @@ def self.eager_load!
   class Error < StandardError
   end
 
-  class RuntimeError < Error
-  end
-
   # This error is raised when GraphQL-Ruby encounters a situation
   # that it *thought* would never happen. Please report this bug!
   class InvariantError < Error
@@ -122,6 +119,7 @@ class << self
   autoload :ParseError, "graphql/parse_error"
   autoload :Backtrace, "graphql/backtrace"
 
+  autoload :RuntimeError, "graphql/runtime_error"
   autoload :UnauthorizedError, "graphql/unauthorized_error"
   autoload :UnauthorizedEnumValueError, "graphql/unauthorized_enum_value_error"
   autoload :UnauthorizedFieldError, "graphql/unauthorized_field_error"

lib/graphql/execution/next.rb

@@ -67,6 +67,13 @@ def self.run_all(schema, query_options, context: {}, max_complexity: schema.max_
         runner = Runner.new(multiplex, **schema.execution_next_options)
         runner.execute
       end
+
+      module Finalizer
+        attr_accessor :path
+        def assign_graphql_result(query, result_data, result_key)
+          raise RequiredImplementationMissingError
+        end
+      end
     end
   end
 end

lib/graphql/execution/next/field_resolve_step.rb

@@ -171,7 +171,7 @@ def coerce_argument_value(arguments, arg_defn, arg_value, run_loads, target_keyw
             end
           end
 
-          if arg_value.is_a?(GraphQL::Error)
+          if arg_value.is_a?(GraphQL::RuntimeError)
             @arguments = arg_value
           elsif run_loads && arg_defn.loads && as_type.nil? && !arg_value.nil?
             # This is for legacy compat:
@@ -292,7 +292,7 @@ def build_arguments
         def execute_field
           objects = @selections_step.objects
           # TODO not as good because only one error?
-          if @arguments.is_a?(GraphQL::Error)
+          if @arguments.is_a?(GraphQL::RuntimeError)
             @field_results = Array.new(objects.size, @arguments)
             @object_is_authorized = AlwaysAuthorized
             build_results
@@ -520,7 +520,7 @@ def build_results
                 else
                   nil
                 end
-              elsif field_result.is_a?(GraphQL::Error)
+              elsif field_result.is_a?(GraphQL::RuntimeError)
                 add_graphql_error(field_result)
               else
                 # TODO `nil`s in [T!] types aren't handled
@@ -596,7 +596,7 @@ def build_graphql_result(graphql_result, key, field_result, return_type, is_nn,
             else
               graphql_result[key] = nil
             end
-          elsif field_result.is_a?(GraphQL::Error)
+          elsif field_result.is_a?(GraphQL::RuntimeError)
             graphql_result[key] = add_graphql_error(field_result)
           elsif is_list
             if is_nn

lib/graphql/execution/next/load_argument_step.rb

@@ -45,7 +45,7 @@ def call
         private
 
         def assign_value
-          if @loaded_value.is_a?(GraphQL::Error)
+          if @loaded_value.is_a?(GraphQL::RuntimeError)
             @loaded_value.path = @field_resolve_step.path
             @field_resolve_step.arguments = @loaded_value
           else

lib/graphql/execution/next/prepare_object_step.rb

@@ -103,7 +103,7 @@ def create_result
               else
                 @graphql_result[@key] = @field_resolve_step.add_graphql_error(@authorization_error)
               end
-            rescue GraphQL::Error => err
+            rescue GraphQL::RuntimeError => err
               if @is_non_null
                 @graphql_result[@key] = @field_resolve_step.add_non_null_error(@is_from_array)
               else

lib/graphql/execution/next/runner.rb

@@ -184,7 +184,7 @@ def execute
                 result
               else
                 data = result["data"]
-                data = propagate_errors(data, query)
+                data = run_finalizers(data, query)
                 errors = []
                 query.context.errors.each do |err|
                   if err.respond_to?(:to_h)
@@ -252,8 +252,8 @@ def lazy?(object)
 
         private
 
-        def propagate_errors(data, query)
-          paths_to_check = query.context.errors.map(&:path)
+        def run_finalizers(data, query)
+          paths_to_check = query.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?
@@ -287,7 +287,7 @@ def check_object_result(query, result_h, static_type, ast_selections, current_ex
                     result_type = result_type.of_type
                   end
 
-                  new_result_value = if result_value.is_a?(GraphQL::Error)
+                  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_h.key?(key) ? result_h[key] : :unassigned
@@ -340,7 +340,7 @@ def check_list_result(query, result_arr, inner_type, ast_selections, current_exe
           new_invalid_null = false
           result_arr.each_with_index do |result_item, idx|
             current_result_path << idx
-            new_result = if result_item.is_a?(GraphQL::Error)
+            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_arr[idx]

lib/graphql/query.rb

@@ -298,6 +298,19 @@ def selected_operation
       with_prepared_ast { @selected_operation }
     end
 
+    # @return [Array<Execution::Next::Finalizer>]
+    def finalizers
+      @finalizers ? (@finalizers + context.errors) : context.errors
+    end
+
+    # @param finalizer [Execution::Next::Finalizer]
+    # @return [Execution::NextFinalizer] `finalizer`
+    def add_finalizer(finalizer)
+      f = @finalizers ||= []
+      f << finalizer
+      f
+    end
+
     # Determine the values for variables of this query, using default values
     # if a value isn't provided at runtime.
     #