defer/stream: split incremental delivery into new entry points

src/execution/__tests__/defer-test.ts

@@ -1,10 +1,10 @@
+import { expect } from 'chai';
 import { describe, it } from 'mocha';
 
 import { expectJSON } from '../../__testUtils__/expectJSON';
+import { expectPromise } from '../../__testUtils__/expectPromise';
 import { resolveOnNextTick } from '../../__testUtils__/resolveOnNextTick';
 
-import { isAsyncIterable } from '../../jsutils/isAsyncIterable';
-
 import type { DocumentNode } from '../../language/ast';
 import { parse } from '../../language/parser';
 
@@ -16,7 +16,11 @@ import {
 import { GraphQLID, GraphQLString } from '../../type/scalars';
 import { GraphQLSchema } from '../../type/schema';
 
-import { execute } from '../execute';
+import type {
+  InitialIncrementalExecutionResult,
+  SubsequentIncrementalExecutionResult,
+} from '../execute';
+import { execute, experimentalExecuteIncrementally } from '../execute';
 
 const friendType = new GraphQLObjectType({
   fields: {
@@ -77,23 +81,25 @@ const query = new GraphQLObjectType({
   name: 'Query',
 });
 
-async function complete(document: DocumentNode) {
-  const schema = new GraphQLSchema({ query });
+const schema = new GraphQLSchema({ query });
 
-  const result = await execute({
+async function complete(document: DocumentNode) {
+  const result = await experimentalExecuteIncrementally({
     schema,
     document,
     rootValue: {},
   });
 
-  if (isAsyncIterable(result)) {
-    const results = [];
-    for await (const patch of result) {
+  if ('initialResult' in result) {
+    const results: Array<
+      InitialIncrementalExecutionResult | SubsequentIncrementalExecutionResult
+    > = [result.initialResult];
+    for await (const patch of result.subsequentResults) {
       results.push(patch);
     }
     return results;
   }
-  return result;
+  return result.singleResult;
 }
 
 describe('Execute: defer directive', () => {
@@ -670,4 +676,46 @@ describe('Execute: defer directive', () => {
       },
     ]);
   });
+
+  it('original execute function throws error if anything is deferred and everything else is sync', () => {
+    const doc = `
+    query Deferred {
+      ... @defer { hero { id } }
+    }
+  `;
+    expect(() =>
+      execute({
+        schema,
+        document: parse(doc),
+        rootValue: {},
+      }),
+    ).to.throw(
+      'Executing this GraphQL operation would unexpectedly produce multiple payloads (due to @defer or @stream directive)',
+    );
+  });
+
+  it('original execute function resolves to error if anything is deferred and something else is async', async () => {
+    const doc = `
+    query Deferred {
+      hero { slowField }
+      ... @defer { hero { id } }
+    }
+  `;
+    expectJSON(
+      await expectPromise(
+        execute({
+          schema,
+          document: parse(doc),
+          rootValue: {},
+        }),
+      ).toResolve(),
+    ).toDeepEqual({
+      errors: [
+        {
+          message:
+            'Executing this GraphQL operation would unexpectedly produce multiple payloads (due to @defer or @stream directive)',
+        },
+      ],
+    });
+  });
 });

src/execution/__tests__/lists-test.ts

@@ -14,7 +14,7 @@ import { GraphQLSchema } from '../../type/schema';
 
 import { buildSchema } from '../../utilities/buildASTSchema';
 
-import type { AsyncExecutionResult, ExecutionResult } from '../execute';
+import type { ExecutionResult } from '../execute';
 import { execute, executeSync } from '../execute';
 
 describe('Execute: Accepts any iterable as list value', () => {
@@ -85,9 +85,7 @@ describe('Execute: Accepts async iterables as list value', () => {
 
   function completeObjectList(
     resolve: GraphQLFieldResolver<{ index: number }, unknown>,
-  ): PromiseOrValue<
-    ExecutionResult | AsyncGenerator<AsyncExecutionResult, void, void>
-  > {
+  ): PromiseOrValue<ExecutionResult> {
     const schema = new GraphQLSchema({
       query: new GraphQLObjectType({
         name: 'Query',

src/execution/__tests__/mutations-test.ts

@@ -4,15 +4,17 @@ import { describe, it } from 'mocha';
 import { expectJSON } from '../../__testUtils__/expectJSON';
 import { resolveOnNextTick } from '../../__testUtils__/resolveOnNextTick';
 
-import { isAsyncIterable } from '../../jsutils/isAsyncIterable';
-
 import { parse } from '../../language/parser';
 
 import { GraphQLObjectType } from '../../type/definition';
 import { GraphQLInt } from '../../type/scalars';
 import { GraphQLSchema } from '../../type/schema';
 
-import { execute, executeSync } from '../execute';
+import {
+  execute,
+  executeSync,
+  experimentalExecuteIncrementally,
+} from '../execute';
 
 class NumberHolder {
   theNumber: number;
@@ -216,15 +218,16 @@ describe('Execute: Handles mutation execution ordering', () => {
     `);
 
     const rootValue = new Root(6);
-    const mutationResult = await execute({
+    const mutationResult = await experimentalExecuteIncrementally({
       schema,
       document,
       rootValue,
     });
     const patches = [];
 
-    assert(isAsyncIterable(mutationResult));
-    for await (const patch of mutationResult) {
+    assert('initialResult' in mutationResult);
+    patches.push(mutationResult.initialResult);
+    for await (const patch of mutationResult.subsequentResults) {
       patches.push(patch);
     }
 
@@ -291,15 +294,16 @@ describe('Execute: Handles mutation execution ordering', () => {
     `);
 
     const rootValue = new Root(6);
-    const mutationResult = await execute({
+    const mutationResult = await experimentalExecuteIncrementally({
       schema,
       document,
       rootValue,
     });
     const patches = [];
 
-    assert(isAsyncIterable(mutationResult));
-    for await (const patch of mutationResult) {
+    assert('initialResult' in mutationResult);
+    patches.push(mutationResult.initialResult);
+    for await (const patch of mutationResult.subsequentResults) {
       patches.push(patch);
     }
 

src/execution/__tests__/nonnull-test.ts

@@ -13,7 +13,7 @@ import { GraphQLSchema } from '../../type/schema';
 
 import { buildSchema } from '../../utilities/buildASTSchema';
 
-import type { AsyncExecutionResult, ExecutionResult } from '../execute';
+import type { ExecutionResult } from '../execute';
 import { execute, executeSync } from '../execute';
 
 const syncError = new Error('sync');
@@ -111,9 +111,7 @@ const schema = buildSchema(`
 function executeQuery(
   query: string,
   rootValue: unknown,
-): PromiseOrValue<
-  ExecutionResult | AsyncGenerator<AsyncExecutionResult, void, void>
-> {
+): PromiseOrValue<ExecutionResult> {
   return execute({ schema, document: parse(query), rootValue });
 }