use complete helpers within completeListItemValue

The optimized helpers change the order of promise resolution and affect
the value of hasNext.

Author: yaacovCR

src/execution/__tests__/stream-test.ts

@@ -483,6 +483,11 @@ describe('Execute: stream directive', () => {
               },
             ],
           },
+        ],
+        hasNext: true,
+      },
+      {
+        incremental: [
           {
             items: [{ name: 'Leia', id: '3' }],
             path: ['friendList', 2],

src/execution/execute.ts

@@ -1092,7 +1092,6 @@ async function completeAsyncIteratorValue(
       completeListItemValue(
         iteration.value,
         completedResults,
-        errors,
         exeContext,
         itemType,
         fieldNodes,
@@ -1122,7 +1121,6 @@ function completeListValue(
   asyncPayloadRecord?: AsyncPayloadRecord,
 ): PromiseOrValue<ReadonlyArray<unknown>> {
   const itemType = returnType.ofType;
-  const errors = asyncPayloadRecord?.errors ?? exeContext.errors;
 
   if (isAsyncIterable(result)) {
     const iterator = result[Symbol.asyncIterator]();
@@ -1181,7 +1179,6 @@ function completeListValue(
       completeListItemValue(
         item,
         completedResults,
-        errors,
         exeContext,
         itemType,
         fieldNodes,
@@ -1207,68 +1204,41 @@ function completeListValue(
 function completeListItemValue(
   item: unknown,
   completedResults: Array<unknown>,
-  errors: Array<GraphQLError>,
   exeContext: ExecutionContext,
   itemType: GraphQLOutputType,
   fieldNodes: ReadonlyArray<FieldNode>,
   info: GraphQLResolveInfo,
   itemPath: Path,
   asyncPayloadRecord?: AsyncPayloadRecord,
 ): boolean {
-  try {
-    let completedItem;
-    if (isPromise(item)) {
-      completedItem = item.then((resolved) =>
-        completeValue(
-          exeContext,
-          itemType,
-          fieldNodes,
-          info,
-          itemPath,
-          resolved,
-          asyncPayloadRecord,
-        ),
-      );
-    } else {
-      completedItem = completeValue(
+  if (isPromise(item)) {
+    completedResults.push(
+      completePromiseCatchingErrors(
         exeContext,
         itemType,
         fieldNodes,
         info,
         itemPath,
         item,
         asyncPayloadRecord,
-      );
-    }
-
-    if (isPromise(completedItem)) {
-      // Note: we don't rely on a `catch` method, but we do expect "thenable"
-      // to take a second callback for the error case.
-      completedResults.push(
-        completedItem.then(undefined, (rawError) => {
-          const error = locatedError(
-            rawError,
-            fieldNodes,
-            pathToArray(itemPath),
-          );
-          const handledError = handleFieldError(error, itemType, errors);
-          filterSubsequentPayloads(exeContext, itemPath, asyncPayloadRecord);
-          return handledError;
-        }),
-      );
+      ),
+    );
+    return true;
+  }
 
-      return true;
-    }
+  const completed = completeValueCatchingErrors(
+    exeContext,
+    itemType,
+    fieldNodes,
+    info,
+    itemPath,
+    item,
+    asyncPayloadRecord,
+  );
 
-    completedResults.push(completedItem);
-  } catch (rawError) {
-    const error = locatedError(rawError, fieldNodes, pathToArray(itemPath));
-    const handledError = handleFieldError(error, itemType, errors);
-    filterSubsequentPayloads(exeContext, itemPath, asyncPayloadRecord);
-    completedResults.push(handledError);
-  }
+  completedResults.push(completed);
 
-  return false;
+  return isPromise(completed);
 }
 
 /**