Refactor base executor

Author: syrusakbary

graphql/execution/base.py

@@ -1,127 +1,15 @@
-# -*- coding: utf-8 -*-
-import logging
-from traceback import format_exception
-
-from ..error import GraphQLError
-from ..language import ast
-from ..pyutils.default_ordered_dict import DefaultOrderedDict
-from ..type.definition import GraphQLInterfaceType, GraphQLUnionType
-from ..type.directives import GraphQLIncludeDirective, GraphQLSkipDirective
-from ..type.introspection import (SchemaMetaFieldDef, TypeMetaFieldDef,
-                                  TypeNameMetaFieldDef)
-from ..utils.type_from_ast import type_from_ast
-from .values import get_argument_values, get_variable_values
-
-logger = logging.getLogger(__name__)
-
-
-class ExecutionContext(object):
-    """Data that must be available at all points during query execution.
-
-    Namely, schema of the type system that is currently executing,
-    and the fragments defined in the query document"""
-
-    __slots__ = 'schema', 'fragments', 'root_value', 'operation', 'variable_values', 'errors', 'context_value', \
-                'argument_values_cache', 'executor', 'middleware', 'allow_subscriptions', '_subfields_cache'
-
-    def __init__(self, schema, document_ast, root_value, context_value, variable_values, operation_name, executor, middleware, allow_subscriptions):
-        """Constructs a ExecutionContext object from the arguments passed
-        to execute, which we will pass throughout the other execution
-        methods."""
-        errors = []
-        operation = None
-        fragments = {}
-
-        for definition in document_ast.definitions:
-            if isinstance(definition, ast.OperationDefinition):
-                if not operation_name and operation:
-                    raise GraphQLError(
-                        'Must provide operation name if query contains multiple operations.')
-
-                if not operation_name or definition.name and definition.name.value == operation_name:
-                    operation = definition
-
-            elif isinstance(definition, ast.FragmentDefinition):
-                fragments[definition.name.value] = definition
-
-            else:
-                raise GraphQLError(
-                    u'GraphQL cannot execute a request containing a {}.'.format(
-                        definition.__class__.__name__),
-                    definition
-                )
-
-        if not operation:
-            if operation_name:
-                raise GraphQLError(
-                    u'Unknown operation named "{}".'.format(operation_name))
-
-            else:
-                raise GraphQLError('Must provide an operation.')
-
-        variable_values = get_variable_values(
-            schema, operation.variable_definitions or [], variable_values)
-
-        self.schema = schema
-        self.fragments = fragments
-        self.root_value = root_value
-        self.operation = operation
-        self.variable_values = variable_values
-        self.errors = errors
-        self.context_value = context_value
-        self.argument_values_cache = {}
-        self.executor = executor
-        self.middleware = middleware
-        self.allow_subscriptions = allow_subscriptions
-        self._subfields_cache = {}
-
-    def get_field_resolver(self, field_resolver):
-        if not self.middleware:
-            return field_resolver
-        return self.middleware.get_field_resolver(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)
-
-        return result
-
-    def report_error(self, error, traceback=None):
-        exception = format_exception(type(error), error, getattr(error, 'stack', None) or traceback)
-        logger.error(''.join(exception))
-        self.errors.append(error)
-
-    def get_sub_fields(self, return_type, field_asts):
-        k = return_type, tuple(field_asts)
-        if k not in self._subfields_cache:
-            subfield_asts = DefaultOrderedDict(list)
-            visited_fragment_names = set()
-            for field_ast in field_asts:
-                selection_set = field_ast.selection_set
-                if selection_set:
-                    subfield_asts = collect_fields(
-                        self, return_type, selection_set,
-                        subfield_asts, visited_fragment_names
-                    )
-            self._subfields_cache[k] = subfield_asts
-        return self._subfields_cache[k]
-
-
-class SubscriberExecutionContext(object):
-    __slots__ = 'exe_context', 'errors'
-
-    def __init__(self, exe_context):
-        self.exe_context = exe_context
-        self.errors = []
-
-    def reset(self):
-        self.errors = []
-
-    def __getattr__(self, name):
-        return getattr(self.exe_context, name)
+# We keep the following imports to preserve compatibility
+from .utils import (
+    ExecutionContext,
+    SubscriberExecutionContext,
+    get_operation_root_type,
+    collect_fields,
+    should_include_node,
+    does_fragment_condition_match,
+    get_field_entry_key,
+    default_resolve_fn,
+    get_field_def
+)
 
 
 class ExecutionResult(object):
@@ -152,149 +40,6 @@ def __eq__(self, other):
         )
 
 
-def get_operation_root_type(schema, operation):
-    op = operation.operation
-    if op == 'query':
-        return schema.get_query_type()
-
-    elif op == 'mutation':
-        mutation_type = schema.get_mutation_type()
-
-        if not mutation_type:
-            raise GraphQLError(
-                'Schema is not configured for mutations',
-                [operation]
-            )
-
-        return mutation_type
-
-    elif op == 'subscription':
-        subscription_type = schema.get_subscription_type()
-
-        if not subscription_type:
-            raise GraphQLError(
-                'Schema is not configured for subscriptions',
-                [operation]
-            )
-
-        return subscription_type
-
-    raise GraphQLError(
-        'Can only execute queries, mutations and subscriptions',
-        [operation]
-    )
-
-
-def collect_fields(ctx, runtime_type, selection_set, fields, prev_fragment_names):
-    """
-    Given a selectionSet, adds all of the fields in that selection to
-    the passed in map of fields, and returns it at the end.
-
-    collect_fields requires the "runtime type" of an object. For a field which
-    returns and Interface or Union type, the "runtime type" will be the actual
-    Object type returned by that field.
-    """
-    for selection in selection_set.selections:
-        directives = selection.directives
-
-        if isinstance(selection, ast.Field):
-            if not should_include_node(ctx, directives):
-                continue
-
-            name = get_field_entry_key(selection)
-            fields[name].append(selection)
-
-        elif isinstance(selection, ast.InlineFragment):
-            if not should_include_node(
-                    ctx, directives) or not does_fragment_condition_match(
-                    ctx, selection, runtime_type):
-                continue
-
-            collect_fields(ctx, runtime_type,
-                           selection.selection_set, fields, prev_fragment_names)
-
-        elif isinstance(selection, ast.FragmentSpread):
-            frag_name = selection.name.value
-
-            if frag_name in prev_fragment_names or not should_include_node(ctx, directives):
-                continue
-
-            prev_fragment_names.add(frag_name)
-            fragment = ctx.fragments.get(frag_name)
-            frag_directives = fragment.directives
-            if not fragment or not \
-                    should_include_node(ctx, frag_directives) or not \
-                    does_fragment_condition_match(ctx, fragment, runtime_type):
-                continue
-
-            collect_fields(ctx, runtime_type,
-                           fragment.selection_set, fields, prev_fragment_names)
-
-    return fields
-
-
-def should_include_node(ctx, directives):
-    """Determines if a field should be included based on the @include and
-    @skip directives, where @skip has higher precidence than @include."""
-    # TODO: Refactor based on latest code
-    if directives:
-        skip_ast = None
-
-        for directive in directives:
-            if directive.name.value == GraphQLSkipDirective.name:
-                skip_ast = directive
-                break
-
-        if skip_ast:
-            args = get_argument_values(
-                GraphQLSkipDirective.args,
-                skip_ast.arguments,
-                ctx.variable_values,
-            )
-            if args.get('if') is True:
-                return False
-
-        include_ast = None
-
-        for directive in directives:
-            if directive.name.value == GraphQLIncludeDirective.name:
-                include_ast = directive
-                break
-
-        if include_ast:
-            args = get_argument_values(
-                GraphQLIncludeDirective.args,
-                include_ast.arguments,
-                ctx.variable_values,
-            )
-
-            if args.get('if') is False:
-                return False
-
-    return True
-
-
-def does_fragment_condition_match(ctx, fragment, type_):
-    type_condition_ast = fragment.type_condition
-    if not type_condition_ast:
-        return True
-
-    conditional_type = type_from_ast(ctx.schema, type_condition_ast)
-    if conditional_type.is_same_type(type_):
-        return True
-
-    if isinstance(conditional_type, (GraphQLInterfaceType, GraphQLUnionType)):
-        return ctx.schema.is_possible_type(conditional_type, type_)
-
-    return False
-
-
-def get_field_entry_key(node):
-    """Implements the logic to compute the key of a given field's entry"""
-    if node.alias:
-        return node.alias.value
-    return node.name.value
-
 
 class ResolveInfo(object):
     __slots__ = ('field_name', 'field_asts', 'return_type', 'parent_type',
@@ -313,30 +58,3 @@ def __init__(self, field_name, field_asts, return_type, parent_type,
         self.variable_values = variable_values
         self.context = context
         self.path = path
-
-
-def default_resolve_fn(source, info, **args):
-    """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
-    property = getattr(source, name, None)
-    if callable(property):
-        return property()
-    return property
-
-
-def get_field_def(schema, parent_type, field_name):
-    """This method looks up the field on the given type defintion.
-    It has special casing for the two introspection fields, __schema
-    and __typename. __typename is special because it can always be
-    queried as a field, even in situations where no other fields
-    are allowed, like on a Union. __schema could get automatically
-    added to the query type, but that would require mutating type
-    definitions, which would cause issues."""
-    if field_name == '__schema' and schema.get_query_type() == parent_type:
-        return SchemaMetaFieldDef
-    elif field_name == '__type' and schema.get_query_type() == parent_type:
-        return TypeMetaFieldDef
-    elif field_name == '__typename':
-        return TypeNameMetaFieldDef
-    return parent_type.fields.get(field_name)