Improved undefined variables usage

syrusakbary · syrusakbary · commit 701a6f7d1052 · 2017-07-23T01:43:58.000-07:00
diff --git a/graphql/__init__.py b/graphql/__init__.py
@@ -112,6 +112,9 @@
         # Un-modifiers
         get_nullable_type,
         get_named_type,
+
+        # Undefined const
+        Undefined
     )
 
     # Parse and operate on GraphQL language source files.
@@ -284,4 +287,5 @@
         'type_from_ast',
         'value_from_ast',
         'get_version',
+        'Undefined',
     )
diff --git a/graphql/execution/base.py b/graphql/execution/base.py
@@ -4,7 +4,7 @@
 from ..error import GraphQLError
 from ..language import ast
 from ..pyutils.default_ordered_dict import DefaultOrderedDict
-from ..type.definition import Undefined, GraphQLInterfaceType, GraphQLUnionType
+from ..type.definition import GraphQLInterfaceType, GraphQLUnionType
 from ..type.directives import GraphQLIncludeDirective, GraphQLSkipDirective
 from ..type.introspection import (SchemaMetaFieldDef, TypeMetaFieldDef,
                                   TypeNameMetaFieldDef)
@@ -75,7 +75,6 @@ def get_field_resolver(self, field_resolver):
     def get_argument_values(self, field_def, field_ast):
         k = field_def, field_ast
         result = self.argument_values_cache.get(k)
-
         if not result:
             result = self.argument_values_cache[k] = get_argument_values(field_def.args, field_ast.arguments,
                                                                          self.variable_values)
diff --git a/graphql/execution/executor.py b/graphql/execution/executor.py
@@ -9,10 +9,10 @@
 from ..error import GraphQLError, GraphQLLocatedError
 from ..pyutils.default_ordered_dict import DefaultOrderedDict
 from ..pyutils.ordereddict import OrderedDict
-from ..type import (GraphQLEnumType, GraphQLInterfaceType, GraphQLList,
+from ..type import (Undefined, GraphQLEnumType, GraphQLInterfaceType, GraphQLList,
                     GraphQLNonNull, GraphQLObjectType, GraphQLScalarType,
                     GraphQLSchema, GraphQLUnionType)
-from .base import (ExecutionContext, ExecutionResult, ResolveInfo, Undefined,
+from .base import (ExecutionContext, ExecutionResult, ResolveInfo,
                    collect_fields, default_resolve_fn, get_field_def,
                    get_operation_root_type)
 from .executors.sync import SyncExecutor
diff --git a/graphql/execution/experimental/fragment.py b/graphql/execution/experimental/fragment.py
@@ -4,9 +4,9 @@
 
 from ...pyutils.cached_property import cached_property
 from ...pyutils.default_ordered_dict import DefaultOrderedDict
-from ...type import (GraphQLInterfaceType, GraphQLList, GraphQLNonNull,
+from ...type import (Undefined, GraphQLInterfaceType, GraphQLList, GraphQLNonNull,
                      GraphQLObjectType, GraphQLUnionType)
-from ..base import ResolveInfo, Undefined, collect_fields, get_field_def
+from ..base import ResolveInfo, collect_fields, get_field_def
 from ..values import get_argument_values
 from ...error import GraphQLError
 try:
diff --git a/graphql/execution/experimental/tests/test_variables.py b/graphql/execution/experimental/tests/test_variables.py
@@ -413,9 +413,10 @@ def test_passes_along_null_for_non_nullable_inputs_if_explcitly_set_in_the_query
     '''
 
     check(doc, {
-        'data': {
-            'fieldWithNonNullableStringInput': None
-        }
+        'errors': [{
+            'message': 'Argument "input" of required type String!" was not provided.'
+        }],
+        'data': None
     })
 
 
diff --git a/graphql/execution/tests/test_variables.py b/graphql/execution/tests/test_variables.py
@@ -413,9 +413,10 @@ def test_passes_along_null_for_non_nullable_inputs_if_explcitly_set_in_the_query
     '''
 
     check(doc, {
-        'data': {
-            'fieldWithNonNullableStringInput': None
-        }
+        'errors': [{
+            'message': 'Argument "input" of required type String!" was not provided.'
+        }],
+        'data': None
     })
 
 
diff --git a/graphql/execution/values.py b/graphql/execution/values.py
@@ -4,8 +4,9 @@
 from six import string_types
 
 from ..error import GraphQLError
+from ..language import ast
 from ..language.printer import print_ast
-from ..type import (GraphQLEnumType, GraphQLInputObjectType, GraphQLList,
+from ..type import (Undefined, GraphQLEnumType, GraphQLInputObjectType, GraphQLList,
                     GraphQLNonNull, GraphQLScalarType, is_input_type)
 from ..utils.is_valid_value import is_valid_value
 from ..utils.type_from_ast import type_from_ast
@@ -23,8 +24,43 @@ def get_variable_values(schema, definition_asts, inputs):
     values = {}
     for def_ast in definition_asts:
         var_name = def_ast.variable.name.value
-        value = get_variable_value(schema, def_ast, inputs.get(var_name))
-        values[var_name] = value
+        var_type = type_from_ast(schema, def_ast.type)
+        value = inputs.get(var_name, Undefined)
+
+        if not is_input_type(var_type):
+            raise GraphQLError(
+                'Variable "${var_name}" expected value of type "{var_type}" which cannot be used as an input type.'.format(
+                    var_name=var_name,
+                    var_type=print_ast(def_ast.type),
+                ),
+                [def_ast]
+            )
+        elif value is Undefined or value is None:
+            if def_ast.default_value is not None:
+                values[var_name] = value_from_ast(def_ast.default_value, var_type)
+            if isinstance(var_type, GraphQLNonNull):
+                raise GraphQLError(
+                    'Variable "${var_name}" of required type "{var_type}" was not provided.'.format(
+                        var_name=var_name, var_type=var_type
+                    ), [def_ast]
+                )
+        else:
+            errors = is_valid_value(value, var_type)
+            if errors:
+                message = u'\n' + u'\n'.join(errors)
+                raise GraphQLError(
+                    'Variable "${}" got invalid value {}.{}'.format(
+                        var_name,
+                        json.dumps(value, sort_keys=True),
+                        message
+                    ),
+                    [def_ast]
+                )
+            coerced_value = coerce_value(var_type, value)
+            if coerced_value is Undefined:
+                raise Exception('Should have reported error.')
+
+            values[var_name] = coerced_value
 
     return values
 
@@ -42,72 +78,51 @@ def get_argument_values(arg_defs, arg_asts, variables=None):
 
     result = {}
     for name, arg_def in arg_defs.items():
-        value_ast = arg_ast_map.get(name)
+        arg_type = arg_def.type
+        value_ast = arg_ast_map.get(name, Undefined)
+        if not value_ast:
+            if arg_def.default_value is not Undefined:
+                result[arg_def.out_name or name] = arg_def.default_value
+                continue
+            elif isinstance(arg_type, GraphQLNonNull):
+                raise GraphQLError('Argument "{name}" of required type {arg_type}" was not provided.'.format(
+                    name=name,
+                    arg_type=arg_type
+                ), arg_asts)
+        elif isinstance(value_ast.value, ast.Variable):
+            variable_name = value_ast.value.name.value
+            variable_value = variables.get(variable_name, Undefined)
+            if variables and variable_value is not Undefined:
+                result[arg_def.out_name or name] = variable_value
+            elif arg_def.default_value is not Undefined:
+                result[arg_def.out_name or name] = arg_def.default_value
+            elif isinstance(arg_type, GraphQLNonNull):
+                raise GraphQLError('Argument "{name}" of required type {arg_type}" provided the variable "${variable_name}" which was not provided'.format(
+                    name=name,
+                    arg_type=arg_type,
+                    variable_name=variable_name
+                ), arg_asts)
+            continue
+
         if value_ast:
             value_ast = value_ast.value
 
         value = value_from_ast(
             value_ast,
-            arg_def.type,
+            arg_type,
             variables
         )
-
-        if value is None:
+        if value is Undefined:
             value = arg_def.default_value
 
-        if value is not None:
+        if value is not Undefined:
             # We use out_name as the output name for the
             # dict if exists
             result[arg_def.out_name or name] = value
 
     return result
 
 
-def get_variable_value(schema, definition_ast, input):
-    """Given a variable definition, and any value of input, return a value which adheres to the variable definition,
-    or throw an error."""
-    type = type_from_ast(schema, definition_ast.type)
-    variable = definition_ast.variable
-
-    if not type or not is_input_type(type):
-        raise GraphQLError(
-            'Variable "${}" expected value of type "{}" which cannot be used as an input type.'.format(
-                variable.name.value,
-                print_ast(definition_ast.type),
-            ),
-            [definition_ast]
-        )
-
-    input_type = type
-    errors = is_valid_value(input, input_type)
-    if not errors:
-        if input is None:
-            default_value = definition_ast.default_value
-            if default_value:
-                return value_from_ast(default_value, input_type)
-
-        return coerce_value(input_type, input)
-
-    if input is None:
-        raise GraphQLError(
-            'Variable "${}" of required type "{}" was not provided.'.format(
-                variable.name.value,
-                print_ast(definition_ast.type)
-            ),
-            [definition_ast]
-        )
-
-    message = (u'\n' + u'\n'.join(errors)) if errors else u''
-    raise GraphQLError(
-        'Variable "${}" got invalid value {}.{}'.format(
-            variable.name.value,
-            json.dumps(input, sort_keys=True),
-            message
-        ),
-        [definition_ast]
-    )
-
-
 def coerce_value(type, value):
     """Given a type and any value, return a runtime value coerced to match the type."""
     if isinstance(type, GraphQLNonNull):
@@ -116,6 +131,9 @@ def coerce_value(type, value):
         # We only call this function after calling isValidValue.
         return coerce_value(type.of_type, value)
 
+    if value is Undefined:
+        return Undefined
+
     if value is None:
         return None
 
@@ -130,11 +148,11 @@ def coerce_value(type, value):
         fields = type.fields
         obj = {}
         for field_name, field in fields.items():
-            field_value = coerce_value(field.type, value.get(field_name))
-            if field_value is None:
+            field_value = coerce_value(field.type, value.get(field_name, Undefined))
+            if field_value is Undefined:
                 field_value = field.default_value
 
-            if field_value is not None:
+            if field_value is not Undefined:
                 # We use out_name as the output name for the
                 # dict if exists
                 obj[field.out_name or field_name] = field_value
@@ -144,4 +162,8 @@ def coerce_value(type, value):
     assert isinstance(type, (GraphQLScalarType, GraphQLEnumType)), \
         'Must be input type'
 
-    return type.parse_value(value)
+    parsed = type.parse_value(value)
+    if parsed is None:
+        return Undefined
+
+    return parsed
diff --git a/graphql/language/ast.py b/graphql/language/ast.py
@@ -1,5 +1,6 @@
 # This is autogenerated code. DO NOT change this manually.
 # Run scripts/generate_ast.py to generate this file.
+from ..utils.undefined import Undefined
 
 
 class Node(object):
@@ -94,7 +95,7 @@ class VariableDefinition(Node):
     __slots__ = ('loc', 'variable', 'type', 'default_value',)
     _fields = ('variable', 'type', 'default_value',)
 
-    def __init__(self, variable, type, default_value=None, loc=None):
+    def __init__(self, variable, type, default_value=Undefined, loc=None):
         self.loc = loc
         self.variable = variable
         self.type = type
@@ -1005,7 +1006,7 @@ class InputValueDefinition(Node):
     __slots__ = ('loc', 'name', 'type', 'default_value', 'directives')
     _fields = ('name', 'type', 'default_value',)
 
-    def __init__(self, name, type, default_value=None, loc=None,
+    def __init__(self, name, type, default_value=Undefined, loc=None,
                  directives=None):
         self.loc = loc
         self.name = name
diff --git a/graphql/type/definition.py b/graphql/type/definition.py
@@ -5,16 +5,7 @@
 from ..pyutils.cached_property import cached_property
 from ..pyutils.ordereddict import OrderedDict
 from ..utils.assert_valid_name import assert_valid_name
-
-
-class _Undefined(object):
-    def __bool__(self):
-        return False
-
-    __nonzero__ = __bool__
-
-
-Undefined = _Undefined()
+from ..utils.undefined import Undefined
 
 
 def is_type(type):
@@ -275,7 +266,7 @@ def __hash__(self):
 class GraphQLArgument(object):
     __slots__ = 'type', 'default_value', 'description', 'out_name'
 
-    def __init__(self, type, default_value=None, description=None, out_name=None):
+    def __init__(self, type, default_value=Undefined, description=None, out_name=None):
         self.type = type
         self.default_value = default_value
         self.description = description
@@ -548,7 +539,7 @@ def _define_field_map(self):
 class GraphQLInputObjectField(object):
     __slots__ = 'type', 'default_value', 'description', 'out_name'
 
-    def __init__(self, type, default_value=None, description=None, out_name=None):
+    def __init__(self, type, default_value=Undefined, description=None, out_name=None):
         self.type = type
         self.default_value = default_value
         self.description = description
diff --git a/graphql/type/introspection.py b/graphql/type/introspection.py
@@ -2,7 +2,7 @@
 
 from ..language.printer import print_ast
 from ..utils.ast_from_value import ast_from_value
-from .definition import (GraphQLArgument, GraphQLEnumType, GraphQLEnumValue,
+from .definition import (Undefined, GraphQLArgument, GraphQLEnumType, GraphQLEnumValue,
                          GraphQLField, GraphQLInputObjectType,
                          GraphQLInterfaceType, GraphQLList, GraphQLNonNull,
                          GraphQLObjectType, GraphQLScalarType,
@@ -345,7 +345,7 @@ def input_fields(type, *_):
         ('defaultValue', GraphQLField(
             type=GraphQLString,
             resolver=lambda input_val, *_:
-            None if input_val.default_value is None
+            None if input_val.default_value is Undefined
             else print_ast(ast_from_value(input_val.default_value, input_val))
         ))
     ]))
diff --git a/graphql/utils/schema_printer.py b/graphql/utils/schema_printer.py
@@ -1,5 +1,5 @@
 from ..language.printer import print_ast
-from ..type.definition import (GraphQLEnumType, GraphQLInputObjectType,
+from ..type.definition import (Undefined, GraphQLEnumType, GraphQLInputObjectType,
                                GraphQLInterfaceType, GraphQLObjectType,
                                GraphQLScalarType, GraphQLUnionType)
 from ..type.directives import DEFAULT_DEPRECATION_REASON
@@ -153,7 +153,7 @@ def _print_args(field_or_directives):
 
 
 def _print_input_value(name, arg):
-    if arg.default_value is not None:
+    if arg.default_value not in (Undefined, None):
         default_value = ' = ' + print_ast(ast_from_value(arg.default_value, arg.type))
     else:
         default_value = ''
diff --git a/graphql/utils/undefined.py b/graphql/utils/undefined.py
@@ -0,0 +1,11 @@
+class _Undefined(object):
+    def __bool__(self):
+        return False
+
+    __nonzero__ = __bool__
+
+    def __repr__(self):
+        return 'Undefined'
+
+
+Undefined = _Undefined()
diff --git a/graphql/utils/value_from_ast.py b/graphql/utils/value_from_ast.py

Original file line number	Diff line number	Diff line change
`@@ -112,6 +112,9 @@`
`112`	`112`	`# Un-modifiers`
`113`	`113`	`get_nullable_type,`
`114`	`114`	`get_named_type,`
	`115`	`+`
	`116`	`+ # Undefined const`
	`117`	`+ Undefined`
`115`	`118`	`)`
`116`	`119`
`117`	`120`	`# Parse and operate on GraphQL language source files.`
`@@ -284,4 +287,5 @@`
`284`	`287`	`'type_from_ast',`
`285`	`288`	`'value_from_ast',`
`286`	`289`	`'get_version',`
	`290`	`+ 'Undefined',`
`287`	`291`	`)`