Improved exception handling

Author: syrusakbary

graphql/error.py

@@ -0,0 +1,6 @@
+from .base import GraphQLError
+from .located_error import GraphQLLocatedError
+from .syntax_error import GraphQLSyntaxError
+from .format_error import format_error
+
+__all__ = ['GraphQLError', 'GraphQLLocatedError', 'GraphQLSyntaxError', 'format_error']

graphql/error/__init__.py

@@ -0,0 +1,36 @@
+from ..language.location import get_location
+
+
+class GraphQLError(Exception):
+    __slots__ = 'message', 'nodes', 'stack', 'original_error', '_source', '_positions'
+
+    def __init__(self, message, nodes=None, stack=None, source=None, positions=None):
+        super(GraphQLError, self).__init__(message)
+        self.message = message
+        self.nodes = nodes
+        self.stack = stack
+        self._source = source
+        self._positions = positions
+
+    @property
+    def source(self):
+        if self._source:
+            return self._source
+        if self.nodes:
+            node = self.nodes[0]
+            return node and node.loc and node.loc.source
+
+    @property
+    def positions(self):
+        if self._positions:
+            return self._positions
+        if self.nodes is not None:
+            node_positions = [node.loc and node.loc.start for node in self.nodes]
+            if any(node_positions):
+                return node_positions
+
+    @property
+    def locations(self):
+        source = self.source
+        if self.positions and source:
+            return [get_location(source, pos) for pos in self.positions]

graphql/error/base.py

@@ -0,0 +1,11 @@
+def format_error(error):
+    formatted_error = {
+        'message': error.message,
+    }
+    if error.locations is not None:
+        formatted_error['locations'] = [
+            {'line': loc.line, 'column': loc.column}
+            for loc in error.locations
+        ]
+
+    return formatted_error

graphql/error/format_error.py

@@ -0,0 +1,26 @@
+import sys
+
+from .base import GraphQLError
+
+__all__ = ['GraphQLLocatedError']
+
+
+class GraphQLLocatedError(GraphQLError):
+
+    def __init__(self, nodes, original_error=None):
+        if original_error:
+            message = str(original_error)
+        else:
+            message = 'An unknown error occurred.'
+
+        if isinstance(original_error, GraphQLError):
+            stack = original_error.stack
+        else:
+            stack = sys.exc_info()[2]
+
+        super(GraphQLLocatedError, self).__init__(
+            message=message,
+            nodes=nodes,
+            stack=stack
+        )
+        self.original_error = original_error

graphql/error/located_error.py

@@ -1,14 +1,14 @@
-from ..error import GraphQLError
-from .location import get_location
+from ..language.location import get_location
+from .base import GraphQLError
 
-__all__ = ['LanguageError']
+__all__ = ['GraphQLSyntaxError']
 
 
-class LanguageError(GraphQLError):
+class GraphQLSyntaxError(GraphQLError):
 
     def __init__(self, source, position, description):
         location = get_location(source, position)
-        super(LanguageError, self).__init__(
+        super(GraphQLSyntaxError, self).__init__(
             message=u'Syntax Error {} ({}:{}) {}\n\n{}'.format(
                 source.name,
                 location.line,

graphql/language/error.py renamed to graphql/error/syntax_error.py

@@ -4,7 +4,7 @@
 
 from promise import Promise, is_thenable, promise_for_dict, promisify
 
-from ..error import GraphQLError
+from ..error import GraphQLError, GraphQLLocatedError
 from ..pyutils.default_ordered_dict import DefaultOrderedDict
 from ..type import (GraphQLEnumType, GraphQLInterfaceType, GraphQLList,
                     GraphQLNonNull, GraphQLObjectType, GraphQLScalarType,
@@ -226,11 +226,11 @@ def complete_value(exe_context, return_type, field_asts, info, result):
                 info,
                 resolved
             ),
-            lambda error: Promise.rejected(GraphQLError(error and str(error), field_asts, error))
+            lambda error: Promise.rejected(GraphQLLocatedError(field_asts, original_error=error))
         )
 
     if isinstance(result, Exception):
-        raise GraphQLError(str(result), field_asts, result)
+        raise GraphQLLocatedError(field_asts, original_error=result)
 
     if isinstance(return_type, GraphQLNonNull):
         completed = complete_value(

graphql/execution/executor.py

@@ -2,7 +2,7 @@
 
 from six import unichr
 
-from .error import LanguageError
+from ..error import GraphQLSyntaxError
 
 __all__ = ['Token', 'Lexer', 'TokenKind',
            'get_token_desc', 'get_token_kind_desc']
@@ -156,7 +156,7 @@ def read_token(source, from_position):
     code = char_code_at(body, position)
 
     if code < 0x0020 and code not in (0x0009, 0x000A, 0x000D):
-        raise LanguageError(
+        raise GraphQLSyntaxError(
             source, position,
             u'Invalid character {}.'.format(print_char_code(code))
         )
@@ -179,7 +179,7 @@ def read_token(source, from_position):
     elif code == 34:  # "
         return read_string(source, position)
 
-    raise LanguageError(
+    raise GraphQLSyntaxError(
         source, position,
         u'Unexpected character {}.'.format(print_char_code(code)))
 
@@ -241,7 +241,7 @@ def read_number(source, start, first_code):
         code = char_code_at(body, position)
 
         if code is not None and 48 <= code <= 57:
-            raise LanguageError(
+            raise GraphQLSyntaxError(
                 source,
                 position,
                 u'Invalid number, unexpected digit after 0: {}.'.format(print_char_code(code))
@@ -291,7 +291,7 @@ def read_digits(source, start, first_code):
 
         return position
 
-    raise LanguageError(
+    raise GraphQLSyntaxError(
         source,
         position,
         u'Invalid number, expected digit but got: {}.'.format(print_char_code(code))
@@ -338,7 +338,7 @@ def read_string(source, start):
             break
 
         if code < 0x0020 and code != 0x0009:
-            raise LanguageError(
+            raise GraphQLSyntaxError(
                 source,
                 position,
                 u'Invalid character within String: {}.'.format(print_char_code(code))
@@ -362,15 +362,15 @@ def read_string(source, start):
                 )
 
                 if char_code < 0:
-                    raise LanguageError(
+                    raise GraphQLSyntaxError(
                         source, position,
                         u'Invalid character escape sequence: \\u{}.'.format(body[position + 1: position + 5])
                     )
 
                 append(unichr(char_code))
                 position += 4
             else:
-                raise LanguageError(
+                raise GraphQLSyntaxError(
                     source, position,
                     u'Invalid character escape sequence: \\{}.'.format(unichr(code))
                 )
@@ -379,7 +379,7 @@ def read_string(source, start):
             chunk_start = position
 
     if code != 34:  # Quote (")
-        raise LanguageError(source, position, 'Unterminated string')
+        raise GraphQLSyntaxError(source, position, 'Unterminated string')
 
     append(body[chunk_start:position])
     return Token(TokenKind.STRING, start, position + 1, u''.join(value))

graphql/language/lexer.py

@@ -1,7 +1,7 @@
 from six import string_types
 
 from . import ast
-from .error import LanguageError
+from ..error import GraphQLSyntaxError
 from .lexer import Lexer, TokenKind, get_token_desc, get_token_kind_desc
 from .source import Source
 
@@ -109,7 +109,7 @@ def expect(parser, kind):
         advance(parser)
         return token
 
-    raise LanguageError(
+    raise GraphQLSyntaxError(
         parser.source,
         token.start,
         u'Expected {}, found {}'.format(
@@ -128,7 +128,7 @@ def expect_keyword(parser, value):
         advance(parser)
         return token
 
-    raise LanguageError(
+    raise GraphQLSyntaxError(
         parser.source,
         token.start,
         u'Expected "{}", found {}'.format(value, get_token_desc(token))
@@ -139,7 +139,7 @@ def unexpected(parser, at_token=None):
     """Helper function for creating an error when an unexpected lexed token
     is encountered."""
     token = at_token or parser.token
-    return LanguageError(
+    return GraphQLSyntaxError(
         parser.source,
         token.start,
         u'Unexpected {}'.format(get_token_desc(token))