Execute serially supporting sync execution.

Refactors executeFieldsSerially to return MaybePromise

Fixes #1195

Author: leebyron

src/execution/execute.js

@@ -9,10 +9,12 @@
 
 import { forEach, isCollection } from 'iterall';
 import { GraphQLError, locatedError } from '../error';
+import getPromise from '../jsutils/getPromise';
 import invariant from '../jsutils/invariant';
 import isInvalid from '../jsutils/isInvalid';
 import isNullish from '../jsutils/isNullish';
 import memoize3 from '../jsutils/memoize3';
+import promiseReduce from '../jsutils/promiseReduce';
 import type { ObjMap } from '../jsutils/ObjMap';
 import type { MaybePromise } from '../jsutils/MaybePromise';
 
@@ -465,33 +467,33 @@ function executeFieldsSerially(
   sourceValue: mixed,
   path: ResponsePath | void,
   fields: ObjMap<Array<FieldNode>>,
-): Promise<ObjMap<mixed>> {
-  return Object.keys(fields).reduce(
-    (prevPromise, responseName) =>
-      prevPromise.then(results => {
-        const fieldNodes = fields[responseName];
-        const fieldPath = addPath(path, responseName);
-        const result = resolveField(
-          exeContext,
-          parentType,
-          sourceValue,
-          fieldNodes,
-          fieldPath,
-        );
-        if (result === undefined) {
-          return results;
-        }
-        const promise = getPromise(result);
-        if (promise) {
-          return promise.then(resolvedResult => {
-            results[responseName] = resolvedResult;
-            return results;
-          });
-        }
-        results[responseName] = result;
+): MaybePromise<ObjMap<mixed>> {
+  return promiseReduce(
+    Object.keys(fields),
+    (results, responseName) => {
+      const fieldNodes = fields[responseName];
+      const fieldPath = addPath(path, responseName);
+      const result = resolveField(
+        exeContext,
+        parentType,
+        sourceValue,
+        fieldNodes,
+        fieldPath,
+      );
+      if (result === undefined) {
         return results;
-      }),
-    Promise.resolve({}),
+      }
+      const promise = getPromise(result);
+      if (promise) {
+        return promise.then(resolvedResult => {
+          results[responseName] = resolvedResult;
+          return results;
+        });
+      }
+      results[responseName] = result;
+      return results;
+    },
+    Object.create(null),
   );
 }
 
@@ -1346,20 +1348,6 @@ export const defaultFieldResolver: GraphQLFieldResolver<any, *> = function(
   }
 };
 
-/**
- * Only returns the value if it acts like a Promise, i.e. has a "then" function,
- * otherwise returns void.
- */
-function getPromise<T>(value: Promise<T> | mixed): Promise<T> | void {
-  if (
-    typeof value === 'object' &&
-    value !== null &&
-    typeof value.then === 'function'
-  ) {
-    return (value: any);
-  }
-}
-
 /**
  * This method looks up the field on the given type defintion.
  * It has special casing for the two introspection fields, __schema

src/jsutils/getPromise.js

@@ -0,0 +1,24 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ */
+
+/**
+ * Only returns the value if it acts like a Promise, i.e. has a "then" function,
+ * otherwise returns void.
+ */
+export default function getPromise<T>(
+  value: Promise<T> | mixed,
+): Promise<T> | void {
+  if (
+    typeof value === 'object' &&
+    value !== null &&
+    typeof value.then === 'function'
+  ) {
+    return (value: any);
+  }
+}

src/jsutils/promiseReduce.js

@@ -0,0 +1,32 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ */
+
+import getPromise from './getPromise';
+import type { MaybePromise } from './MaybePromise';
+
+/**
+ * Similar to Array.prototype.reduce(), however the reducing callback may return
+ * a Promise, in which case reduction will continue after each promise resolves.
+ *
+ * If the callback does not return a Promise, then this function will also not
+ * return a Promise.
+ */
+export default function promiseReduce<T, V>(
+  values: $ReadOnlyArray<V>,
+  callback: (T, V) => MaybePromise<T>,
+  initialValue: T,
+): MaybePromise<T> {
+  return values.reduce((accumulator, value) => {
+    const promise = getPromise(accumulator);
+    if (promise) {
+      return promise.then(resolved => callback(resolved, value));
+    }
+    return callback(accumulator, value);
+  }, initialValue);
+}