Improved query builder

Author: syrusakbary

graphql/execution/querybuilder/executor.py

@@ -0,0 +1,82 @@
+import collections
+import functools
+import logging
+import sys
+
+from promise import Promise, promise_for_dict, promisify
+
+from ...error import GraphQLError, GraphQLLocatedError
+from ...pyutils.default_ordered_dict import DefaultOrderedDict
+from ...pyutils.ordereddict import OrderedDict
+from ...type import (GraphQLEnumType, GraphQLInterfaceType, GraphQLList,
+                    GraphQLNonNull, GraphQLObjectType, GraphQLScalarType,
+                    GraphQLSchema, GraphQLUnionType)
+from ..base import (ExecutionContext, ExecutionResult, ResolveInfo, Undefined,
+                   collect_fields, default_resolve_fn, get_field_def,
+                   get_operation_root_type)
+from ..executors.sync import SyncExecutor
+from ..middleware import MiddlewareManager
+
+from .resolver import type_resolver
+from .fragment import Fragment
+
+logger = logging.getLogger(__name__)
+
+
+def is_promise(obj):
+    return type(obj) == Promise
+
+
+def execute(schema, document_ast, root_value=None, context_value=None,
+            variable_values=None, operation_name=None, executor=None,
+            return_promise=False, middlewares=None):
+    assert schema, 'Must provide schema'
+    assert isinstance(schema, GraphQLSchema), (
+        'Schema must be an instance of GraphQLSchema. Also ensure that there are ' +
+        'not multiple versions of GraphQL installed in your node_modules directory.'
+    )
+    if middlewares:
+        assert isinstance(middlewares, MiddlewareManager), (
+            'middlewares have to be an instance'
+            ' of MiddlewareManager. Received "{}".'.format(middlewares)
+        )
+
+    if executor is None:
+        executor = SyncExecutor()
+
+    context = ExecutionContext(
+        schema,
+        document_ast,
+        root_value,
+        context_value,
+        variable_values,
+        operation_name,
+        executor,
+        middlewares
+    )
+
+    def executor(resolve, reject):
+        return resolve(execute_operation(context, context.operation, root_value))
+
+    def on_rejected(error):
+        context.errors.append(error)
+        return None
+
+    def on_resolve(data):
+        return ExecutionResult(data=data, errors=context.errors)
+
+    promise = Promise(executor).catch(on_rejected).then(on_resolve)
+    if return_promise:
+        return promise
+    context.executor.wait_until_finished()
+    return promise.get()
+
+
+def execute_operation(exe_context, operation, root_value):
+    type = get_operation_root_type(exe_context.schema, operation)
+    execute_serially = operation.operation == 'mutation'
+
+    fragment = Fragment(type=type, selection_set=operation.selection_set, context=exe_context, execute_serially=execute_serially)
+    resolver = type_resolver(type, lambda: root_value, fragment=fragment)
+    resolved = resolver()
+    return resolved

graphql/execution/querybuilder/fragment.py

@@ -1,34 +1,73 @@
 from functools import partial
 from ...pyutils.cached_property import cached_property
 from ..values import get_argument_values, get_variable_values
+from ..base import collect_fields
+from ...pyutils.default_ordered_dict import DefaultOrderedDict
 
 
+from ...type import GraphQLList, GraphQLNonNull, GraphQLObjectType, GraphQLInterfaceType, GraphQLUnionType
+
+
+def get_base_type(type):
+    if isinstance(type, (GraphQLList, GraphQLNonNull)):
+        return get_base_type(type.of_type)
+    return type
+
+
+def get_resolvers(context, type, selection_set):
+    from .resolver import field_resolver
+    subfield_asts = DefaultOrderedDict(list)
+    visited_fragment_names = set()
+    if selection_set:
+        subfield_asts = collect_fields(
+            context, type, selection_set,
+            subfield_asts, visited_fragment_names
+        )
+
+    resolvers = []
+    for response_name, field_asts in subfield_asts.items():
+        field_ast = field_asts[0]
+        field_name = field_ast.name.value
+        field_def = type.fields[field_name]
+        field_base_type = get_base_type(field_def.type)
+        field_fragment = None
+        if isinstance(field_base_type, GraphQLObjectType):
+            field_fragment = Fragment(
+                type=field_base_type,
+                selection_set=field_ast.selection_set,
+                context=context
+            )
+        elif isinstance(field_base_type, (GraphQLInterfaceType, GraphQLUnionType)):
+            field_fragment = AbstractFragment(
+                abstract_type=field_base_type,
+                selection_set=field_ast.selection_set,
+                context=context
+            )
+        resolver = field_resolver(field_def, fragment=field_fragment)
+        args = get_argument_values(
+            field_def.args,
+            field_ast.arguments,
+            context and context.variable_values
+        )
+        resolver = partial(resolver, args=args)
+        resolvers.append((response_name, resolver))
+    return resolvers
+
 
 class Fragment(object):
-    def __init__(self, type, field_asts, field_fragments=None, execute_serially=False):
+    def __init__(self, type, selection_set, context=None, execute_serially=False):
         self.type = type
-        self.field_asts = field_asts
-        self.field_fragments = field_fragments or {}
-        self.variable_values = {}
+        self.selection_set = selection_set
         self.execute_serially = execute_serially
+        self.context = context
 
     @cached_property
     def partial_resolvers(self):
-        from .resolver import field_resolver
-        resolvers = []
-        for field_ast in self.field_asts:
-            field_name = field_ast.name.value
-            field_def = self.type.fields[field_name]
-            field_fragment = self.field_fragments.get(field_name)
-            resolver = field_resolver(field_def, fragment=field_fragment)
-            args = get_argument_values(
-                field_def.args,
-                field_ast.arguments,
-                self.variable_values
-            )
-            resolver = partial(resolver, args=args)
-            resolvers.append((field_name, resolver))
-        return resolvers
+        return get_resolvers(
+            self.context,
+            self.type,
+            self.selection_set
+        )
 
     def resolver(self, resolver, *args, **kwargs):
         root = resolver(*args, **kwargs)
@@ -40,7 +79,51 @@ def resolver(self, resolver, *args, **kwargs):
     def __eq__(self, other):
         return isinstance(other, Fragment) and (
             other.type == self.type and
-            other.field_asts == self.field_asts and
-            other.field_fragments == self.field_fragments and
+            other.selection_set == self.selection_set and
+            other.context == self.context and
             other.execute_serially == self.execute_serially
         )
+
+
+class AbstractFragment(object):
+    def __init__(self, abstract_type, selection_set, context=None, execute_serially=False):
+        self.abstract_type = abstract_type
+        self.selection_set = selection_set
+        self.context = context
+        # self.execute_serially = execute_serially # Technically impossible
+        self._type_resolvers = {}
+
+    @cached_property
+    def possible_types(self):
+        return self.context.schema.get_possible_types(self.abstract_type)
+
+    def get_type_resolvers(self, type):
+        if type not in self._type_resolvers:
+            assert type in self.possible_types
+            self._type_resolvers[type] = get_resolvers(
+                self.context,
+                type,
+                self.selection_set
+            )
+        return self._type_resolvers[type]
+
+    def resolve_type(self, result):
+        return_type = self.abstract_type
+        context = self.context.context_value
+        info = None
+
+        if return_type.resolve_type:
+            runtime_type = return_type.resolve_type(result, context, info)
+        else:
+            for type in self.possible_types:
+                if callable(type.is_type_of) and type.is_type_of(result, context, info):
+                    return type
+
+    def resolver(self, resolver, *args, **kwargs):
+        root = resolver(*args, **kwargs)
+        _type = self.resolve_type(root)
+
+        return {
+            field_name: field_resolver(root)
+            for field_name, field_resolver in self.get_type_resolvers(_type)
+        }

graphql/execution/querybuilder/querybuilder.py

@@ -1,91 +1,91 @@
-# -*- coding: utf-8 -*-
-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
+# # -*- coding: utf-8 -*-
+# 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
 
-from ...type import (GraphQLEnumType, GraphQLInterfaceType, GraphQLList,
-                     GraphQLNonNull, GraphQLObjectType, GraphQLScalarType,
-                     GraphQLSchema, GraphQLUnionType)
-from ..base import (ExecutionContext, ExecutionResult, ResolveInfo, Undefined,
-                    collect_fields, default_resolve_fn, get_field_def,
-                    get_operation_root_type)
+# from ...type import (GraphQLEnumType, GraphQLInterfaceType, GraphQLList,
+#                      GraphQLNonNull, GraphQLObjectType, GraphQLScalarType,
+#                      GraphQLSchema, GraphQLUnionType)
+# from ..base import (ExecutionContext, ExecutionResult, ResolveInfo, Undefined,
+#                     collect_fields, default_resolve_fn, get_field_def,
+#                     get_operation_root_type)
 
-from .fragment import Fragment
+# from .fragment import Fragment
 
 
-def get_base_type(type):
-    if isinstance(type, (GraphQLList, GraphQLNonNull)):
-        return get_base_type(type.of_type)
-    return type
+# def get_base_type(type):
+#     if isinstance(type, (GraphQLList, GraphQLNonNull)):
+#         return get_base_type(type.of_type)
+#     return type
 
 
-class QueryBuilder(object):
+# class QueryBuilder(object):
 
-    __slots__ = 'schema', 'operations', 'fragments'
+#     __slots__ = 'schema', 'operations', 'fragments'
 
-    def __init__(self, schema, document_ast):
-        operations = {}
-        fragments = {}
+#     def __init__(self, schema, document_ast):
+#         operations = {}
+#         fragments = {}
 
-        for definition in document_ast.definitions:
-            if isinstance(definition, ast.OperationDefinition):
-                operation_name  = definition.name.value
-                operations[operation_name] = definition
+#         for definition in document_ast.definitions:
+#             if isinstance(definition, ast.OperationDefinition):
+#                 operation_name  = definition.name.value
+#                 operations[operation_name] = definition
 
-            elif isinstance(definition, ast.FragmentDefinition):
-                fragment_name = definition.name.value
-                fragments[fragment_name] = definition
+#             elif isinstance(definition, ast.FragmentDefinition):
+#                 fragment_name = definition.name.value
+#                 fragments[fragment_name] = definition
 
-            else:
-                raise GraphQLError(
-                    u'GraphQL cannot execute a request containing a {}.'.format(definition.__class__.__name__),
-                    definition
-                )
+#             else:
+#                 raise GraphQLError(
+#                     u'GraphQL cannot execute a request containing a {}.'.format(definition.__class__.__name__),
+#                     definition
+#                 )
 
-        if not operations:
-            raise GraphQLError('Must provide an operation.')
+#         if not operations:
+#             raise GraphQLError('Must provide an operation.')
 
-        self.fragments = fragments
-        self.schema = schema
-        self.operations = {}
+#         self.fragments = fragments
+#         self.schema = schema
+#         self.operations = {}
 
-        for operation_name, operation in operations.items():
-            self.operations[operation_name] = fragment_operation(self.schema, operation)
+#         for operation_name, operation in operations.items():
+#             self.operations[operation_name] = fragment_operation(self.schema, operation)
 
-    def get_operation_fragment(self, operation_name):
-        return self.operations[operation_name]
+#     def get_operation_fragment(self, operation_name):
+#         return self.operations[operation_name]
 
 
-def fragment_operation(schema, operation):
-    field_asts = operation.selection_set.selections
-    root_type = get_operation_root_type(schema, operation)
-    execute_serially = operation.operation == 'mutation'
-    return generate_fragment(root_type, field_asts, execute_serially)
+# def fragment_operation(schema, operation):
+#     field_asts = operation.selection_set.selections
+#     root_type = get_operation_root_type(schema, operation)
+#     execute_serially = operation.operation == 'mutation'
+#     return generate_fragment(root_type, field_asts, execute_serially)
 
 
-def generate_fragment(type, field_asts, execute_serially=False):
-    field_fragments = {}
-    for field_ast in field_asts:
-        field_name = field_ast.name.value
-        field_def = type.fields[field_name]
-        field_base_type = get_base_type(field_def.type)
-        if not isinstance(field_base_type, GraphQLObjectType):
-            continue
-        field_fragments[field_name] = generate_fragment(field_base_type, field_ast.selection_set.selections)
+# def generate_fragment(type, field_asts, execute_serially=False):
+#     field_fragments = {}
+#     for field_ast in field_asts:
+#         field_name = field_ast.name.value
+#         field_def = type.fields[field_name]
+#         field_base_type = get_base_type(field_def.type)
+#         if not isinstance(field_base_type, GraphQLObjectType):
+#             continue
+#         field_fragments[field_name] = generate_fragment(field_base_type, field_ast.selection_set.selections)
 
-    return Fragment(
-        type,
-        field_asts,
-        field_fragments,
-        execute_serially=execute_serially
-    )
+#     return Fragment(
+#         type,
+#         field_asts,
+#         field_fragments,
+#         execute_serially=execute_serially
+#     )
 
 
-def build_query(schema, document_ast):
-    static_context = QueryBuilder(schema, document_ast)
+# def build_query(schema, document_ast):
+#     static_context = QueryBuilder(schema, document_ast)