Merge pull request #74 from graphql-python/features/next-query-builder

Query Builder + Promise 2.0 + DataLoader

Author: syrusakbary

.travis.yml

@@ -21,10 +21,7 @@ before_install:
     source "$HOME/virtualenvs/pypy-$PYPY_VERSION/bin/activate"
   fi
 install:
-- pip install pytest-cov pytest-mock coveralls flake8 gevent==1.1b5 six>=1.10.0 promise>=0.4.2
-  pytest-benchmark
-- pip install pytest==2.9.2
-- pip install -e .
+- pip install -e .[test]
 script:
 - py.test --cov=graphql graphql tests
 after_success:
@@ -37,6 +34,7 @@ matrix:
     script:
     - py.test --cov=graphql graphql tests tests_py35
   - python: '2.7'
+    install: pip install flake8
     script:
     - flake8
 deploy:

graphql/error/tests/test_base.py

@@ -47,4 +47,14 @@ def resolver(context, *_):
         ('resolve_or_error', 'return executor.execute(resolve_fn, source, args, context, info)'),
         ('execute', 'return fn(*args, **kwargs)'), ('resolver', "raise Exception('Failed')")
     ]
+    # assert formatted_tb == [
+    #     ('test_reraise', 'result.errors[0].reraise()'),
+    #     ('reraise', 'six.reraise(type(self), self, self.stack)'),
+    #     ('on_complete_resolver', 'result = __resolver(*args, **kwargs)'),
+    #     # ('reraise', 'raise value.with_traceback(tb)'),
+    #     # ('resolve_or_error', 'return executor.execute(resolve_fn, source, args, context, info)'),
+    #     # ('execute', 'return fn(*args, **kwargs)'),
+    #     ('resolver', "raise Exception('Failed')")
+    # ]
+
     assert str(exc_info.value) == 'Failed'

graphql/execution/executor.py

@@ -4,7 +4,7 @@
 import sys
 
 from six import string_types
-from promise import Promise, promise_for_dict, promisify, is_thenable
+from promise import Promise, promise_for_dict, is_thenable
 
 from ..error import GraphQLError, GraphQLLocatedError
 from ..pyutils.default_ordered_dict import DefaultOrderedDict
@@ -16,6 +16,7 @@
                    collect_fields, default_resolve_fn, get_field_def,
                    get_operation_root_type)
 from .executors.sync import SyncExecutor
+from .experimental.executor import execute as experimental_execute
 from .middleware import MiddlewareManager
 
 logger = logging.getLogger(__name__)
@@ -25,9 +26,19 @@ def is_promise(obj):
     return type(obj) == Promise
 
 
+use_experimental_executor = False
+
+
 def execute(schema, document_ast, root_value=None, context_value=None,
             variable_values=None, operation_name=None, executor=None,
             return_promise=False, middleware=None):
+    if use_experimental_executor:
+        return experimental_execute(
+            schema, document_ast, root_value, context_value,
+            variable_values, operation_name, executor,
+            return_promise, middleware
+        )
+
     assert schema, 'Must provide schema'
     assert isinstance(schema, GraphQLSchema), (
         'Schema must be an instance of GraphQLSchema. Also ensure that there are ' +
@@ -106,7 +117,7 @@ def collect_result(resolved_result):
                 results[response_name] = resolved_result
                 return results
 
-            return promisify(result).then(collect_result, None)
+            return result.then(collect_result, None)
 
         results[response_name] = result
         return results
@@ -210,9 +221,9 @@ def complete_value_catching_error(exe_context, return_type, field_asts, info, re
         if is_thenable(completed):
             def handle_error(error):
                 exe_context.errors.append(error)
-                return Promise.fulfilled(None)
+                return None
 
-            return promisify(completed).then(None, handle_error)
+            return completed.catch(handle_error)
 
         return completed
     except Exception as e:
@@ -242,7 +253,7 @@ def complete_value(exe_context, return_type, field_asts, info, result):
     # If field type is NonNull, complete for inner type, and throw field error if result is null.
 
     if is_thenable(result):
-        return promisify(result).then(
+        return Promise.resolve(result).then(
             lambda resolved: complete_value(
                 exe_context,
                 return_type,

graphql/execution/executors/asyncio.py

@@ -2,7 +2,7 @@
 
 from asyncio import Future, get_event_loop, iscoroutine, wait
 
-from promise import promisify
+from promise import Promise
 
 try:
     from asyncio import ensure_future
@@ -49,5 +49,5 @@ def execute(self, fn, *args, **kwargs):
         if isinstance(result, Future) or iscoroutine(result):
             future = ensure_future(result, loop=self.loop)
             self.futures.append(future)
-            return promisify(future)
+            return Promise.resolve(future)
         return result

graphql/execution/executors/utils.py

@@ -1,6 +1,6 @@
 def process(p, f, args, kwargs):
     try:
         val = f(*args, **kwargs)
-        p.fulfill(val)
+        p.do_resolve(val)
     except Exception as e:
-        p.reject(e)
+        p.do_reject(e)

graphql/execution/experimental/__init__.py

@@ -0,0 +1,64 @@
+from promise import Promise
+
+from ...type import GraphQLSchema
+from ..base import ExecutionContext, ExecutionResult, get_operation_root_type
+from ..executors.sync import SyncExecutor
+from ..middleware import MiddlewareManager
+from .fragment import Fragment
+
+
+def execute(schema, document_ast, root_value=None, context_value=None,
+            variable_values=None, operation_name=None, executor=None,
+            return_promise=False, middleware=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 middleware:
+        if not isinstance(middleware, MiddlewareManager):
+            middleware = MiddlewareManager(*middleware)
+        assert isinstance(middleware, MiddlewareManager), (
+            'middlewares have to be an instance'
+            ' of MiddlewareManager. Received "{}".'.format(middleware)
+        )
+
+    if executor is None:
+        executor = SyncExecutor()
+
+    context = ExecutionContext(
+        schema,
+        document_ast,
+        root_value,
+        context_value,
+        variable_values,
+        operation_name,
+        executor,
+        middleware
+    )
+
+    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, field_asts=[operation], context=exe_context)
+    if execute_serially:
+        return fragment.resolve_serially(root_value)
+    return fragment.resolve(root_value)