Make parse_literal optional and use wrapped parse_value by default

Replicates graphql/graphql-js@f2c3e96

Author: Cito

graphql/type/definition.py

@@ -304,14 +304,6 @@ def serialize_odd(value):
 
     """
 
-    # Serializes an internal value to include in a response.
-    serialize: GraphQLScalarSerializer
-    #  Parses an externally provided value to use as an input.
-    parse_value: GraphQLScalarValueParser
-    # Parses an externally provided literal value to use as an input.
-    # Takes a dictionary of variables as an optional second argument.
-    parse_literal: GraphQLScalarLiteralParser
-
     ast_node: Optional[ScalarTypeDefinitionNode]
     extension_ast_nodes: Optional[Tuple[ScalarTypeExtensionNode]]
 
@@ -333,17 +325,19 @@ def __init__(
         )
         if serialize is not None and not callable(serialize):
             raise TypeError(
-                f"{name} must provide 'serialize' function."
+                f"{name} must provide 'serialize' as a function."
                 " If this custom Scalar is also used as an input type,"
                 " ensure 'parse_value' and 'parse_literal' functions"
                 " are also provided."
             )
-        if parse_value is not None or parse_literal is not None:
-            if not callable(parse_value) or not callable(parse_literal):
-                raise TypeError(
-                    f"{name} must provide"
-                    " both 'parse_value' and 'parse_literal' functions."
-                )
+        if parse_literal is not None and (
+            not callable(parse_literal)
+            or (parse_value is None or not callable(parse_value))
+        ):
+            raise TypeError(
+                f"{name} must provide"
+                " both 'parse_value' and 'parse_literal' as functions."
+            )
         if ast_node and not isinstance(ast_node, ScalarTypeDefinitionNode):
             raise TypeError(f"{name} AST node must be a ScalarTypeDefinitionNode.")
         if extension_ast_nodes and not all(
@@ -352,23 +346,59 @@ def __init__(
             raise TypeError(
                 f"{name} extension AST nodes must be ScalarTypeExtensionNode."
             )
-        self.serialize = serialize or identity_func  # type: ignore
-        self.parse_value = parse_value or identity_func  # type: ignore
-        self.parse_literal = parse_literal or value_from_ast_untyped  # type: ignore
+        if serialize is not None:
+            self.serialize = serialize
+        if parse_value is not None:
+            self.parse_value = parse_value
+        if parse_literal is not None:
+            self.parse_literal = parse_literal
 
     def __repr__(self):
         return f"<{self.__class__.__name__} {self.name!r}>"
 
     def __str__(self):
         return self.name
 
+    @staticmethod
+    def serialize(value: Any):
+        """Serializes an internal value to include in a response.
+
+        This default method just passes the value through and should be replaced
+        with a more specific version when creating a scalar type.
+        """
+        return value
+
+    @staticmethod
+    def parse_value(value: Any):
+        """Parses an externally provided value to use as an input.
+
+        This default method just passes the value through and should be replaced
+        with a more specific version when creating a scalar type.
+        """
+        return value
+
+    def parse_literal(  # type: ignore
+        self, node: ValueNode, _variables: Dict[str, Any] = None
+    ):
+        """Parses an externally provided literal value to use as an input.
+
+        This default method uses the parse_value method and should be replaced
+        with a more specific version when creating a scalar type.
+        """
+        return self.parse_value(value_from_ast_untyped(node))
+
     def to_kwargs(self) -> Dict[str, Any]:
         return dict(
             **super().to_kwargs(),
-            serialize=None if self.serialize is identity_func else self.serialize,
-            parse_value=None if self.parse_value is identity_func else self.parse_value,
+            serialize=None
+            if self.serialize is GraphQLScalarType.serialize
+            else self.serialize,
+            parse_value=None
+            if self.parse_value is GraphQLScalarType.parse_value
+            else self.parse_value,
             parse_literal=None
-            if self.parse_literal is value_from_ast_untyped
+            if getattr(self.parse_literal, "__func__")
+            is GraphQLScalarType.parse_literal
             else self.parse_literal,
         )
 

tests/type/test_definition.py

@@ -3,7 +3,7 @@
 from pytest import mark, raises
 
 from graphql.error import INVALID
-from graphql.language import Node, InputValueDefinitionNode
+from graphql.language import parse_value, Node, InputValueDefinitionNode
 from graphql.pyutils import identity_func
 from graphql.type import (
     GraphQLArgument,
@@ -21,7 +21,6 @@
     GraphQLString,
     GraphQLUnionType,
 )
-from graphql.utilities import value_from_ast_untyped
 
 ScalarType = GraphQLScalarType("Scalar")
 ObjectType = GraphQLObjectType("Object", {})
@@ -48,43 +47,45 @@ def accepts_a_scalar_type_defining_parse_value_and_parse_literal():
     def provides_default_methods_if_omitted():
         scalar = GraphQLScalarType("Foo")
 
-        assert scalar.serialize is identity_func
-        assert scalar.parse_value is identity_func
-        assert scalar.parse_literal is value_from_ast_untyped
+        assert scalar.serialize is GraphQLScalarType.serialize
+        assert scalar.parse_value is GraphQLScalarType.parse_value
+        assert scalar.parse_literal.__func__ is GraphQLScalarType.parse_literal
 
         kwargs = scalar.to_kwargs()
         assert kwargs["serialize"] is None
         assert kwargs["parse_value"] is None
         assert kwargs["parse_literal"] is None
 
+    def use_parse_value_for_parsing_literals_if_parse_literal_omitted():
+        scalar = GraphQLScalarType(
+            "Foo", parse_value=lambda value: f"parse_value: {value!r}"
+        )
+
+        assert scalar.parse_literal(parse_value("null")) == "parse_value: None"
+        assert (
+            scalar.parse_literal(parse_value('{foo: "bar"}'))
+            == "parse_value: {'foo': 'bar'}"
+        )
+
     def rejects_a_scalar_type_defining_serialize_with_incorrect_type():
         with raises(TypeError) as exc_info:
             # noinspection PyTypeChecker
             GraphQLScalarType("SomeScalar", {})
         msg = str(exc_info.value)
         assert msg == (
-            "SomeScalar must provide 'serialize' function."
+            "SomeScalar must provide 'serialize' as a function."
             " If this custom Scalar is also used as an input type,"
             " ensure 'parse_value' and 'parse_literal' functions"
             " are also provided."
         )
 
-    def rejects_a_scalar_type_defining_parse_value_but_not_parse_literal():
-        with raises(TypeError) as exc_info:
-            GraphQLScalarType("SomeScalar", parse_value=lambda: None)
-        msg = str(exc_info.value)
-        assert msg == (
-            "SomeScalar must provide both"
-            " 'parse_value' and 'parse_literal' functions."
-        )
-
     def rejects_a_scalar_type_defining_parse_literal_but_not_parse_value():
         with raises(TypeError) as exc_info:
             GraphQLScalarType("SomeScalar", parse_literal=lambda: None)
         msg = str(exc_info.value)
         assert msg == (
             "SomeScalar must provide both"
-            " 'parse_value' and 'parse_literal' functions."
+            " 'parse_value' and 'parse_literal' as functions."
         )
 
     def rejects_a_scalar_type_incorrectly_defining_parse_literal_and_value():
@@ -94,7 +95,7 @@ def rejects_a_scalar_type_incorrectly_defining_parse_literal_and_value():
         msg = str(exc_info.value)
         assert msg == (
             "SomeScalar must provide both"
-            " 'parse_value' and 'parse_literal' functions."
+            " 'parse_value' and 'parse_literal' as functions."
         )
 
 

tests/validation/harness.py

@@ -1,7 +1,7 @@
 from typing import List, Optional, Type
 
 from graphql.error import GraphQLError
-from graphql.language import parse, print_ast
+from graphql.language import parse
 from graphql.type import (
     GraphQLArgument,
     GraphQLBoolean,
@@ -230,9 +230,6 @@ def raise_type_error(message):
 
 InvalidScalar = GraphQLScalarType(
     name="Invalid",
-    parse_literal=lambda value_node: raise_type_error(
-        f"Invalid scalar is always invalid: {print_ast(value_node)}"
-    ),
     parse_value=lambda value: raise_type_error(
         f"Invalid scalar is always invalid: {value!r}"
     ),

tests/validation/test_validation.py

@@ -38,7 +38,7 @@ def detects_bad_scalar_parse():
         assert errors == [
             {
                 "message": 'Expected type Invalid, found "bad value";'
-                ' Invalid scalar is always invalid: "bad value"',
+                " Invalid scalar is always invalid: 'bad value'",
                 "locations": [(3, 31)],
             }
         ]