Improved Promise.all() to accept non-promise items

Author: syrusakbary

graphql/execution/execute.py

@@ -36,12 +36,10 @@ def executor(resolve, reject):
         return resolve(execute_operation(context, context.operation, root_value))
 
     def on_rejected(error):
-        # print "ON=REJECTED", error
         context.errors.append(error)
         return None
 
     def on_resolve(data):
-        # print "ON=RESOLVE", data
         return ExecutionResult(data=data, errors=context.errors)
 
     return Promise(executor).catch(on_rejected).then(on_resolve).value
@@ -133,7 +131,7 @@ def execute_fields(exe_context, parent_type, source_value, fields):
     if not contains_promise:
         return final_results
 
-    return promise_for_dict(final_results, collections.OrderedDict)
+    return promise_for_dict(final_results)
 
 
 def resolve_field(exe_context, parent_type, source, field_asts):
@@ -195,17 +193,14 @@ def complete_value_catching_error(exe_context, return_type, field_asts, info, re
     try:
         completed = complete_value(exe_context, return_type, field_asts, info, result)
         if is_thenable(completed):
-            # TODO: Check if is None or Undefined
             def handle_error(error):
-                # print "HANDLE=ERROR", error
                 exe_context.errors.append(error)
-                return Promise.resolved(None)
+                return Promise.fulfilled(None)
 
             return promisify(completed).then(None, handle_error)
 
         return completed
     except Exception as e:
-        # print "GENERAL=EXCEPTION", e
         exe_context.errors.append(e)
         return None
 
@@ -232,15 +227,15 @@ 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):
-        promisify(result).then(
+        return promisify(result).then(
             lambda resolved: complete_value(
                 exe_context,
                 return_type,
                 field_asts,
                 info,
                 resolved
             ),
-            lambda error: Promise.rejected(GraphQLError(error.value and str(error.value), field_asts, error))
+            lambda error: Promise.rejected(GraphQLError(error and str(error), field_asts, error))
         )
 
     if isinstance(result, Exception):

graphql/execution/tests/test_lists.py

@@ -3,7 +3,7 @@
 from graphql.error import format_error
 from graphql.execution import execute
 from graphql.language.parser import parse
-from graphql.pyutils.aplus import Promisex
+from graphql.pyutils.aplus import Promise
 from graphql.type import (GraphQLField, GraphQLInt, GraphQLList,
                           GraphQLNonNull, GraphQLObjectType, GraphQLSchema)
 

graphql/pyutils/aplus.py

@@ -53,28 +53,19 @@ def __init__(self, fn=None):
     def do_resolve(self, fn):
         self._done = False
         def resolve_fn(x):
-            print 'RESOLVE FN', x
             if self._done:
                 return
             self._done = True
             self.fulfill(x)
         def reject_fn(x):
-            print 'REJECT FN', x
             if self._done:
                 return
             self._done = True
             self.reject(x)
-        res = None
-        err = None
         try:
-            print 'TRY DO RES'
-            res = fn(resolve_fn, reject_fn)
-            print 'DO RES', res
+            fn(resolve_fn, reject_fn)
         except Exception, e:
-            err = e
-        if not res and err:
-            print "ERR", err
-            self.reject(err)
+            self.reject(e)
 
     @staticmethod
     def fulfilled(x):
@@ -379,8 +370,8 @@ def then_all(self, *handlers):
         return promises
 
     @staticmethod
-    def all(*promises):
-        return listPromise(*promises)
+    def all(values_or_promises):
+        return listPromise(values_or_promises)
 
 
 def _isFunction(v):
@@ -420,66 +411,49 @@ def _promisify(obj):
 
 promisify = _promisify
 
-def listPromise(*promises):
+def listPromise(values_or_promises):
     """
     A special function that takes a bunch of promises
     and turns them into a promise for a vector of values.
     In other words, this turns an list of promises for values
     into a promise for a list of values.
     """
-    if len(promises) == 1 and isinstance(promises[0], list):
-        promises = promises[0]
-
+    promises=filter(_isPromise, values_or_promises)
     if len(promises) == 0:
-        return Promise.fulfilled([])
+        # All the values or promises are resolved
+        return Promise.fulfilled(values_or_promises)
 
     ret = Promise()
     counter = CountdownLatch(len(promises))
 
     def handleSuccess(_):
         if counter.dec() == 0:
-            value = list(map(lambda p: p.value, promises))
-            ret.fulfill(value)
+            values = list(map(lambda p: p.value if p in promises else p, values_or_promises))
+            ret.fulfill(values)
 
     for p in promises:
-        assert _isPromise(p)
-
         _promisify(p).done(handleSuccess, ret.reject)
 
     return ret
 
 
-def dictPromise(m, dict_type=None):
+def dictPromise(m):
     """
     A special function that takes a dictionary of promises
     and turns them into a promise for a dictionary of values.
     In other words, this turns an dictionary of promises for values
     into a promise for a dictionary of values.
     """
-    if len(m) == 0:
+    if not m:
         return Promise.fulfilled({})
 
-    ret = Promise()
-    counter = CountdownLatch(len(m))
-
-    if not dict_type:
-        dict_type = dict
-
-    def handleSuccess(_):
-        if counter.dec() == 0:
-            value = dict_type()
-
-            for k in m:
-                value[k] = m[k].value
-
-            ret.fulfill(value)
+    keys, values = zip(*m.items())
+    dict_type = type(m)
 
-    for p in m.values():
-        assert _isPromise(p)
+    def handleSuccess(values):
+        return dict_type(zip(keys, values))
 
-        _promisify(p).done(handleSuccess, ret.reject)
-
-    return ret
+    return Promise.all(values).then(handleSuccess)
 
 
 promise_for_dict = dictPromise