enum: serialize and parse_value/literal now throw on invalid values

Replicates graphql/graphql-js@8057e39

Author: Cito

src/graphql/type/definition.py

@@ -16,6 +16,7 @@
     overload,
 )
 
+from ..error import GraphQLError
 from ..language import (
     EnumTypeDefinitionNode,
     EnumValueDefinitionNode,
@@ -39,17 +40,19 @@
     UnionTypeDefinitionNode,
     UnionTypeExtensionNode,
     ValueNode,
+    print_ast,
 )
 from ..pyutils import (
     AwaitableOrValue,
     FrozenList,
     Path,
     cached_property,
+    did_you_mean,
     inspect,
     is_collection,
     is_description,
+    suggestion_list,
     Undefined,
-    UndefinedType,
 )
 from ..utilities.value_from_ast_untyped import value_from_ast_untyped
 
@@ -1100,40 +1103,56 @@ def _value_lookup(self) -> Dict[Any, str]:
                 pass  # ignore unhashable values
         return lookup
 
-    def serialize(self, output_value: Any) -> Union[str, None, UndefinedType]:
+    def serialize(self, output_value: Any) -> str:
         try:
-            return self._value_lookup.get(output_value, Undefined)
-        except TypeError:  # unhashable value
+            return self._value_lookup[output_value]
+        except KeyError:  # hashable value not found
+            pass
+        except TypeError:  # unhashable value, we need to scan all values
             for enum_name, enum_value in self.values.items():
                 if enum_value.value == output_value:
                     return enum_name
-        return Undefined
+        raise GraphQLError(
+            f"Enum '{self.name}' cannot represent value: {inspect(output_value)}"
+        )
 
     def parse_value(self, input_value: str) -> Any:
         if isinstance(input_value, str):
             try:
                 enum_value = self.values[input_value]
             except KeyError:
-                return Undefined
-            if enum_value.value is None or enum_value.value is Undefined:
-                return input_value
+                raise GraphQLError(
+                    f"Value '{input_value}' does not exist in '{self.name}' enum."
+                    + did_you_mean_enum_value(self, input_value)
+                )
             return enum_value.value
-        return Undefined
+        value_str = inspect(input_value)
+        raise GraphQLError(
+            f"Enum '{self.name}' cannot represent non-string value: {value_str}."
+            + did_you_mean_enum_value(self, value_str)
+        )
 
     def parse_literal(
         self, value_node: ValueNode, _variables: Optional[Dict[str, Any]] = None
     ) -> Any:
         # Note: variables will be resolved before calling this method.
         if isinstance(value_node, EnumValueNode):
-            value = value_node.value
             try:
-                enum_value = self.values[value]
+                enum_value = self.values[value_node.value]
             except KeyError:
-                return Undefined
-            if enum_value.value is None or enum_value.value is Undefined:
-                return value
+                value_str = print_ast(value_node)
+                raise GraphQLError(
+                    f"Value '{value_str}' does not exist in '{self.name}' enum."
+                    + did_you_mean_enum_value(self, value_str),
+                    value_node,
+                )
             return enum_value.value
-        return Undefined
+        value_str = print_ast(value_node)
+        raise GraphQLError(
+            f"Enum '{self.name}' cannot represent non-enum value: {value_str}."
+            + did_you_mean_enum_value(self, value_str),
+            value_node,
+        )
 
 
 def is_enum_type(type_: Any) -> bool:
@@ -1146,6 +1165,11 @@ def assert_enum_type(type_: Any) -> GraphQLEnumType:
     return cast(GraphQLEnumType, type_)
 
 
+def did_you_mean_enum_value(enum_type: GraphQLEnumType, unknown_value_str: str) -> str:
+    suggested_values = suggestion_list(unknown_value_str, enum_type.values)
+    return did_you_mean(suggested_values, "the enum value")
+
+
 class GraphQLEnumValue:
 
     value: Any

src/graphql/utilities/coerce_input_value.py

@@ -11,16 +11,14 @@
     Undefined,
 )
 from ..type import (
-    GraphQLEnumType,
     GraphQLInputObjectType,
     GraphQLInputType,
     GraphQLList,
     GraphQLScalarType,
-    is_enum_type,
+    is_leaf_type,
     is_input_object_type,
     is_list_type,
     is_non_null_type,
-    is_scalar_type,
     GraphQLNonNull,
 )
 
@@ -130,7 +128,7 @@ def coerce_input_value(
                 )
         return type_.out_type(coerced_dict)
 
-    if is_scalar_type(type_):
+    if is_leaf_type(type_):
         # Scalars determine if a value is valid via `parse_value()`, which can throw to
         # indicate failure. If it throws, maintain a reference to the original error.
         type_ = cast(GraphQLScalarType, type_)
@@ -156,23 +154,5 @@ def coerce_input_value(
             )
         return parse_result
 
-    if is_enum_type(type_):
-        type_ = cast(GraphQLEnumType, type_)
-        values = type_.values
-        if isinstance(input_value, str):
-            enum_value = values.get(input_value)
-            if enum_value:
-                return enum_value.value
-        suggestions = suggestion_list(str(input_value), values)
-        on_error(
-            path.as_list() if path else [],
-            input_value,
-            GraphQLError(
-                f"Expected type '{type_.name}'."
-                + did_you_mean(suggestions, "the enum value")
-            ),
-        )
-        return Undefined
-
     # Not reachable. All possible input types have been considered.
     raise TypeError(f"Unexpected input type: {inspect(type_)}.")  # pragma: no cover

src/graphql/utilities/value_from_ast.py

@@ -1,7 +1,6 @@
 from typing import Any, Dict, List, Optional, cast
 
 from ..language import (
-    EnumValueNode,
     ListValueNode,
     NullValueNode,
     ObjectValueNode,
@@ -10,17 +9,15 @@
 )
 from ..pyutils import inspect, is_invalid, Undefined
 from ..type import (
-    GraphQLEnumType,
     GraphQLInputObjectType,
     GraphQLInputType,
     GraphQLList,
     GraphQLNonNull,
     GraphQLScalarType,
-    is_enum_type,
     is_input_object_type,
+    is_leaf_type,
     is_list_type,
     is_non_null_type,
-    is_scalar_type,
 )
 
 __all__ = ["value_from_ast"]
@@ -125,18 +122,7 @@ def value_from_ast(
 
         return type_.out_type(coerced_obj)
 
-    if is_enum_type(type_):
-        if not isinstance(value_node, EnumValueNode):
-            return Undefined
-        type_ = cast(GraphQLEnumType, type_)
-        value_name = value_node.value
-        enum_value = type_.values.get(value_name)
-        if not enum_value:
-            return Undefined
-        value = enum_value.value
-        return value_name if value is Undefined else value
-
-    if is_scalar_type(type_):
+    if is_leaf_type(type_):
         # Scalars fulfill parsing a literal value via `parse_literal()`. Invalid values
         # represent a failure to parse correctly, in which case Undefined is returned.
         type_ = cast(GraphQLScalarType, type_)
@@ -148,8 +134,6 @@ def value_from_ast(
                 result = type_.parse_literal(value_node)
         except Exception:
             return Undefined
-        if is_invalid(result):
-            return Undefined
         return result
 
     # Not reachable. All possible input types have been considered.

src/graphql/validation/rules/values_of_correct_type.py

@@ -19,12 +19,11 @@
     GraphQLScalarType,
     get_named_type,
     get_nullable_type,
-    is_enum_type,
     is_input_object_type,
+    is_leaf_type,
     is_list_type,
     is_non_null_type,
     is_required_input_field,
-    is_scalar_type,
 )
 from . import ValidationRule
 
@@ -116,21 +115,7 @@ def is_valid_value_node(self, node: ValueNode) -> None:
 
         type_ = get_named_type(location_type)
 
-        if is_enum_type(type_):
-            if not isinstance(node, EnumValueNode) or node.value not in type_.values:
-                all_names = list(type_.values)
-                suggested_values = suggestion_list(print_ast(node), all_names)
-                self.report_error(
-                    GraphQLError(
-                        f"Expected value of type '{type_.name}',"
-                        f" found {print_ast(node)}."
-                        + did_you_mean(suggested_values, "the enum value"),
-                        node,
-                    )
-                )
-            return
-
-        if not is_scalar_type(type_):
+        if not is_leaf_type(type_):
             self.report_error(
                 GraphQLError(
                     f"Expected value of type '{location_type}',"

tests/execution/test_executor.py

@@ -5,8 +5,8 @@
 
 from graphql.error import GraphQLError
 from graphql.execution import execute
-from graphql.language import parse, OperationDefinitionNode, FieldNode
-from graphql.pyutils import inspect
+from graphql.language import parse, FieldNode, OperationDefinitionNode
+from graphql.pyutils import inspect, Undefined
 from graphql.type import (
     GraphQLArgument,
     GraphQLBoolean,
@@ -18,6 +18,7 @@
     GraphQLObjectType,
     GraphQLResolveInfo,
     GraphQLSchema,
+    GraphQLScalarType,
     GraphQLString,
     ResponsePath,
 )
@@ -904,6 +905,34 @@ async def async_is_special():
         awaited_result = await async_result
         assert awaited_result == result
 
+    def fails_when_serialize_of_custom_scalar_does_not_return_a_value():
+        custom_scalar = GraphQLScalarType(
+            "CustomScalar", serialize=lambda _value: Undefined  # returns nothing
+        )
+        schema = GraphQLSchema(
+            GraphQLObjectType(
+                "Query",
+                {
+                    "customScalar": GraphQLField(
+                        custom_scalar, resolve=lambda *_args: "CUSTOM_VALUE"
+                    )
+                },
+            )
+        )
+
+        result = execute(schema, parse("{ customScalar }"))
+        assert result == (
+            {"customScalar": None},
+            [
+                {
+                    "message": "Expected a value of type 'CustomScalar'"
+                    " but received: 'CUSTOM_VALUE'",
+                    "locations": [(1, 3)],
+                    "path": ["customScalar"],
+                }
+            ],
+        )
+
     def executes_ignoring_invalid_non_executable_definitions():
         schema = GraphQLSchema(
             GraphQLObjectType("Query", {"foo": GraphQLField(GraphQLString)})