[RFC] Add explicit context arg to graphql execution

Related GraphQL-js commit: graphql/graphql-js@d7cc6f9

Author: syrusakbary

graphql/execution/base.py

@@ -259,7 +259,7 @@ def __init__(self, field_name, field_asts, return_type, parent_type,
         self.variable_values = variable_values
 
 
-def default_resolve_fn(source, args, info):
+def default_resolve_fn(source, args, context, info):
     """If a resolve function is not given, then a default resolve behavior is used which takes the property of the source object
     of the same name as the field and returns it as the result, or if it's a function, returns the result of calling that function."""
     name = info.field_name

graphql/execution/executor.py

@@ -164,7 +164,7 @@ def resolve_field(exe_context, parent_type, source, field_asts):
 
 def resolve_or_error(resolve_fn, source, args, context, info, executor):
     try:
-        return executor.execute(resolve_fn, source, args, info)
+        return executor.execute(resolve_fn, source, args, context, info)
     except Exception as e:
         logger.exception("An error occurred while resolving field {}.{}".format(
             info.parent_type.name, info.field_name
@@ -310,7 +310,7 @@ def complete_abstract_value(exe_context, return_type, field_asts, info, result):
     # Field type must be Object, Interface or Union and expect sub-selections.
     if isinstance(return_type, (GraphQLInterfaceType, GraphQLUnionType)):
         if return_type.resolve_type:
-            runtime_type = return_type.resolve_type(result, info)
+            runtime_type = return_type.resolve_type(result, exe_context.context_value, info)
         else:
             runtime_type = get_default_resolve_type_fn(result, exe_context.context_value, info, return_type)
 
@@ -342,15 +342,15 @@ def complete_abstract_value(exe_context, return_type, field_asts, info, result):
 def get_default_resolve_type_fn(value, context, info, abstract_type):
     possible_types = info.schema.get_possible_types(abstract_type)
     for type in possible_types:
-        if callable(type.is_type_of) and type.is_type_of(value, info):
+        if callable(type.is_type_of) and type.is_type_of(value, context, info):
             return type
 
 
 def complete_object_value(exe_context, return_type, field_asts, info, result):
     """
     Complete an Object value by evaluating all sub-selections.
     """
-    if return_type.is_type_of and not return_type.is_type_of(result, info):
+    if return_type.is_type_of and not return_type.is_type_of(result, exe_context.context_value, info):
         raise GraphQLError(
             u'Expected value of type "{}" but got: {}.'.format(return_type, type(result).__name__),
             field_asts

graphql/execution/tests/test_abstract.py

@@ -25,11 +25,11 @@ def __init__(self, name):
         self.name = name
 
 
-is_type_of = lambda type: lambda obj, info: isinstance(obj, type)
+is_type_of = lambda type: lambda obj, context, info: isinstance(obj, type)
 
 
 def make_type_resolver(types):
-    def resolve_type(obj, info):
+    def resolve_type(obj, context, info):
         if callable(types):
             t = types()
         else:

graphql/execution/tests/test_executor.py

@@ -485,7 +485,7 @@ def __init__(self, value):
         fields={
             'value': GraphQLField(GraphQLString),
         },
-        is_type_of=lambda obj, info: isinstance(obj, Special)
+        is_type_of=lambda obj, context, info: isinstance(obj, Special)
     )
 
     schema = GraphQLSchema(

graphql/execution/tests/test_union_interface.py

@@ -38,7 +38,7 @@ def __init__(self, name, pets, friends):
         'name': GraphQLField(GraphQLString),
         'barks': GraphQLField(GraphQLBoolean),
     },
-    is_type_of=lambda value, info: isinstance(value, Dog)
+    is_type_of=lambda value, context, info: isinstance(value, Dog)
 )
 
 CatType = GraphQLObjectType(
@@ -48,11 +48,11 @@ def __init__(self, name, pets, friends):
         'name': GraphQLField(GraphQLString),
         'meows': GraphQLField(GraphQLBoolean),
     },
-    is_type_of=lambda value, info: isinstance(value, Cat)
+    is_type_of=lambda value, context, info: isinstance(value, Cat)
 )
 
 
-def resolve_pet_type(value, info):
+def resolve_pet_type(value, context, info):
     if isinstance(value, Dog):
         return DogType
     if isinstance(value, Cat):
@@ -70,7 +70,7 @@ def resolve_pet_type(value, info):
         'pets': GraphQLField(GraphQLList(PetType)),
         'friends': GraphQLField(GraphQLList(NamedType)),
     },
-    is_type_of=lambda value, info: isinstance(value, Person)
+    is_type_of=lambda value, context, info: isinstance(value, Person)
 )
 
 schema = GraphQLSchema(query=PersonType, types=[PetType])
@@ -107,6 +107,7 @@ def test_can_introspect_on_union_and_intersection_types():
     }''')
 
     result = execute(schema, ast)
+    assert not result.errors
     assert result.data == {
         'Named': {
             'enumValues': None,
@@ -311,12 +312,15 @@ def test_only_include_fields_from_matching_fragment_condition():
 
 
 def test_gets_execution_info_in_resolver():
-    encountered_schema = [None]
-    encountered_root_value = [None]
-
-    def resolve_type(obj, info):
-        encountered_schema[0] = info.schema
-        encountered_root_value[0] = info.root_value
+    class encountered:
+        schema = None
+        root_value = None
+        context = None
+
+    def resolve_type(obj, context, info):
+        encountered.schema = info.schema
+        encountered.root_value = info.root_value
+        encountered.context = context
         return PersonType2
 
     NamedType2 = GraphQLInterfaceType(
@@ -338,12 +342,15 @@ def resolve_type(obj, info):
 
     schema2 = GraphQLSchema(query=PersonType2)
     john2 = Person('John', [], [liz])
+    context = {'hey'}
     ast = parse('''{ name, friends { name } }''')
 
-    result = execute(schema2, ast, john2)
+    result = execute(schema2, ast, john2, context_value=context)
+    assert not result.errors
     assert result.data == {
         'name': 'John', 'friends': [{'name': 'Liz'}]
     }
 
-    assert encountered_schema[0] == schema2
-    assert encountered_root_value[0] == john2
+    assert encountered.schema == schema2
+    assert encountered.root_value == john2
+    assert encountered.context == context

graphql/execution/tests/test_variables.py

@@ -27,7 +27,7 @@
 stringify = lambda obj: json.dumps(obj, sort_keys=True)
 
 
-def input_to_json(obj, args, info):
+def input_to_json(obj, args, context, info):
     input = args.get('input')
     if input:
         return stringify(input)

graphql/type/definition.py

@@ -157,7 +157,7 @@ class GraphQLObjectType(GraphQLType):
             'street': GraphQLField(GraphQLString),
             'number': GraphQLField(GraphQLInt),
             'formatted': GraphQLField(GraphQLString,
-                resolver=lambda obj, args, info: obj.number + ' ' + obj.street),
+                resolver=lambda obj, args, context, info: obj.number + ' ' + obj.street),
         })
 
     When two types need to refer to each other, or a type needs to refer to

graphql/type/introspection.py

@@ -168,7 +168,7 @@ def interfaces(type, *_):
             return type.get_interfaces()
 
     @staticmethod
-    def possible_types(type, args, info):
+    def possible_types(type, args, context, info):
         if isinstance(type, (GraphQLInterfaceType, GraphQLUnionType)):
             return info.schema.get_possible_types(type)
 
@@ -350,7 +350,7 @@ def input_fields(type, *_):
 SchemaMetaFieldDef = GraphQLField(
     type=GraphQLNonNull(__Schema),
     description='Access the current type schema of this server.',
-    resolver=lambda source, args, info: info.schema,
+    resolver=lambda source, args, context, info: info.schema,
     args=[]
 )
 SchemaMetaFieldDef.name = '__schema'
@@ -361,15 +361,15 @@ def input_fields(type, *_):
     type=__Type,
     description='Request the type information of a single type.',
     args=[TypeMetaFieldDef_args_name],
-    resolver=lambda source, args, info: info.schema.get_type(args['name'])
+    resolver=lambda source, args, context, info: info.schema.get_type(args['name'])
 )
 TypeMetaFieldDef.name = '__type'
 del TypeMetaFieldDef_args_name
 
 TypeNameMetaFieldDef = GraphQLField(
     type=GraphQLNonNull(GraphQLString),
     description='The name of the current Object type at runtime.',
-    resolver=lambda source, args, info: info.parent_type.name,
+    resolver=lambda source, args, context, info: info.parent_type.name,
     args=[]
 )
 TypeNameMetaFieldDef.name = '__typename'

graphql/type/tests/test_enum_type.py

@@ -35,15 +35,15 @@ def get_first(args, *keys):
                 'fromInt': GraphQLArgument(GraphQLInt),
                 'fromString': GraphQLArgument(GraphQLString)
             },
-            resolver=lambda value, args, info: get_first(args, 'fromInt', 'fromString', 'fromEnum')
+            resolver=lambda value, args, context, info: get_first(args, 'fromInt', 'fromString', 'fromEnum')
         ),
         'colorInt': GraphQLField(
             type=GraphQLInt,
             args={
                 'fromEnum': GraphQLArgument(ColorType),
                 'fromInt': GraphQLArgument(GraphQLInt),
             },
-            resolver=lambda value, args, info: get_first(args, 'fromInt', 'fromEnum')
+            resolver=lambda value, args, context, info: get_first(args, 'fromInt', 'fromEnum')
         )
     }
 )
@@ -56,7 +56,7 @@ def get_first(args, *keys):
             args={
                 'color': GraphQLArgument(ColorType)
             },
-            resolver=lambda value, args, info: args.get('color')
+            resolver=lambda value, args, context, info: args.get('color')
         )
     }
 )
@@ -69,7 +69,7 @@ def get_first(args, *keys):
             args={
                 'color': GraphQLArgument(ColorType)
             },
-            resolver=lambda value, args, info: args.get('color')
+            resolver=lambda value, args, context, info: args.get('color')
         )
     }
 )

graphql/type/tests/test_introspection.py

@@ -728,7 +728,7 @@ def test_introspects_on_input_object():
         'field': GraphQLField(
             type=GraphQLString,
             args={'complex': GraphQLArgument(TestInputObject)},
-            resolver=lambda obj, args, info: json.dumps(args.get('complex'))
+            resolver=lambda obj, args, context, info: json.dumps(args.get('complex'))
         )
     })
     schema = GraphQLSchema(TestType)