return async iterables in the non incremental delivery case (#4144)

catching errors

Author: yaacovCR

src/execution/__tests__/lists-test.ts

@@ -1,4 +1,4 @@
-import { expect } from 'chai';
+import { assert, expect } from 'chai';
 import { describe, it } from 'mocha';
 
 import { expectJSON } from '../../__testUtils__/expectJSON.js';
@@ -245,6 +245,34 @@ describe('Execute: Accepts async iterables as list value', () => {
       errors,
     });
   });
+
+  it('Returns async iterable when list nulls', async () => {
+    const values = [1, null, 2];
+    let i = 0;
+    let returned = false;
+    const listField = {
+      [Symbol.asyncIterator]: () => ({
+        next: () => Promise.resolve({ value: values[i++], done: false }),
+        return: () => {
+          returned = true;
+          return Promise.resolve({ value: undefined, done: true });
+        },
+      }),
+    };
+    const errors = [
+      {
+        message: 'Cannot return null for non-nullable field Query.listField.',
+        locations: [{ line: 1, column: 3 }],
+        path: ['listField', 1],
+      },
+    ];
+
+    expectJSON(await complete({ listField }, '[Int!]')).toDeepEqual({
+      data: { listField: null },
+      errors,
+    });
+    assert(returned);
+  });
 });
 
 describe('Execute: Handles list nullability', () => {

src/execution/execute.ts

@@ -779,56 +779,67 @@ async function completeAsyncIteratorValue(
   let containsPromise = false;
   const completedResults: Array<unknown> = [];
   let index = 0;
-  // eslint-disable-next-line no-constant-condition
-  while (true) {
-    const itemPath = addPath(path, index, undefined);
-    let iteration;
-    try {
-      // eslint-disable-next-line no-await-in-loop
-      iteration = await asyncIterator.next();
+  const earlyReturn = asyncIterator.return?.bind(asyncIterator);
+  try {
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+      const itemPath = addPath(path, index, undefined);
+      let iteration;
+      try {
+        // eslint-disable-next-line no-await-in-loop
+        iteration = await asyncIterator.next();
+      } catch (rawError) {
+        throw locatedError(rawError, fieldGroup, pathToArray(path));
+      }
+
+      // TODO: add test case for stream returning done before initialCount
+      /* c8 ignore next 3 */
       if (iteration.done) {
         break;
       }
-    } catch (rawError) {
-      throw locatedError(rawError, fieldGroup, pathToArray(path));
-    }
 
-    // TODO: add test case for stream returning done before initialCount
-    /* c8 ignore next 3 */
-    if (iteration.done) {
-      break;
-    }
-
-    const item = iteration.value;
-    // TODO: add tests for stream backed by asyncIterator that returns a promise
-    /* c8 ignore start */
-    if (isPromise(item)) {
-      completedResults.push(
-        completePromisedListItemValue(
+      const item = iteration.value;
+      // TODO: add tests for stream backed by asyncIterator that returns a promise
+      /* c8 ignore start */
+      if (isPromise(item)) {
+        completedResults.push(
+          completePromisedListItemValue(
+            item,
+            exeContext,
+            itemType,
+            fieldGroup,
+            info,
+            itemPath,
+          ),
+        );
+        containsPromise = true;
+      } else if (
+        /* c8 ignore stop */
+        completeListItemValue(
           item,
+          completedResults,
           exeContext,
           itemType,
           fieldGroup,
           info,
           itemPath,
-        ),
-      );
-      containsPromise = true;
-    } else if (
+        )
+        // TODO: add tests for stream backed by asyncIterator that completes to a promise
+        /* c8 ignore start */
+      ) {
+        containsPromise = true;
+      }
       /* c8 ignore stop */
-      completeListItemValue(
-        item,
-        completedResults,
-        exeContext,
-        itemType,
-        fieldGroup,
-        info,
-        itemPath,
-      )
-    ) {
-      containsPromise = true;
+      index++;
     }
-    index += 1;
+  } catch (error) {
+    if (earlyReturn !== undefined) {
+      earlyReturn().catch(() => {
+        /* c8 ignore next 1 */
+        // ignore error
+      });
+    }
+    throw error;
   }
   return containsPromise ? Promise.all(completedResults) : completedResults;
 }