Move error handling inline instead of using a block

Author: rmosolgo

lib/graphql/execution/interpreter/runtime.rb

@@ -498,13 +498,17 @@ def evaluate_selection_with_args(arguments, field_defn, next_path, ast_node, fie
             field_result = call_method_on_directives(:resolve, object, directives) do
               # Actually call the field resolver and capture the result
               app_result = begin
-                query.with_error_handling do
-                  query.trace("execute_field", {owner: owner_type, field: field_defn, path: next_path, ast_node: ast_node, query: query, object: object, arguments: kwarg_arguments}) do
-                    field_defn.resolve(object, kwarg_arguments, context)
-                  end
+                query.trace("execute_field", {owner: owner_type, field: field_defn, path: next_path, ast_node: ast_node, query: query, object: object, arguments: kwarg_arguments}) do
+                  field_defn.resolve(object, kwarg_arguments, context)
                 end
               rescue GraphQL::ExecutionError => err
                 err
+              rescue StandardError => err
+                begin
+                  query.handle_or_reraise(err)
+                rescue GraphQL::ExecutionError => ex_err
+                  ex_err
+                end
               end
               after_lazy(app_result, owner: owner_type, field: field_defn, path: next_path, ast_node: ast_node, owner_object: object, arguments: resolved_arguments, result_name: result_name, result: selection_result) do |inner_result|
                 continue_value = continue_value(next_path, inner_result, owner_type, field_defn, return_type.non_null?, ast_node, result_name, selection_result)
@@ -871,21 +875,21 @@ def after_lazy(lazy_obj, owner:, field:, path:, owner_object:, arguments:, ast_n
               # Wrap the execution of _this_ method with tracing,
               # but don't wrap the continuation below
               inner_obj = begin
-                query.with_error_handling do
-                  begin
-                    if trace
-                      query.trace("execute_field_lazy", {owner: owner, field: field, path: path, query: query, object: owner_object, arguments: arguments, ast_node: ast_node}) do
-                        schema.sync_lazy(lazy_obj)
-                      end
-                    else
-                      schema.sync_lazy(lazy_obj)
-                    end
-                  rescue GraphQL::ExecutionError, GraphQL::UnauthorizedError => err
-                    err
+                if trace
+                  query.trace("execute_field_lazy", {owner: owner, field: field, path: path, query: query, object: owner_object, arguments: arguments, ast_node: ast_node}) do
+                    schema.sync_lazy(lazy_obj)
                   end
+                else
+                  schema.sync_lazy(lazy_obj)
                 end
-              rescue GraphQL::ExecutionError => ex_err
+              rescue GraphQL::ExecutionError, GraphQL::UnauthorizedError => ex_err
                 ex_err
+              rescue StandardError => err
+                begin
+                  query.handle_or_reraise(err)
+                rescue GraphQL::ExecutionError => ex_err
+                  ex_err
+                end
               end
               yield(inner_obj)
             end

lib/graphql/query.rb

@@ -331,10 +331,8 @@ def subscription?
     end
 
     # @api private
-    def with_error_handling
-      schema.with_error_handling(context) do
-        yield
-      end
+    def handle_or_reraise(err)
+      schema.handle_or_reraise(context, err)
     end
 
     private

lib/graphql/query/null_context.rb

@@ -12,9 +12,6 @@ def visible_type_membership?(tm, ctx); true; end
       end
 
       class NullQuery
-        def with_error_handling
-          yield
-        end
       end
 
       class NullSchema < GraphQL::Schema

lib/graphql/schema.rb

@@ -713,26 +713,19 @@ def error_handlers
         }
       end
 
-      # Call the given block with the schema's configured error handlers.
-      #
-      # If the block returns a lazy value, it's not wrapped with error handling. That area will have to be wrapped itself.
-      #
-      # @param ctx [GraphQL::Query::Context]
-      # @return [Object] Either the result of the given block, or some object to replace the result, in case of error handling.
-      def with_error_handling(ctx)
-        yield
-      rescue StandardError => err
+      # @api private
+      def handle_or_reraise(context, err)
         handler = Execution::Errors.find_handler_for(self, err.class)
         if handler
-          runtime_info = ctx.namespace(:interpreter) || {}
+          runtime_info = context.namespace(:interpreter) || {}
           obj = runtime_info[:current_object]
           args = runtime_info[:current_arguments]
           args = args && args.keyword_arguments
           field = runtime_info[:current_field]
           if obj.is_a?(GraphQL::Schema::Object)
             obj = obj.object
           end
-          handler[:handler].call(err, obj, args, ctx, field)
+          handler[:handler].call(err, obj, args, context, field)
         else
           raise err
         end

lib/graphql/schema/argument.rb

@@ -247,24 +247,30 @@ def coerce_into_values(parent_object, values, context, argument_values)
         end
 
         loaded_value = nil
-        coerced_value = context.schema.with_error_handling(context) do
+        coerced_value = begin
           type.coerce_input(value, context)
+        rescue StandardError => err
+          context.schema.handle_or_reraise(context, err)
         end
 
         # If this isn't lazy, then the block returns eagerly and assigns the result here
         # If it _is_ lazy, then we write the lazy to the hash, then update it later
         argument_values[arg_key] = context.schema.after_lazy(coerced_value) do |resolved_coerced_value|
           if loads && !from_resolver?
-            loaded_value = context.query.with_error_handling do
+            loaded_value = begin
               load_and_authorize_value(owner, coerced_value, context)
+            rescue StandardError => err
+              context.schema.handle_or_reraise(context, err)
             end
           end
 
           maybe_loaded_value = loaded_value || resolved_coerced_value
           context.schema.after_lazy(maybe_loaded_value) do |resolved_loaded_value|
             owner.validate_directive_argument(self, resolved_loaded_value)
-            prepared_value = context.schema.with_error_handling(context) do
+            prepared_value = begin
               prepare_value(parent_object, resolved_loaded_value, context: context)
+            rescue StandardError => err
+              context.schema.handle_or_reraise(context, err)
             end
 
             # TODO code smell to access such a deeply-nested constant in a distant module

lib/graphql/schema/object.rb

@@ -51,12 +51,12 @@ def authorized_new(object, context)
           trace_payload = { context: context, type: self, object: object, path: context[:current_path] }
 
           maybe_lazy_auth_val = context.query.trace("authorized", trace_payload) do
-            context.query.with_error_handling do
-              begin
-                authorized?(object, context)
-              rescue GraphQL::UnauthorizedError => err
-                context.schema.unauthorized_object(err)
-              end
+            begin
+              authorized?(object, context)
+            rescue GraphQL::UnauthorizedError => err
+              context.schema.unauthorized_object(err)
+            rescue StandardError => err
+              context.query.handle_or_reraise(err)
             end
           end
 

lib/graphql/schema/scalar.rb

@@ -42,11 +42,11 @@ def default_scalar?
 
         def validate_non_null_input(value, ctx)
           coerced_result = begin
-            ctx.query.with_error_handling do
-              coerce_input(value, ctx)
-            end
+            coerce_input(value, ctx)
           rescue GraphQL::CoercionError => err
             err
+          rescue StandardError => err
+            ctx.query.handle_or_reraise(err)
           end
 
           if coerced_result.nil?