EPR resolveField

Author: mohawk2

src/execution/execute.js

@@ -520,17 +520,23 @@ function executeFieldsSerially(
           fieldNodes,
           fieldPath,
         );
-        if (result === undefined) {
+        if (result === null) {
           return results;
         }
         const promise = getPromise(result);
         if (promise) {
           return promise.then(resolvedResult => {
-            results[responseName] = resolvedResult;
+            if (resolvedResult.errors && resolvedResult.errors.length) {
+              exeContext.errors.push.apply(exeContext.errors, resolvedResult.errors);
+            }
+            results[responseName] = resolvedResult.data;
             return results;
           });
         }
-        results[responseName] = result;
+        if (result.errors && result.errors.length) {
+          exeContext.errors.push.apply(exeContext.errors, result.errors);
+        }
+        results[responseName] = result.data;
         return results;
       }),
     Promise.resolve({}),
@@ -560,7 +566,7 @@ function executeFields(
       fieldNodes,
       fieldPath,
     );
-    if (result === undefined) {
+    if (result === null) {
       return results;
     }
     results[responseName] = result;
@@ -572,14 +578,40 @@ function executeFields(
 
   // If there are no promises, we can just return the object
   if (!containsPromise) {
-    return finalResults;
+    const merged = mergeEPRs(finalResults);
+    if (merged.errors && merged.errors.length) {
+      exeContext.errors.push.apply(exeContext.errors, merged.errors);
+    }
+    return merged.data;
   }
 
   // Otherwise, results is a map from field name to the result
   // of resolving that field, which is possibly a promise. Return
   // a promise that will return this same map, but with any
   // promises replaced with the values they resolved to.
-  return promiseForObject(finalResults);
+  return promiseForObject(finalResults).then(merged => {
+    if (merged.errors && merged.errors.length) {
+      exeContext.errors.push.apply(exeContext.errors, merged.errors);
+    }
+    return merged.data;
+  });
+}
+
+function mergeEPRs(
+  eprMap: ObjMap<ExecutionPartialResult<mixed>>,
+): ExecutionPartialResult<mixed> {
+  const keys = Object.keys(eprMap);
+  const values = keys.map(name => eprMap[name]);
+  return values.reduce(
+    (merged, value, i) => {
+      merged.data[keys[i]] = value.data;
+      if (value.errors && value.errors.length) {
+        merged.errors.push.apply(merged.errors, value.errors);
+      }
+      return merged;
+    },
+    { data: Object.create(null), errors: [] },
+  );
 }
 
 /**
@@ -705,21 +737,25 @@ function doesFragmentConditionMatch(
 }
 
 /**
- * This function transforms a JS object `ObjMap<Promise<T>>` into
- * a `Promise<ObjMap<T>>`
+ * This function transforms a JS object `ObjMap<ExecutionPartialResult<T>>` into
+ * a `ExecutionPartialResult<T>`
  *
  * This is akin to bluebird's `Promise.props`, but implemented only using
  * `Promise.all` so it will work with any implementation of ES6 promises.
  */
-function promiseForObject<T>(object: ObjMap<Promise<T>>): Promise<ObjMap<T>> {
+function promiseForObject<T>(
+  object: ObjMap<ExecutionPartialResult<T>>,
+): ExecutionPartialResult<T> {
   const keys = Object.keys(object);
   const valuesAndPromises = keys.map(name => object[name]);
-  return Promise.all(valuesAndPromises).then(values =>
-    values.reduce((resolvedObject, value, i) => {
-      resolvedObject[keys[i]] = value;
-      return resolvedObject;
-    }, Object.create(null)),
-  );
+  return Promise.all(valuesAndPromises)
+    .then(values =>
+      values.reduce((resolvedObject, value, i) => {
+        resolvedObject[keys[i]] = value;
+        return resolvedObject;
+      }, Object.create(null)),
+    )
+    .then(valueMap => mergeEPRs(valueMap));
 }
 
 /**
@@ -741,13 +777,13 @@ function resolveField(
   source: mixed,
   fieldNodes: $ReadOnlyArray<FieldNode>,
   path: ResponsePath,
-): mixed {
+): ExecutionPartialResult<mixed> | null {
   const fieldNode = fieldNodes[0];
   const fieldName = fieldNode.name.value;
 
   const fieldDef = getFieldDef(exeContext.schema, parentType, fieldName);
   if (!fieldDef) {
-    return;
+    return null;
   }
 
   const resolveFn = fieldDef.resolve || exeContext.fieldResolver;
@@ -771,27 +807,14 @@ function resolveField(
     info,
   );
 
-  const completed = completeValueCatchingError(
+  return completeValueCatchingError(
     exeContext,
     fieldDef.type,
     fieldNodes,
     info,
     path,
     result,
   );
-  const promise = getPromise(completed);
-  if (promise) {
-    return promise.then(r => {
-      if (r.errors && r.errors.length) {
-        exeContext.errors.push.apply(exeContext.errors, r.errors);
-      }
-      return r.data;
-    });
-  }
-  if (completed.errors && completed.errors.length) {
-    exeContext.errors.push.apply(exeContext.errors, completed.errors);
-  }
-  return completed.data;
 }
 
 export function buildResolveInfo(