Use inspect() instead of repr() for error messages (#12)

We don't want to leak too much of the inner representation
of Python objects in the client-facing error messages.

Author: Cito

README.md

@@ -12,7 +12,7 @@ a query language for APIs created by Facebook.
 [![Python 3 Status](https://pyup.io/repos/github/graphql-python/graphql-core-next/python-3-shield.svg)](https://pyup.io/repos/github/graphql-python/graphql-core-next/)
 
 The current version 1.0.1 of GraphQL-core-next is up-to-date with GraphQL.js version
-14.0.2. All parts of the API are covered by an extensive test suite of currently 1655
+14.0.2. All parts of the API are covered by an extensive test suite of currently 1656
 unit tests.
 
 

graphql/execution/execute.py

@@ -27,7 +27,7 @@
     SelectionSetNode,
 )
 from .middleware import MiddlewareManager
-from ..pyutils import is_invalid, is_nullish, MaybeAwaitable
+from ..pyutils import inspect, is_invalid, is_nullish, MaybeAwaitable
 from ..utilities import get_operation_root_type, type_from_ast
 from ..type import (
     GraphQLAbstractType,
@@ -234,7 +234,7 @@ def build(
                 raise TypeError(
                     "Middleware must be passed as a list or tuple of functions"
                     " or objects, or as a single MiddlewareManager object."
-                    f" Got {middleware!r} instead."
+                    f" Got {inspect(middleware)} instead."
                 )
 
         for definition in document.definitions:
@@ -776,7 +776,9 @@ def complete_value(
             )
 
         # Not reachable. All possible output types have been considered.
-        raise TypeError(f"Cannot complete value of unexpected type {return_type}.")
+        raise TypeError(
+            f"Cannot complete value of unexpected type '{inspect(return_type)}'."
+        )
 
     def complete_list_value(
         self,
@@ -842,7 +844,8 @@ def complete_leaf_value(return_type: GraphQLLeafType, result: Any) -> Any:
         serialized_result = return_type.serialize(result)
         if is_invalid(serialized_result):
             raise TypeError(
-                f"Expected a value of type '{return_type}' but received: {result!r}"
+                f"Expected a value of type '{inspect(return_type)}'"
+                f" but received: {inspect(result)}"
             )
         return serialized_result
 
@@ -914,7 +917,7 @@ def ensure_valid_runtime_type(
                 f"Abstract type {return_type.name} must resolve"
                 " to an Object type at runtime"
                 f" for field {info.parent_type.name}.{info.field_name}"
-                f" with value {result!r}, received '{runtime_type}'."
+                f" with value {inspect(result)}, received '{inspect(runtime_type)}'."
                 f" Either the {return_type.name} type should provide"
                 ' a "resolve_type" function or each possible type should'
                 ' provide an "is_type_of" function.',
@@ -1084,7 +1087,8 @@ def invalid_return_type_error(
 ) -> GraphQLError:
     """Create a GraphQLError for an invalid return type."""
     return GraphQLError(
-        f"Expected value of type '{return_type.name}' but got: {result!r}.", field_nodes
+        f"Expected value of type '{return_type.name}' but got: {inspect(result)}.",
+        field_nodes,
     )
 
 

graphql/execution/values.py

@@ -15,6 +15,7 @@
     VariableNode,
     print_ast,
 )
+from ..pyutils import inspect
 from ..type import (
     GraphQLDirective,
     GraphQLField,
@@ -95,7 +96,7 @@ def get_variable_values(
                         for error in coercion_errors:
                             error.message = (
                                 f"Variable '${var_name}' got invalid"
-                                f" value {value!r}; {error.message}"
+                                f" value {inspect(value)}; {error.message}"
                             )
                         errors.extend(coercion_errors)
                     else:

graphql/language/parser.py

@@ -59,6 +59,7 @@
 from .lexer import Lexer, Token, TokenKind
 from .source import Source
 from ..error import GraphQLError, GraphQLSyntaxError
+from ..pyutils import inspect
 
 __all__ = ["parse", "parse_type", "parse_value"]
 
@@ -91,7 +92,7 @@ def parse(
     if isinstance(source, str):
         source = Source(source)
     elif not isinstance(source, Source):
-        raise TypeError(f"Must provide Source. Received: {source!r}")
+        raise TypeError(f"Must provide Source. Received: {inspect(source)}")
     lexer = Lexer(
         source,
         no_location=no_location,

graphql/language/visitor.py

@@ -10,7 +10,7 @@
     Union,
 )
 
-from ..pyutils import snake_to_camel
+from ..pyutils import inspect, snake_to_camel
 from . import ast
 
 from .ast import Node
@@ -210,9 +210,9 @@ def visit(root: Node, visitor: Visitor, visitor_keys=None) -> Node:
     dictionary visitor_keys mapping node kinds to node attributes.
     """
     if not isinstance(root, Node):
-        raise TypeError(f"Not an AST Node: {root!r}")
+        raise TypeError(f"Not an AST Node: {inspect(root)}")
     if not isinstance(visitor, Visitor):
-        raise TypeError(f"Not an AST Visitor class: {visitor!r}")
+        raise TypeError(f"Not an AST Visitor class: {inspect(visitor)}")
     if visitor_keys is None:
         visitor_keys = QUERY_DOCUMENT_KEYS
     stack: Any = None
@@ -280,7 +280,7 @@ def visit(root: Node, visitor: Visitor, visitor_keys=None) -> Node:
             result = None
         else:
             if not isinstance(node, Node):
-                raise TypeError(f"Not an AST Node: {node!r}")
+                raise TypeError(f"Not an AST Node: {inspect(node)}")
             visit_fn = visitor.get_visit_fn(node.kind, is_leaving)
             if visit_fn:
                 result = visit_fn(visitor, node, key, parent, path, ancestors)

graphql/pyutils/inspect.py

@@ -64,6 +64,13 @@ def inspect(value: Any) -> str:
     elif isgenerator(value):
         type_ = "generator"
     else:
+        # stringify (only) the well-known GraphQL types
+        from ..type import GraphQLNamedType, GraphQLScalarType, GraphQLWrappingType
+
+        if isinstance(
+            value, (GraphQLNamedType, GraphQLScalarType, GraphQLWrappingType)
+        ):
+            return str(value)
         try:
             name = type(value).__name__
             if not name or "<" in name or ">" in name:

graphql/type/definition.py

@@ -42,7 +42,7 @@
     UnionTypeExtensionNode,
     ValueNode,
 )
-from ..pyutils import MaybeAwaitable, cached_property
+from ..pyutils import MaybeAwaitable, cached_property, inspect
 from ..utilities.value_from_ast_untyped import value_from_ast_untyped
 
 if TYPE_CHECKING:  # pragma: no cover
@@ -344,6 +344,12 @@ def __init__(
         self.parse_value = parse_value or default_value_parser
         self.parse_literal = parse_literal or value_from_ast_untyped
 
+    def __str__(self):
+        return self.name
+
+    def __repr__(self):
+        return f"<{self.__class__.__name__}({self})>"
+
 
 def is_scalar_type(type_: Any) -> bool:
     return isinstance(type_, GraphQLScalarType)
@@ -400,7 +406,7 @@ def __init__(
         if resolve is not None and not callable(resolve):
             raise TypeError(
                 "Field resolver must be a function if provided, "
-                f" but got: {resolve!r}."
+                f" but got: {inspect(resolve)}."
             )
         if description is not None and not isinstance(description, str):
             raise TypeError("The description must be a string.")
@@ -576,7 +582,7 @@ def __init__(
         if is_type_of is not None and not callable(is_type_of):
             raise TypeError(
                 f"{name} must provide 'is_type_of' as a function,"
-                f" but got: {is_type_of!r}."
+                f" but got: {inspect(is_type_of)}."
             )
         if ast_node and not isinstance(ast_node, ObjectTypeDefinitionNode):
             raise TypeError(f"{name} AST node must be an ObjectTypeDefinitionNode.")
@@ -686,7 +692,7 @@ def __init__(
         if resolve_type is not None and not callable(resolve_type):
             raise TypeError(
                 f"{name} must provide 'resolve_type' as a function,"
-                f" but got: {resolve_type!r}."
+                f" but got: {inspect(resolve_type)}."
             )
         if ast_node and not isinstance(ast_node, InterfaceTypeDefinitionNode):
             raise TypeError(f"{name} AST node must be an InterfaceTypeDefinitionNode.")
@@ -784,7 +790,7 @@ def __init__(
         if resolve_type is not None and not callable(resolve_type):
             raise TypeError(
                 f"{name} must provide 'resolve_type' as a function,"
-                f" but got: {resolve_type!r}."
+                f" but got: {inspect(resolve_type)}."
             )
         if ast_node and not isinstance(ast_node, UnionTypeDefinitionNode):
             raise TypeError(f"{name} AST node must be a UnionTypeDefinitionNode.")

graphql/type/scalars.py

@@ -2,7 +2,7 @@
 from typing import Any
 
 from ..error import INVALID
-from ..pyutils import is_finite, is_integer
+from ..pyutils import inspect, is_finite, is_integer
 from ..language.ast import (
     BooleanValueNode,
     FloatValueNode,
@@ -51,20 +51,20 @@ def serialize_int(value: Any) -> int:
             if num != float_value:
                 raise ValueError
     except (OverflowError, ValueError, TypeError):
-        raise TypeError(f"Int cannot represent non-integer value: {value!r}")
+        raise TypeError(f"Int cannot represent non-integer value: {inspect(value)}")
     if not MIN_INT <= num <= MAX_INT:
         raise TypeError(
-            f"Int cannot represent non 32-bit signed integer value: {value!r}"
+            f"Int cannot represent non 32-bit signed integer value: {inspect(value)}"
         )
     return num
 
 
 def coerce_int(value: Any) -> int:
     if not is_integer(value):
-        raise TypeError(f"Int cannot represent non-integer value: {value!r}")
+        raise TypeError(f"Int cannot represent non-integer value: {inspect(value)}")
     if not MIN_INT <= value <= MAX_INT:
         raise TypeError(
-            f"Int cannot represent non 32-bit signed integer value: {value!r}"
+            f"Int cannot represent non 32-bit signed integer value: {inspect(value)}"
         )
     return int(value)
 
@@ -100,13 +100,13 @@ def serialize_float(value: Any) -> float:
         if not isfinite(num):
             raise ValueError
     except (ValueError, TypeError):
-        raise TypeError(f"Float cannot represent non numeric value: {value!r}")
+        raise TypeError(f"Float cannot represent non numeric value: {inspect(value)}")
     return num
 
 
 def coerce_float(value: Any) -> float:
     if not is_finite(value):
-        raise TypeError(f"Float cannot represent non numeric value: {value!r}")
+        raise TypeError(f"Float cannot represent non numeric value: {inspect(value)}")
     return float(value)
 
 
@@ -139,13 +139,13 @@ def serialize_string(value: Any) -> str:
     # do not serialize builtin types as strings, but allow serialization of custom
     # types via their `__str__` method
     if type(value).__module__ == "builtins":
-        raise TypeError(f"String cannot represent value: {value!r}")
+        raise TypeError(f"String cannot represent value: {inspect(value)}")
     return str(value)
 
 
 def coerce_string(value: Any) -> str:
     if not isinstance(value, str):
-        raise TypeError(f"String cannot represent a non string value: {value!r}")
+        raise TypeError(f"String cannot represent a non string value: {inspect(value)}")
     return value
 
 
@@ -173,12 +173,14 @@ def serialize_boolean(value: Any) -> bool:
         return value
     if is_finite(value):
         return bool(value)
-    raise TypeError(f"Boolean cannot represent a non boolean value: {value!r}")
+    raise TypeError(f"Boolean cannot represent a non boolean value: {inspect(value)}")
 
 
 def coerce_boolean(value: Any) -> bool:
     if not isinstance(value, bool):
-        raise TypeError(f"Boolean cannot represent a non boolean value: {value!r}")
+        raise TypeError(
+            f"Boolean cannot represent a non boolean value: {inspect(value)}"
+        )
     return value
 
 
@@ -206,13 +208,13 @@ def serialize_id(value: Any) -> str:
     # do not serialize builtin types as IDs, but allow serialization of custom types
     # via their `__str__` method
     if type(value).__module__ == "builtins":
-        raise TypeError(f"ID cannot represent value: {value!r}")
+        raise TypeError(f"ID cannot represent value: {inspect(value)}")
     return str(value)
 
 
 def coerce_id(value: Any) -> str:
     if not isinstance(value, str) and not is_integer(value):
-        raise TypeError(f"ID cannot represent value: {value!r}")
+        raise TypeError(f"ID cannot represent value: {inspect(value)}")
     if isinstance(value, float):
         value = int(value)
     return str(value)

graphql/type/validate.py

@@ -28,6 +28,7 @@
     is_union_type,
     is_required_argument,
 )
+from ..pyutils import inspect
 from ..utilities.assert_valid_name import is_valid_name_error
 from ..utilities.type_comparators import is_equal_type, is_type_sub_type_of
 from .directives import GraphQLDirective, is_directive
@@ -48,7 +49,7 @@ def validate_schema(schema: GraphQLSchema) -> List[GraphQLError]:
     """
     # First check to ensure the provided value is in fact a GraphQLSchema.
     if not is_schema(schema):
-        raise TypeError(f"Expected {schema!r} to be a GraphQL schema.")
+        raise TypeError(f"Expected {inspect(schema)} to be a GraphQL schema.")
 
     # If this Schema has already been validated, return the previous results.
     # noinspection PyProtectedMember
@@ -140,7 +141,7 @@ def validate_directives(self):
             # Ensure all directives are in fact GraphQL directives.
             if not is_directive(directive):
                 self.report_error(
-                    f"Expected directive but got: {directive!r}.",
+                    f"Expected directive but got: {inspect(directive)}.",
                     getattr(directive, "ast_node", None),
                 )
                 continue
@@ -168,7 +169,7 @@ def validate_directives(self):
                 if not is_input_type(arg.type):
                     self.report_error(
                         f"The type of @{directive.name}({arg_name}:)"
-                        f" must be Input Type but got: {arg.type!r}.",
+                        f" must be Input Type but got: {inspect(arg.type)}.",
                         get_directive_arg_type_node(directive, arg_name),
                     )
 
@@ -192,7 +193,7 @@ def validate_types(self):
             # Ensure all provided types are in fact GraphQL type.
             if not is_named_type(type_):
                 self.report_error(
-                    f"Expected GraphQL named type but got: {type_!r}.",
+                    f"Expected GraphQL named type but got: {inspect(type)}.",
                     type_.ast_node if type_ else None,
                 )
                 continue
@@ -253,7 +254,7 @@ def validate_fields(self, type_: Union[GraphQLObjectType, GraphQLInterfaceType])
             if not is_output_type(field.type):
                 self.report_error(
                     f"The type of {type_.name}.{field_name}"
-                    " must be Output Type but got: {field.type!r}.",
+                    " must be Output Type but got: {inspect(field.type)}.",
                     get_field_type_node(type_, field_name),
                 )
 
@@ -279,7 +280,7 @@ def validate_fields(self, type_: Union[GraphQLObjectType, GraphQLInterfaceType])
                     self.report_error(
                         "Field argument"
                         f" {type_.name}.{field_name}({arg_name}:)"
-                        f" must be Input Type but got: {arg.type!r}.",
+                        f" must be Input Type but got: {inspect(arg.type)}.",
                         get_field_arg_type_node(type_, field_name, arg_name),
                     )
 
@@ -289,7 +290,7 @@ def validate_object_interfaces(self, obj: GraphQLObjectType):
             if not is_interface_type(iface):
                 self.report_error(
                     f"Type {obj.name} must only implement Interface"
-                    f" types, it cannot implement {iface!r}.",
+                    f" types, it cannot implement {inspect(iface)}.",
                     get_implements_interface_node(obj, iface),
                 )
                 continue
@@ -450,7 +451,7 @@ def validate_input_fields(self, input_obj: GraphQLInputObjectType):
             if not is_input_type(field.type):
                 self.report_error(
                     f"The type of {input_obj.name}.{field_name}"
-                    f" must be Input Type but got: {field.type!r}.",
+                    f" must be Input Type but got: {inspect(field.type)}.",
                     field.ast_node.type if field.ast_node else None,
                 )
 

graphql/utilities/ast_from_value.py

@@ -14,7 +14,7 @@
     StringValueNode,
     ValueNode,
 )
-from ..pyutils import is_nullish, is_invalid
+from ..pyutils import inspect, is_nullish, is_invalid
 from ..type import (
     GraphQLID,
     GraphQLInputType,
@@ -124,6 +124,6 @@ def ast_from_value(value: Any, type_: GraphQLInputType) -> Optional[ValueNode]:
 
             return StringValueNode(value=serialized)
 
-        raise TypeError(f"Cannot convert value to AST: {serialized!r}")
+        raise TypeError(f"Cannot convert value to AST: {inspect(serialized)}")
 
-    raise TypeError(f"Unknown type: {type_!r}.")
+    raise TypeError(f"Unknown type: {inspect(type_)}.")