Implement validation infrastructure

Author: dittos

graphql/core/__init__.py

@@ -1,12 +1,18 @@
-from .executor import execute
+from .executor.executor import execute, ExecutionResult
 from .language.source import Source
 from .language.parser import parse
+from .validation import validate
 
 
 def graphql(schema, request='', root=None, vars=None, operation_name=None):
     source = Source(request, 'GraphQL request')
     ast = parse(source)
-    # TODO: validate document
+    validation_errors = validate(schema, ast)
+    if validation_errors:
+        return ExecutionResult(
+            data=None,
+            errors=validation_errors,
+        )
     return execute(
         schema,
         root or object(),

graphql/core/error.py

@@ -1,11 +1,43 @@
+from .language.location import get_location
+
+
 class Error(Exception):
     pass
 
 
 class GraphQLError(Error):
-    def __init__(self, message, nodes=None, cause=None):
+    def __init__(self, message, nodes=None, stack=None, source=None, positions=None):
         super(GraphQLError, self).__init__(message)
+        self.nodes = nodes
+        self.stack = stack or message
+        self._source = source
+        self._positions = positions
+
+    @property
+    def source(self):
+        if self._source:
+            return self._source
+        if self.nodes:
+            node = self.nodes[0]
+            return node and node.loc and node.loc['source']
+
+    @property
+    def positions(self):
+        if self._positions:
+            return self._positions
+        if self.nodes is not None:
+            node_positions = [node.loc and node.loc['start'] for node in self.nodes]
+            if any(node_positions):
+                return node_positions
+
+    @property
+    def locations(self):
+        if self.positions and self.source:
+            return [get_location(self.source, pos) for pos in self.positions]
 
 
 def format_error(error):
-    return error
+    return {
+        'message': error.message,
+        'locations': error.locations,
+    }

graphql/core/language/location.py

@@ -1,10 +1,8 @@
-__all__ = ['get_location']
+from collections import namedtuple
 
+__all__ = ['get_location', 'SourceLocation']
 
-class SourceLocation(object):
-    def __init__(self, line, column):
-        self.line = line
-        self.column = column
+SourceLocation = namedtuple('SourceLocation', 'line column')
 
 
 def get_location(source, position):

graphql/core/language/visitor.py

@@ -151,14 +151,14 @@ def is_node(maybe_node):
 
 class Visitor(object):
     def enter(self, node, key, parent, path, ancestors):
-        self._call_kind_specific_visitor('enter_', node, key, parent, path, ancestors)
+        return self._call_kind_specific_visitor('enter_', node, key, parent, path, ancestors)
 
     def leave(self, node, key, parent, path, ancestors):
-        self._call_kind_specific_visitor('leave_', node, key, parent, path, ancestors)
+        return self._call_kind_specific_visitor('leave_', node, key, parent, path, ancestors)
 
     def _call_kind_specific_visitor(self, prefix, node, key, parent, path, ancestors):
         node_kind = type(node).__name__
         method_name = prefix + node_kind
         method = getattr(self, method_name, None)
         if method:
-            method(node, key, parent, path, ancestors)
+            return method(node, key, parent, path, ancestors)

graphql/core/type/definition.py

@@ -56,22 +56,6 @@
   );
 }
 
-/**
- * These types may describe the parent context of a selection set.
- */
-export type GraphQLCompositeType =
-  GraphQLObjectType |
-  GraphQLInterfaceType |
-  GraphQLUnionType;
-
-export function isCompositeType(type: ?GraphQLType): boolean {
-  return (
-    type instanceof GraphQLObjectType ||
-    type instanceof GraphQLInterfaceType ||
-    type instanceof GraphQLUnionType
-  );
-}
-
 /**
  * These types may describe the parent context of a selection set.
  */
@@ -113,13 +97,27 @@ def is_input_type(type):
     ))
 
 
+def is_composite_type(type):
+    return isinstance(type, (
+        GraphQLObjectType,
+        GraphQLInterfaceType,
+        GraphQLUnionType,
+    ))
+
+
 def get_named_type(type):
     unmodified_type = type
     while isinstance(unmodified_type, (GraphQLList, GraphQLNonNull)):
         unmodified_type = unmodified_type.of_type
     return unmodified_type
 
 
+def get_nullable_type(type):
+    if isinstance(type, GraphQLNonNull):
+        return type.of_type
+    return type
+
+
 class GraphQLType(object):
     def __str__(self):
         return self.name

graphql/core/utils.py

@@ -1,23 +1,169 @@
-from .language.ast import ListType, NonNullType, NamedType
-from .type.definition import GraphQLList, GraphQLNonNull
+from .language import ast
+from .type.definition import (
+    GraphQLInputObjectType,
+    GraphQLObjectType,
+    GraphQLInterfaceType,
+    GraphQLUnionType,
+    GraphQLList,
+    GraphQLNonNull,
+    get_named_type,
+    get_nullable_type,
+    is_composite_type,
+)
+from .type.introspection import SchemaMetaFieldDef, TypeMetaFieldDef, TypeNameMetaFieldDef
 
 
 def type_from_ast(schema, input_type_ast):
-    if isinstance(input_type_ast, ListType):
+    if isinstance(input_type_ast, ast.ListType):
         inner_type = type_from_ast(schema, input_type_ast.type)
         if inner_type:
             return GraphQLList(inner_type)
         else:
             return None
-    if isinstance(input_type_ast, NonNullType):
+    if isinstance(input_type_ast, ast.NonNullType):
         inner_type = type_from_ast(schema, input_type_ast.type)
         if inner_type:
             return GraphQLNonNull(inner_type)
         else:
             return None
-    assert isinstance(input_type_ast, NamedType), 'Must be a type name.'
+    assert isinstance(input_type_ast, ast.NamedType), 'Must be a type name.'
     return schema.get_type(input_type_ast.name.value)
 
 
 def is_nullish(value):
     return value is None or value != value
+
+
+def pop(lst):
+    if lst:
+        lst.pop()
+
+
+class TypeInfo(object):
+    def __init__(self, schema):
+        self._schema = schema
+        self._type_stack = []
+        self._parent_type_stack = []
+        self._input_type_stack = []
+        self._field_def_stack = []
+        self._directive = None
+        self._argument = None
+
+    def get_type(self):
+        if self._type_stack:
+            return self._type_stack[-1]
+
+    def get_parent_type(self):
+        if self._parent_type_stack:
+            return self._parent_type_stack[-1]
+
+    def get_input_type(self):
+        if self._input_type_stack:
+            return self._input_type_stack[-1]
+
+    def get_field_def(self):
+        if self._field_def_stack:
+            return self._field_def_stack[-1]
+
+    def get_directive(self):
+        return self._directive
+
+    def get_argument(self):
+        return self._argument
+
+    def enter(self, node):
+        schema = self._schema
+        type = None
+        if isinstance(node, ast.SelectionSet):
+            named_type = get_named_type(self.get_type())
+            composite_type = None
+            if is_composite_type(named_type):
+                composite_type = named_type
+            self._parent_type_stack.append(composite_type)
+        elif isinstance(node, ast.Field):
+            parent_type = self.get_parent_type()
+            field_def = None
+            if parent_type:
+                field_def = get_field_def(schema, parent_type, node)
+            self._field_def_stack.append(field_def)
+            self._type_stack.append(field_def and field_def.type)
+        elif isinstance(node, ast.Directive):
+            self._directive = schema.get_directive(node.name.value)
+        elif isinstance(node, ast.OperationDefinition):
+            if node.operation == 'query':
+                type = schema.get_query_type()
+            elif node.operation == 'mutation':
+                type = schema.get_mutation_type()
+            self._type_stack.append(type)
+        elif isinstance(node, (ast.InlineFragment, ast.FragmentDefinition)):
+            type = type_from_ast(schema, node.type_condition)
+            self._type_stack.append(type)
+        elif isinstance(node, ast.VariableDefinition):
+            self._input_type_stack.append(type_from_ast(schema, node.type))
+        elif isinstance(node, ast.Argument):
+            arg_def = None
+            arg_type = None
+            field_or_directive = self.get_directive() or self.get_field_def()
+            if field_or_directive:
+                arg_def = filter(lambda arg: arg.name == node.name.value, field_or_directive.args)
+                if arg_def:
+                    arg_def = arg_def[0]
+                    arg_type = arg_def.type
+                else:
+                    arg_def = None
+            self._argument = arg_def
+            self._input_type_stack.append(arg_type)
+        elif isinstance(node, ast.ListType):
+            list_type = get_nullable_type(self.get_input_type())
+            self._input_type_stack.append(
+                list_type.of_type if isinstance(list_type, GraphQLList) else None
+            )
+        elif isinstance(node, ast.ObjectField):
+            object_type = get_named_type(self.get_input_type())
+            field_type = None
+            if isinstance(object_type, GraphQLInputObjectType):
+                input_field = object_type.get_fields().get(node.name.value)
+                field_type = input_field.type if input_field else None
+            self._input_type_stack.append(field_type)
+
+    def leave(self, node):
+        if isinstance(node, ast.SelectionSet):
+            pop(self._parent_type_stack)
+        elif isinstance(node, ast.Field):
+            pop(self._field_def_stack)
+            pop(self._type_stack)
+        elif isinstance(node, ast.Directive):
+            self._directive = None
+        elif isinstance(node, (
+                ast.OperationDefinition,
+                ast.InlineFragment,
+                ast.FragmentDefinition,
+        )):
+            pop(self._type_stack)
+        elif isinstance(node, ast.VariableDefinition):
+            pop(self._input_type_stack)
+        elif isinstance(node, ast.Argument):
+            self._argument = None
+            pop(self._input_type_stack)
+        elif isinstance(node, (ast.ListType, ast.ObjectField)):
+            pop(self._input_type_stack)
+
+
+def get_field_def(schema, parent_type, field_ast):
+    """Not exactly the same as the executor's definition of get_field_def, in this
+    statically evaluated environment we do not always have an Object type,
+    and need to handle Interface and Union types."""
+    name = field_ast.name.value
+    if name == SchemaMetaFieldDef.name and schema.get_query_type() == parent_type:
+        return SchemaMetaFieldDef
+    elif name == TypeMetaFieldDef.name and schema.get_query_type() == parent_type:
+        return TypeMetaFieldDef
+    elif name == TypeNameMetaFieldDef.name and \
+            isinstance(parent_type, (
+                GraphQLObjectType,
+                GraphQLInterfaceType,
+                GraphQLUnionType,
+            )):
+        return TypeNameMetaFieldDef
+    elif isinstance(parent_type, (GraphQLObjectType, GraphQLInterfaceType)):
+        return parent_type.get_fields().get(name)