class GraphQL::Schema::RescueMiddleware

  • If no handler is found, re-raise the error
    - If a handler is found, use it & return a {GraphQL::ExecutionError}
    - Rescue errors in a middleware chain, then check for a handler
    - Store a table of errors & handlers

def attempt_rescue(err) 

def attempt_rescue(err)
  rescue_table.each { |klass, handler|
    if klass.is_a?(Class) && err.is_a?(klass) && handler
      result = handler.call(err)
      case result
      when String
        return GraphQL::ExecutionError.new(result)
      when GraphQL::ExecutionError
        return result
      end
    end
  }
  raise(err)
end

def call(*args)

Implement the requirement for {GraphQL::Schema::MiddlewareChain} 
def call(*args)
  begin
    yield
  rescue StandardError => err
    attempt_rescue(err)
  end
end

def initialize 

def initialize
  @rescue_table = {}
end

def remove_handler(*error_classes)

Parameters:
  • error_class (Class) -- the error class whose handler should be removed 
def remove_handler(*error_classes)
  error_classes.map{ |error_class| rescue_table.delete(error_class) }
end

def rescue_from(*error_classes, &block)

Other tags:
    Yieldreturn: - message to put in GraphQL response

Other tags:
    Yieldparam: an - error that was rescued

Other tags:
    Yield: - A handler to return a message for these error instances

Parameters:
  • error_classes (Class) -- one or more classes of errors to rescue from

Other tags:
    Example: Rescue from not-found by telling the user - 
def rescue_from(*error_classes, &block)
  error_classes.map{ |error_class| rescue_table[error_class] = block }
end