EPRs to tuples

Author: mohawk2

src/execution/execute.js

@@ -108,13 +108,13 @@ export type ExecutionResult = {
 };
 
 /**
- * A partial result of GraphQL execution. `data` and `errors` as above.
- * "NP" = "Not Promise".
+ * A partial result of GraphQL execution. `data` and `errors` as above, but
+ * tuple to avoid allocating/destroying objects. "NP" = "Not Promise".
  */
-export type ExecutionPartialResultNP<T> = {
-  errors?: $ReadOnlyArray<GraphQLError>,
-  data?: T | null,
-};
+export type ExecutionPartialResultNP<T> = [
+  T | null,
+  $ReadOnlyArray<GraphQLError> | null,
+];
 
 /**
  * A partial result of GraphQL execution. `data` and `errors` as above.
@@ -239,17 +239,17 @@ function executeImpl(
 }
 
 /**
- * Strip out `errors` if empty.
+ * Given a completed ExecutionPartialResult, build the { errors, data }
+ * response defined by the "Response" section of the GraphQL specification.
  */
 function buildResponse(result: ExecutionPartialResult<mixed>) {
   const promise = getPromise(result);
   if (promise) {
     return promise.then(resolved => buildResponse(resolved));
   }
-  if (result.data && (!result.errors || !result.errors.length)) {
-    return { data: result.data };
-  }
-  return result;
+  return !result[1] || result[1].length === 0
+    ? { data: result[0] }
+    : { data: result[0], errors: result[1] };
 }
 
 /**
@@ -418,14 +418,11 @@ function executeOperation(
         : executeFields(exeContext, type, rootValue, path, fields);
     const promise = getPromise(result);
     if (promise) {
-      return promise.then(undefined, error => ({
-        data: null,
-        errors: [error],
-      }));
+      return promise.then(undefined, error => [null, [error]]);
     }
     return result;
   } catch (error) {
-    return { data: null, errors: [error] };
+    return [null, [error]];
   }
 }
 
@@ -564,13 +561,13 @@ function mergeEPRs(
   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(...value.errors);
+      merged[0][keys[i]] = value[0];
+      if (value[1] && value[1].length) {
+        merged[1].push(...value[1]);
       }
       return merged;
     },
-    { data: Object.create(null), errors: [] },
+    [Object.create(null), []],
   );
 }
 
@@ -879,16 +876,13 @@ function completeValueCatchingError(
       // the rejection error and resolve to null.
       // Note: we don't rely on a `catch` method, but we do expect "thenable"
       // to take a second callback for the error case.
-      return promise.then(undefined, error => ({
-        data: null,
-        errors: [error],
-      }));
+      return promise.then(undefined, error => [null, [error]]);
     }
     return completed;
   } catch (error) {
     // If `completeValueWithLocatedError` returned abruptly (threw an error),
     // log the error and return null.
-    return { data: null, errors: [error] };
+    return [null, [error]];
   }
 }
 
@@ -986,7 +980,7 @@ function completeValue(
       path,
       result,
     );
-    if (completed.data === null) {
+    if (completed[0] === null) {
       throw new Error(
         `Cannot return null for non-nullable field ${info.parentType.name}.${
           info.fieldName
@@ -998,7 +992,7 @@ function completeValue(
 
   // If result value is null-ish (null, undefined, or NaN) then return null.
   if (isNullish(result)) {
-    return { data: null };
+    return [null, null];
   }
 
   // If field type is List, complete each item in the list with the inner type
@@ -1016,7 +1010,7 @@ function completeValue(
   // If field type is a leaf type, Scalar or Enum, serialize to a valid value,
   // returning null if serialization is not possible.
   if (isLeafType(returnType)) {
-    return { data: completeLeafValue(returnType, result) };
+    return [completeLeafValue(returnType, result), null];
   }
 
   // If field type is an abstract type, Interface or Union, determine the
@@ -1107,12 +1101,12 @@ function flattenEPRs(
   const errors = [];
   const data = [];
   forEach((eprs: any), item => {
-    data.push(item.data);
-    if (item.errors && item.errors.length) {
-      errors.push(...item.errors);
+    data.push(item[0]);
+    if (item[1] && item[1].length) {
+      errors.push(...item[1]);
     }
   });
-  return { data, errors };
+  return [data, errors.length ? errors : null];
 }
 
 /**