Fixed path resolution

Author: syrusakbary

graphql/error/base.py

@@ -3,16 +3,17 @@
 
 
 class GraphQLError(Exception):
- __slots__ = 'message', 'nodes', 'stack', 'original_error', '_source', '_positions', '_locations'
+ __slots__ = 'message', 'nodes', 'stack', 'original_error', '_source', '_positions', '_locations', 'path'
 
- def __init__(self, message, nodes=None, stack=None, source=None, positions=None, locations=None):
+ def __init__(self, message, nodes=None, stack=None, source=None, positions=None, locations=None, path=None):
  super(GraphQLError, self).__init__(message)
  self.message = message
  self.nodes = nodes
  self.stack = stack
  self._source = source
  self._positions = positions
  self._locations = locations
+ self.path = path
 
  @property
  def source(self):

graphql/error/located_error.py

@@ -7,7 +7,7 @@
 
 class GraphQLLocatedError(GraphQLError):
 
- def __init__(self, nodes, original_error=None):
+ def __init__(self, nodes, original_error=None, path=None):
  if original_error:
  try:
  message = str(original_error)
@@ -24,6 +24,7 @@ def __init__(self, nodes, original_error=None):
  super(GraphQLLocatedError, self).__init__(
  message=message,
  nodes=nodes,
- stack=stack
+ stack=stack,
+ path=path
  )
  self.original_error = original_error

graphql/execution/executor.py

@@ -124,7 +124,7 @@ def execute_operation(exe_context, operation, root_value):
  )
 
  if operation.operation == 'mutation':
- return execute_fields_serially(exe_context, type, root_value, fields)
+ return execute_fields_serially(exe_context, type, root_value, [], fields)
 
  if operation.operation == 'subscription':
  if not exe_context.allow_subscriptions:
@@ -133,12 +133,12 @@ def execute_operation(exe_context, operation, root_value):
  "You will need to either use the subscribe function "
  "or pass allow_subscriptions=True"
  )
- return subscribe_fields(exe_context, type, root_value, fields)
+ return subscribe_fields(exe_context, type, root_value, fields,)
 
- return execute_fields(exe_context, type, root_value, fields, None)
+ return execute_fields(exe_context, type, root_value, fields, [], None)
 
 
-def execute_fields_serially(exe_context, parent_type, source_value, fields):
+def execute_fields_serially(exe_context, parent_type, source_value, path, fields):
  def execute_field_callback(results, response_name):
  field_asts = fields[response_name]
  result = resolve_field(
@@ -147,7 +147,7 @@ def execute_field_callback(results, response_name):
  source_value,
  field_asts,
  None,
- [response_name]
+ path+[response_name]
  )
  if result is Undefined:
  return results
@@ -168,13 +168,13 @@ def execute_field(prev_promise, response_name):
  return functools.reduce(execute_field, fields.keys(), Promise.resolve(collections.OrderedDict()))
 
 
-def execute_fields(exe_context, parent_type, source_value, fields, info):
+def execute_fields(exe_context, parent_type, source_value, fields, path, info):
  contains_promise = False
 
  final_results = OrderedDict()
 
  for response_name, field_asts in fields.items():
- result = resolve_field(exe_context, parent_type, source_value, field_asts, info, (info.path if info else []) + [response_name])
+ result = resolve_field(exe_context, parent_type, source_value, field_asts, info, path + [response_name])
  if result is Undefined:
  continue
 
@@ -207,8 +207,7 @@ def map_result(data):
  # assert len(fields) == 1, "Can only subscribe one element at a time."
 
  for response_name, field_asts in fields.items():
-
- result = subscribe_field(exe_context, parent_type, source_value, field_asts)
+ result = subscribe_field(exe_context, parent_type, source_value, field_asts, [response_name])
  if result is Undefined:
  continue
 
@@ -272,11 +271,12 @@ def resolve_field(exe_context, parent_type, source, field_asts, parent_info, fie
  return_type,
  field_asts,
  info,
+ field_path,
  result
  )
 
 
-def subscribe_field(exe_context, parent_type, source, field_asts):
+def subscribe_field(exe_context, parent_type, source, field_asts, path):
  field_ast = field_asts[0]
  field_name = field_ast.name.value
 
@@ -312,7 +312,7 @@ def subscribe_field(exe_context, parent_type, source, field_asts):
  operation=exe_context.operation,
  variable_values=exe_context.variable_values,
  context=context,
- path=[field_name]
+ path=path
  )
 
  executor = exe_context.executor
@@ -332,6 +332,7 @@ def subscribe_field(exe_context, parent_type, source, field_asts):
  return_type,
  field_asts,
  info,
+ path,
  ))
 
 
@@ -346,16 +347,16 @@ def resolve_or_error(resolve_fn, source, info, args, executor):
  return e
 
 
-def complete_value_catching_error(exe_context, return_type, field_asts, info, result):
+def complete_value_catching_error(exe_context, return_type, field_asts, info, path, result):
  # If the field type is non-nullable, then it is resolved without any
  # protection from errors.
  if isinstance(return_type, GraphQLNonNull):
- return complete_value(exe_context, return_type, field_asts, info, result)
+ return complete_value(exe_context, return_type, field_asts, info, path, result)
 
  # Otherwise, error protection is applied, logging the error and
  # resolving a null value for this field if one is encountered.
  try:
- completed = complete_value(exe_context, return_type, field_asts, info, result)
+ completed = complete_value(exe_context, return_type, field_asts, info, path, result)
  if is_thenable(completed):
  def handle_error(error):
  traceback = completed._traceback
@@ -371,7 +372,7 @@ def handle_error(error):
  return None
 
 
-def complete_value(exe_context, return_type, field_asts, info, result):
+def complete_value(exe_context, return_type, field_asts, info, path, result):
  """
  Implements the instructions for completeValue as defined in the
  "Field entries" section of the spec.
@@ -399,6 +400,7 @@ def complete_value(exe_context, return_type, field_asts, info, result):
  return_type,
  field_asts,
  info,
+ path,
  resolved
  ),
  lambda error: Promise.rejected(
@@ -407,35 +409,35 @@ def complete_value(exe_context, return_type, field_asts, info, result):
 
  # print return_type, type(result)
  if isinstance(result, Exception):
- raise GraphQLLocatedError(field_asts, original_error=result)
+ raise GraphQLLocatedError(field_asts, original_error=result, path=path)
 
  if isinstance(return_type, GraphQLNonNull):
- return complete_nonnull_value(exe_context, return_type, field_asts, info, result)
+ return complete_nonnull_value(exe_context, return_type, field_asts, info, path, result)
 
  # If result is null-like, return null.
  if result is None:
  return None
 
  # If field type is List, complete each item in the list with the inner type
  if isinstance(return_type, GraphQLList):
- return complete_list_value(exe_context, return_type, field_asts, info, result)
+ return complete_list_value(exe_context, return_type, field_asts, info, path, result)
 
  # 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)):
- return complete_leaf_value(return_type, result)
+ return complete_leaf_value(return_type, path, result)
 
  if isinstance(return_type, (GraphQLInterfaceType, GraphQLUnionType)):
- return complete_abstract_value(exe_context, return_type, field_asts, info, result)
+ return complete_abstract_value(exe_context, return_type, field_asts, info, path, result)
 
  if isinstance(return_type, GraphQLObjectType):
- return complete_object_value(exe_context, return_type, field_asts, info, result)
+ return complete_object_value(exe_context, return_type, field_asts, info, path, result)
 
  assert False, u'Cannot complete value of unexpected type "{}".'.format(
  return_type)
 
 
-def complete_list_value(exe_context, return_type, field_asts, info, result):
+def complete_list_value(exe_context, return_type, field_asts, info, path, result):
  """
  Complete a list value by completing each item in the list with the inner type
  """
@@ -448,10 +450,8 @@ def complete_list_value(exe_context, return_type, field_asts, info, result):
  contains_promise = False
 
  index = 0
- path = info.path[:]
  for item in result:
- info.path = path + [index]
- completed_item = complete_value_catching_error(exe_context, item_type, field_asts, info, item)
+ completed_item = complete_value_catching_error(exe_context, item_type, field_asts, info, path + [index], item, )
  if not contains_promise and is_thenable(completed_item):
  contains_promise = True
 
@@ -461,7 +461,7 @@ def complete_list_value(exe_context, return_type, field_asts, info, result):
  return Promise.all(completed_results) if contains_promise else completed_results
 
 
-def complete_leaf_value(return_type, result):
+def complete_leaf_value(return_type, path, result):
  """
  Complete a Scalar or Enum by serializing to a valid value, returning null if serialization is not possible.
  """
@@ -471,12 +471,13 @@ def complete_leaf_value(return_type, result):
  if serialized_result is None:
  raise GraphQLError(
  ('Expected a value of type "{}" but ' +
- 'received: {}').format(return_type, result)
+ 'received: {}').format(return_type, result),
+ path=path
  )
  return serialized_result
 
 
-def complete_abstract_value(exe_context, return_type, field_asts, info, result):
+def complete_abstract_value(exe_context, return_type, field_asts, info, path, result):
  """
  Complete an value of an abstract type by determining the runtime type of that value, then completing based
  on that type.
@@ -514,7 +515,7 @@ def complete_abstract_value(exe_context, return_type, field_asts, info, result):
  field_asts
  )
 
- return complete_object_value(exe_context, runtime_type, field_asts, info, result)
+ return complete_object_value(exe_context, runtime_type, field_asts, info, path, result)
 
 
 def get_default_resolve_type_fn(value, info, abstract_type):
@@ -524,7 +525,7 @@ def get_default_resolve_type_fn(value, info, abstract_type):
  return type
 
 
-def complete_object_value(exe_context, return_type, field_asts, info, result):
+def complete_object_value(exe_context, return_type, field_asts, info, path, result):
  """
  Complete an Object value by evaluating all sub-selections.
  """
@@ -537,15 +538,15 @@ def complete_object_value(exe_context, return_type, field_asts, info, result):
 
  # Collect sub-fields to execute to complete this value.
  subfield_asts = exe_context.get_sub_fields(return_type, field_asts)
- return execute_fields(exe_context, return_type, result, subfield_asts, info)
+ return execute_fields(exe_context, return_type, result, subfield_asts, path, info)
 
 
-def complete_nonnull_value(exe_context, return_type, field_asts, info, result):
+def complete_nonnull_value(exe_context, return_type, field_asts, info, path, result):
  """
  Complete a NonNull value by completing the inner type
  """
  completed = complete_value(
- exe_context, return_type.of_type, field_asts, info, result
+ exe_context, return_type.of_type, field_asts, info, path, result
  )
  if completed is None:
  raise GraphQLError(