correctly handle promises returned by completeValue in async iterable resovlers

# Conflicts:
#	src/execution/execute.js

Author: robrichard

src/execution/__tests__/lists-test.js

@@ -2,6 +2,9 @@ import { expect } from 'chai';
 import { describe, it } from 'mocha';
 
 import { parse } from '../../language/parser';
+import { GraphQLList, GraphQLObjectType } from '../../type/definition';
+import { GraphQLString } from '../../type/scalars';
+import { GraphQLSchema } from '../../type/schema';
 
 import { buildSchema } from '../../utilities/buildASTSchema';
 
@@ -73,6 +76,38 @@ describe('Execute: Accepts async iterables as list value', () => {
     });
   }
 
+  function completeObjectList(resolve) {
+    const schema = new GraphQLSchema({
+      query: new GraphQLObjectType({
+        name: 'Query',
+        fields: {
+          listField: {
+            resolve: async function* listField() {
+              yield await { index: 0 };
+              yield await { index: 1 };
+              yield await { index: 2 };
+            },
+            type: new GraphQLList(
+              new GraphQLObjectType({
+                name: 'ObjectWrapper',
+                fields: {
+                  index: {
+                    type: GraphQLString,
+                    resolve,
+                  },
+                },
+              }),
+            ),
+          },
+        },
+      }),
+    });
+    return execute({
+      schema,
+      document: parse('{ listField { index } }'),
+    });
+  }
+
   it('Accepts an AsyncGenerator function as a List value', async () => {
     async function* listField() {
       yield await 'two';
@@ -121,6 +156,34 @@ describe('Execute: Accepts async iterables as list value', () => {
       ],
     });
   });
+
+  it('Handles promises from `completeValue` in AsyncIterables', async () => {
+    expect(
+      await completeObjectList(({ index }) => Promise.resolve(index)),
+    ).to.deep.equal({
+      data: { listField: [{ index: '0' }, { index: '1' }, { index: '2' }] },
+    });
+  });
+
+  it('Handles rejected promises from `completeValue` in AsyncIterables', async () => {
+    expect(
+      await completeObjectList(({ index }) => {
+        if (index === 2) {
+          return Promise.reject(new Error('bad'));
+        }
+        return Promise.resolve(index);
+      }),
+    ).to.deep.equal({
+      data: { listField: [{ index: '0' }, { index: '1' }, { index: null }] },
+      errors: [
+        {
+          message: 'bad',
+          locations: [{ line: 1, column: 15 }],
+          path: ['listField', 2, 'index'],
+        },
+      ],
+    });
+  });
 });
 
 describe('Execute: Handles list nullability', () => {

src/execution/execute.js

@@ -869,6 +869,7 @@ function completeAsyncIteratorValue(
   path: Path,
   iterator: AsyncIterator<mixed>,
 ): Promise<$ReadOnlyArray<mixed>> {
+  let containsPromise = false;
   return new Promise((resolve) => {
     function next(index, completedResults) {
       const fieldPath = addPath(path, index, undefined);
@@ -880,16 +881,18 @@ function completeAsyncIteratorValue(
           }
           // TODO can the error checking logic be consolidated with completeListValue?
           try {
-            completedResults.push(
-              completeValue(
-                exeContext,
-                itemType,
-                fieldNodes,
-                info,
-                fieldPath,
-                value,
-              ),
+            const completedItem = completeValue(
+              exeContext,
+              itemType,
+              fieldNodes,
+              info,
+              fieldPath,
+              value,
             );
+            if (isPromise(completedItem)) {
+              containsPromise = true;
+            }
+            completedResults.push(completedItem);
           } catch (rawError) {
             completedResults.push(null);
             const error = locatedError(
@@ -917,7 +920,9 @@ function completeAsyncIteratorValue(
       );
     }
     next(0, []);
-  });
+  }).then((completedResults) =>
+    containsPromise ? Promise.all(completedResults) : completedResults,
+  );
 }
 
 /**