EPR collectAndExecuteSubfields, executeFieldsSerially, executeFields

Author: mohawk2

src/execution/execute.js

@@ -440,13 +440,11 @@ function executeOperation(
         : executeFields(exeContext, type, rootValue, path, fields);
     const promise = getPromise(result);
     if (promise) {
-      return promise
-        .then(resolved => ({ data: resolved }))
-        .then(undefined, error =>
-          mergeErrors(exeContext, { data: null, errors: [error] }),
-        );
+      return promise.then(undefined, error =>
+        mergeErrors(exeContext, { data: null, errors: [error] }),
+      );
     }
-    return mergeErrors(exeContext, { data: result });
+    return mergeErrors(exeContext, result);
   } catch (error) {
     return mergeErrors(exeContext, { data: null, errors: [error] });
   }
@@ -503,40 +501,36 @@ 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 === null) {
-          return results;
-        }
-        const promise = getPromise(result);
-        if (promise) {
-          return promise.then(resolvedResult => {
-            if (resolvedResult.errors && resolvedResult.errors.length) {
-              exeContext.errors.push.apply(exeContext.errors, resolvedResult.errors);
-            }
-            results[responseName] = resolvedResult.data;
+): ExecutionPartialResult<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 === null) {
             return results;
-          });
-        }
-        if (result.errors && result.errors.length) {
-          exeContext.errors.push.apply(exeContext.errors, result.errors);
-        }
-        results[responseName] = result.data;
-        return results;
-      }),
-    Promise.resolve({}),
-  );
+          }
+          const promise = getPromise(result);
+          if (promise) {
+            return promise.then(resolvedResult => {
+              results[responseName] = resolvedResult;
+              return results;
+            });
+          }
+          results[responseName] = result;
+          return results;
+        }),
+      Promise.resolve({}),
+    )
+    .then(finalResults => mergeEPRs(finalResults));
 }
 
 /**
@@ -549,7 +543,7 @@ function executeFields(
   sourceValue: mixed,
   path: ResponsePath | void,
   fields: ObjMap<Array<FieldNode>>,
-): MaybePromise<ObjMap<mixed>> {
+): ExecutionPartialResult<mixed> {
   let containsPromise = false;
 
   const finalResults = Object.keys(fields).reduce((results, responseName) => {
@@ -574,23 +568,14 @@ function executeFields(
 
   // If there are no promises, we can just return the object
   if (!containsPromise) {
-    const merged = mergeEPRs(finalResults);
-    if (merged.errors && merged.errors.length) {
-      exeContext.errors.push.apply(exeContext.errors, merged.errors);
-    }
-    return merged.data;
+    return mergeEPRs(finalResults);
   }
 
   // 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).then(merged => {
-    if (merged.errors && merged.errors.length) {
-      exeContext.errors.push.apply(exeContext.errors, merged.errors);
-    }
-    return merged.data;
-  });
+  return promiseForObject(finalResults);
 }
 
 function mergeEPRs(
@@ -1283,19 +1268,14 @@ function completeObjectValue(
         if (!isTypeOfResult) {
           throw invalidReturnTypeError(returnType, result, fieldNodes);
         }
-        const data = collectAndExecuteSubfields(
+        return collectAndExecuteSubfields(
           exeContext,
           returnType,
           fieldNodes,
           info,
           path,
           result,
         );
-        const subpromise = getPromise(data);
-        if (subpromise) {
-          return subpromise.then(d => ({ data: d }));
-        }
-        return { data };
       });
     }
 
@@ -1304,19 +1284,14 @@ function completeObjectValue(
     }
   }
 
-  const subfields = collectAndExecuteSubfields(
+  return collectAndExecuteSubfields(
     exeContext,
     returnType,
     fieldNodes,
     info,
     path,
     result,
   );
-  const subfpromise = getPromise(subfields);
-  if (subfpromise) {
-    return subfpromise.then(d => ({ data: d }));
-  }
-  return { data: subfields };
 }
 
 function invalidReturnTypeError(
@@ -1337,7 +1312,7 @@ function collectAndExecuteSubfields(
   info: GraphQLResolveInfo,
   path: ResponsePath,
   result: mixed,
-): mixed {
+): ExecutionPartialResult<mixed> {
   // Collect sub-fields to execute to complete this value.
   let subFieldNodes = Object.create(null);
   const visitedFragmentNames = Object.create(null);