Refactor coerce to serialize/parse in scalar type definition (fix #32)

Author: dittos

graphql/core/execution/__init__.py

@@ -336,7 +336,7 @@ def complete_value(ctx, return_type, field_asts, info, result):
 
     If the field type is a List, then this recursively completes the value for the inner type on each item in the list.
 
-    If the field type is a Scalar or Enum, ensures the completed value is a legal value of the type by calling the `coerce`
+    If the field type is a Scalar or Enum, ensures the completed value is a legal value of the type by calling the `serialize`
     method of GraphQL type definition.
 
     Otherwise, the field type expects a sub-selection set, and will complete the value by evaluating all sub-selections."""
@@ -366,12 +366,12 @@ def complete_value(ctx, return_type, field_asts, info, result):
             ctx, item_type, field_asts, info, item
         ) for item in result]
 
-    # If field type is Scalar or Enum, coerce to a valid value, returning null if coercion is not possible.
+    # If field type is Scalar or Enum, serialize to a valid value, returning null if coercion is not possible.
     if isinstance(return_type, (GraphQLScalarType, GraphQLEnumType)):
-        coerced_result = return_type.coerce(result)
-        if is_nullish(coerced_result):
+        serialized_result = return_type.serialize(result)
+        if is_nullish(serialized_result):
             return None
-        return coerced_result
+        return serialized_result
 
     # Field type must be Object, Interface or Union and expect sub-selections.
     if isinstance(return_type, GraphQLObjectType):

graphql/core/execution/values.py

@@ -11,7 +11,7 @@
 
 def get_variable_values(schema, definition_asts, inputs):
     """Prepares an object map of variables of the correct type based on the provided variable definitions and arbitrary input.
-    If the input cannot be coerced to match the variable definitions, a GraphQLError will be thrown."""
+    If the input cannot be parsed to match the variable definitions, a GraphQLError will be thrown."""
     if inputs is None:
         inputs = {}
     values = {}
@@ -109,7 +109,7 @@ def is_valid_value(type, value):
     assert isinstance(type, (GraphQLScalarType, GraphQLEnumType)), \
         'Must be input type'
 
-    return not is_nullish(type.coerce(value))
+    return not is_nullish(type.parse_value(value))
 
 
 def coerce_value(type, value):
@@ -143,9 +143,9 @@ def coerce_value(type, value):
     assert isinstance(type, (GraphQLScalarType, GraphQLEnumType)), \
         'Must be input type'
 
-    coerced = type.coerce(value)
-    if not is_nullish(coerced):
-        return coerced
+    parsed = type.parse_value(value)
+    if not is_nullish(parsed):
+        return parsed
 
     return None
 
@@ -201,8 +201,8 @@ def coerce_value_ast(type, value_ast, variables):
     assert isinstance(type, (GraphQLScalarType, GraphQLEnumType)), \
         'Must be input type'
 
-    coerced = type.coerce_literal(value_ast)
-    if not is_nullish(coerced):
-        return coerced
+    parsed = type.parse_literal(value_ast)
+    if not is_nullish(parsed):
+        return parsed
 
     return None

graphql/core/type/definition.py

@@ -61,21 +61,30 @@ def coerce_odd(value):
                 return value
             return None
 
-        OddType = GraphQLScalarType(name='Odd', coerce=coerce_odd)
+        OddType = GraphQLScalarType(name='Odd', serialize=coerce_odd)
     """
-    def __init__(self, name, description=None, coerce=None, coerce_literal=None):
+    def __init__(self, name, description=None, serialize=None, parse_value=None, parse_literal=None):
         assert name, 'Type must be named.'
         self.name = name
         self.description = description
-        self._coerce = coerce
-        self._coerce_literal = coerce_literal
-
-    def coerce(self, value):
-        return self._coerce(value)
+        assert callable(serialize)
+        if parse_value or parse_literal:
+            assert callable(parse_value) and callable(parse_literal)
+        self._serialize = serialize
+        self._parse_value = parse_value
+        self._parse_literal = parse_literal
+
+    def serialize(self, value):
+        return self._serialize(value)
+
+    def parse_value(self, value):
+        if self._parse_value:
+            return self._parse_value(value)
+        return None
 
-    def coerce_literal(self, value):
-        if self._coerce_literal:
-            return self._coerce_literal(value)
+    def parse_literal(self, value_ast):
+        if self._parse_literal:
+            return self._parse_literal(value_ast)
         return None
 
     def __str__(self):
@@ -310,16 +319,23 @@ def get_values(self):
             self._value_map = self._define_value_map()
         return self._value_map
 
-    def coerce(self, value):
+    def serialize(self, value):
+        if isinstance(value, collections.Hashable):
+            enum_value = self._get_value_lookup().get(value)
+            if enum_value:
+                return enum_value.name
+        return None
+
+    def parse_value(self, value):
         if isinstance(value, collections.Hashable):
             enum_value = self._get_value_lookup().get(value)
             if enum_value:
                 return enum_value.name
         return None
 
-    def coerce_literal(self, value):
-        if isinstance(value, ast.EnumValue):
-            enum_value = self._get_name_lookup().get(value.value)
+    def parse_literal(self, value_ast):
+        if isinstance(value_ast, ast.EnumValue):
+            enum_value = self._get_name_lookup().get(value_ast.value)
             if enum_value:
                 return enum_value.value
 

graphql/core/type/scalars.py

@@ -26,15 +26,16 @@ def coerce_int(value):
     return None
 
 
-def coerce_int_literal(ast):
+def parse_int_literal(ast):
     if isinstance(ast, IntValue):
         num = int(ast.value)
         if MIN_INT <= num <= MAX_INT:
             return num
 
 GraphQLInt = GraphQLScalarType(name='Int',
-                               coerce=coerce_int,
-                               coerce_literal=coerce_int_literal)
+                               serialize=coerce_int,
+                               parse_value=coerce_int,
+                               parse_literal=parse_int_literal)
 
 
 def coerce_float(value):
@@ -47,14 +48,15 @@ def coerce_float(value):
     return None
 
 
-def coerce_float_literal(ast):
+def parse_float_literal(ast):
     if isinstance(ast, (FloatValue, IntValue)):
         return float(ast.value)
     return None
 
 GraphQLFloat = GraphQLScalarType(name='Float',
-                                 coerce=coerce_float,
-                                 coerce_literal=coerce_float_literal)
+                                 serialize=coerce_float,
+                                 parse_value=coerce_float,
+                                 parse_literal=parse_float_literal)
 
 
 def coerce_string(value):
@@ -63,31 +65,34 @@ def coerce_string(value):
     return str(value)
 
 
-def coerce_string_literal(ast):
+def parse_string_literal(ast):
     if isinstance(ast, StringValue):
         return ast.value
     return None
 
 GraphQLString = GraphQLScalarType(name='String',
-                                  coerce=coerce_string,
-                                  coerce_literal=coerce_string_literal)
+                                  serialize=coerce_string,
+                                  parse_value=coerce_string,
+                                  parse_literal=parse_string_literal)
 
 
-def coerce_boolean_literal(ast):
+def parse_boolean_literal(ast):
     if isinstance(ast, BooleanValue):
         return ast.value
     return None
 
 GraphQLBoolean = GraphQLScalarType(name='Boolean',
-                                   coerce=bool,
-                                   coerce_literal=coerce_boolean_literal)
+                                   serialize=bool,
+                                   parse_value=bool,
+                                   parse_literal=parse_boolean_literal)
 
 
-def coerce_id_literal(ast):
+def parse_id_literal(ast):
     if isinstance(ast, (StringValue, IntValue)):
         return ast.value
     return None
 
 GraphQLID = GraphQLScalarType(name='ID',
-                              coerce=str,
-                              coerce_literal=coerce_id_literal)
+                              serialize=str,
+                              parse_value=str,
+                              parse_literal=parse_id_literal)

graphql/core/utils.py

@@ -211,4 +211,4 @@ def is_valid_literal_value(type, value_ast):
 
     assert isinstance(type, (GraphQLScalarType, GraphQLEnumType)), 'Must be input type'
 
-    return not is_nullish(type.coerce_literal(value_ast))
+    return not is_nullish(type.parse_literal(value_ast))

tests/core_type/test_coercion.py

@@ -0,0 +1,51 @@
+from graphql.core.type import (
+    GraphQLInt,
+    GraphQLFloat,
+    GraphQLString,
+    GraphQLBoolean,
+)
+
+def test_serializes_output_int():
+    assert GraphQLInt.serialize(1) == 1
+    assert GraphQLInt.serialize(0) == 0
+    assert GraphQLInt.serialize(-1) == -1
+    assert GraphQLInt.serialize(0.1) == 0
+    assert GraphQLInt.serialize(1.1) == 1
+    assert GraphQLInt.serialize(-1.1) == -1
+    assert GraphQLInt.serialize(1e5) == 100000
+    assert GraphQLInt.serialize(1e100) is None
+    assert GraphQLInt.serialize(-1e100) is None
+    assert GraphQLInt.serialize('-1.1') == -1
+    assert GraphQLInt.serialize('one') is None
+    assert GraphQLInt.serialize(False) == 0
+    assert GraphQLInt.serialize(True) == 1
+
+
+def test_serializes_output_float():
+    assert GraphQLFloat.serialize(1) == 1.0
+    assert GraphQLFloat.serialize(0) == 0.0
+    assert GraphQLFloat.serialize(-1) == -1.0
+    assert GraphQLFloat.serialize(0.1) == 0.1
+    assert GraphQLFloat.serialize(1.1) == 1.1
+    assert GraphQLFloat.serialize(-1.1) == -1.1
+    assert GraphQLFloat.serialize('-1.1') == -1.1
+    assert GraphQLFloat.serialize('one') is None
+    assert GraphQLFloat.serialize(False) == 0
+    assert GraphQLFloat.serialize(True) == 1
+
+
+def test_serializes_output_string():
+    assert GraphQLString.serialize('string') == 'string'
+    assert GraphQLString.serialize(1) == '1'
+    assert GraphQLString.serialize(-1.1) == '-1.1'
+    assert GraphQLString.serialize(True) == 'true'
+    assert GraphQLString.serialize(False) == 'false'
+
+
+def test_serializes_output_boolean():
+    assert GraphQLBoolean.serialize('string') is True
+    assert GraphQLBoolean.serialize('') is False
+    assert GraphQLBoolean.serialize(1) is True
+    assert GraphQLBoolean.serialize(0) is False
+    assert GraphQLBoolean.serialize(True) is True
+    assert GraphQLBoolean.serialize(False) is False