add helpers

Author: yaacovCR

src/execution/IncrementalPublisher.ts

@@ -307,6 +307,12 @@ export class IncrementalPublisher {
         path,
         deferredFragmentRecords,
         groupedFieldSet,
+        priority:
+          incrementalDataRecord === undefined
+            ? 1
+            : shouldInitiateDefer
+            ? incrementalDataRecord.priority + 1
+            : incrementalDataRecord.priority,
         shouldInitiateDefer,
       });
       for (const deferredFragmentRecord of deferredFragmentRecords) {
@@ -345,6 +351,10 @@ export class IncrementalPublisher {
     const streamItemsRecord = new StreamItemsRecord({
       streamRecord,
       path,
+      priority:
+        incrementalDataRecord === undefined
+          ? 1
+          : incrementalDataRecord.priority + 1,
       parents,
     });
 
@@ -672,13 +682,17 @@ export class IncrementalPublisher {
 
     if (isStreamItemsRecord(subsequentResultRecord)) {
       this._introduce(subsequentResultRecord);
+      subsequentResultRecord.publish();
       return;
     }
 
     if (subsequentResultRecord._pending.size === 0) {
       subsequentResultRecord.isCompleted = true;
       this._push(subsequentResultRecord);
     } else {
+      for (const deferredGroupedFieldSetRecord of subsequentResultRecord.deferredGroupedFieldSetRecords) {
+        deferredGroupedFieldSetRecord.publish();
+      }
       this._introduce(subsequentResultRecord);
     }
   }
@@ -748,24 +762,38 @@ export class IncrementalPublisher {
 /** @internal */
 export class DeferredGroupedFieldSetRecord {
   path: ReadonlyArray<string | number>;
+  priority: number;
   deferredFragmentRecords: ReadonlyArray<DeferredFragmentRecord>;
   groupedFieldSet: GroupedFieldSet;
   shouldInitiateDefer: boolean;
   errors: Array<GraphQLError>;
   data: ObjMap<unknown> | undefined;
+  published: true | Promise<void>;
+  publish: () => void;
   sent: boolean;
 
   constructor(opts: {
     path: Path | undefined;
+    priority: number;
     deferredFragmentRecords: ReadonlyArray<DeferredFragmentRecord>;
     groupedFieldSet: GroupedFieldSet;
     shouldInitiateDefer: boolean;
   }) {
     this.path = pathToArray(opts.path);
+    this.priority = opts.priority;
     this.deferredFragmentRecords = opts.deferredFragmentRecords;
     this.groupedFieldSet = opts.groupedFieldSet;
     this.shouldInitiateDefer = opts.shouldInitiateDefer;
     this.errors = [];
+    // promiseWithResolvers uses void only as a generic type parameter
+    // see: https://typescript-eslint.io/rules/no-invalid-void-type/
+    // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
+    const { promise: published, resolve } = promiseWithResolvers<void>();
+    this.published = published;
+    this.publish = () => {
+      resolve();
+      this.published = true;
+    };
     this.sent = false;
   }
 }
@@ -822,26 +850,40 @@ export class StreamItemsRecord {
   errors: Array<GraphQLError>;
   streamRecord: StreamRecord;
   path: ReadonlyArray<string | number>;
+  priority: number;
   items: Array<unknown>;
   parents: ReadonlyArray<SubsequentResultRecord> | undefined;
   children: Set<SubsequentResultRecord>;
   isFinalRecord?: boolean;
   isCompletedAsyncIterator?: boolean;
   isCompleted: boolean;
+  published: true | Promise<void>;
+  publish: () => void;
   sent: boolean;
 
   constructor(opts: {
     streamRecord: StreamRecord;
     path: Path | undefined;
+    priority: number;
     parents: ReadonlyArray<SubsequentResultRecord> | undefined;
   }) {
     this.streamRecord = opts.streamRecord;
     this.path = pathToArray(opts.path);
+    this.priority = opts.priority;
     this.parents = opts.parents;
     this.children = new Set();
     this.errors = [];
     this.isCompleted = false;
     this.items = [];
+    // promiseWithResolvers uses void only as a generic type parameter
+    // see: https://typescript-eslint.io/rules/no-invalid-void-type/
+    // eslint-disable-next-line @typescript-eslint/no-invalid-void-type
+    const { promise: published, resolve } = promiseWithResolvers<void>();
+    this.published = published;
+    this.publish = () => {
+      resolve();
+      this.published = true;
+    };
     this.sent = false;
   }
 }

src/execution/__tests__/defer-test.ts

@@ -5,6 +5,8 @@ import { expectJSON } from '../../__testUtils__/expectJSON.js';
 import { expectPromise } from '../../__testUtils__/expectPromise.js';
 import { resolveOnNextTick } from '../../__testUtils__/resolveOnNextTick.js';
 
+import { isPromise } from '../../jsutils/isPromise.js';
+
 import type { DocumentNode } from '../../language/ast.js';
 import { parse } from '../../language/parser.js';
 
@@ -141,9 +143,13 @@ const query = new GraphQLObjectType({
   name: 'Query',
 });
 
-const schema = new GraphQLSchema({ query });
+const heroSchema = new GraphQLSchema({ query });
 
-async function complete(document: DocumentNode, rootValue: unknown = { hero }) {
+async function complete(
+  document: DocumentNode,
+  rootValue: unknown = { hero },
+  schema = heroSchema,
+) {
   const result = await experimentalExecuteIncrementally({
     schema,
     document,
@@ -224,6 +230,84 @@ describe('Execute: defer directive', () => {
       },
     });
   });
+  it('Can provides correct info about deferred execution state when resolver could defer', async () => {
+    let priority;
+    let published;
+
+    const SomeType = new GraphQLObjectType({
+      name: 'SomeType',
+      fields: {
+        someField: {
+          type: GraphQLString,
+          resolve: () => Promise.resolve('someField'),
+        },
+        deferredField: {
+          type: GraphQLString,
+          resolve: (_parent, _args, _context, info) => {
+            priority = info.priority;
+            published = info.published;
+          },
+        },
+      },
+    });
+
+    const someSchema = new GraphQLSchema({ query: SomeType });
+
+    const document = parse(`
+      query {
+        someField
+        ... @defer {
+          deferredField
+        }
+      }
+    `);
+
+    const result = complete(document, undefined, someSchema);
+
+    expect(priority).to.equal(undefined);
+    expect(published).to.equal(undefined);
+
+    await result;
+
+    expect(priority).to.equal(1);
+    expect(isPromise(published)).to.equal(true);
+  });
+  it('Can provides correct info about deferred execution state when resolver no longer need defer', async () => {
+    let priority;
+    let published;
+    const SomeType = new GraphQLObjectType({
+      name: 'SomeType',
+      fields: {
+        deferredField: {
+          type: GraphQLString,
+          resolve: (_parent, _args, _context, info) => {
+            priority = info.priority;
+            published = info.published;
+          },
+        },
+      },
+    });
+
+    const someSchema = new GraphQLSchema({ query: SomeType });
+
+    const document = parse(`
+      query {
+        ... @defer {
+          deferredField
+        }
+      }
+    `);
+
+    const result = complete(document, undefined, someSchema);
+
+    expect(priority).to.equal(undefined);
+    expect(published).to.equal(undefined);
+
+    await result;
+
+    expect(priority).to.equal(1);
+    expect(published).to.equal(true);
+  });
   it('Does not disable defer with null if argument', async () => {
     const document = parse(`
       query HeroNameQuery($shouldDefer: Boolean) {
@@ -2035,7 +2119,7 @@ describe('Execute: defer directive', () => {
   `;
     expect(() =>
       execute({
-        schema,
+        schema: heroSchema,
         document: parse(doc),
         rootValue: {},
       }),
@@ -2053,7 +2137,7 @@ describe('Execute: defer directive', () => {
   `;
     await expectPromise(
       execute({
-        schema,
+        schema: heroSchema,
         document: parse(doc),
         rootValue: {
           hero: {

src/execution/__tests__/executor-test.ts

@@ -222,6 +222,8 @@ describe('Execute: Handles basic execution tasks', () => {
       'rootValue',
       'operation',
       'variableValues',
+      'priority',
+      'published',
     );
 
     const operation = document.definitions[0];
@@ -234,6 +236,8 @@ describe('Execute: Handles basic execution tasks', () => {
       schema,
       rootValue,
       operation,
+      priority: 0,
+      published: true,
     });
 
     const field = operation.selectionSet.selections[0];

src/execution/execute.ts

@@ -725,6 +725,7 @@ function executeField(
     fieldGroup,
     parentType,
     path,
+    incrementalDataRecord,
   );
 
   // Get the resolve function, regardless of if its result is normal or abrupt (error).
@@ -810,6 +811,7 @@ export function buildResolveInfo(
   fieldGroup: FieldGroup,
   parentType: GraphQLObjectType,
   path: Path,
+  incrementalDataRecord?: IncrementalDataRecord | undefined,
 ): GraphQLResolveInfo {
   // The resolve function's optional fourth argument is a collection of
   // information about the current execution state.
@@ -824,6 +826,13 @@ export function buildResolveInfo(
     rootValue: exeContext.rootValue,
     operation: exeContext.operation,
     variableValues: exeContext.variableValues,
+    priority:
+      incrementalDataRecord === undefined ? 0 : incrementalDataRecord.priority,
+    published:
+      incrementalDataRecord === undefined ||
+      incrementalDataRecord.published === true
+        ? true
+        : incrementalDataRecord.published,
   };
 }
 

src/type/definition.ts

@@ -896,6 +896,8 @@ export interface GraphQLResolveInfo {
   readonly rootValue: unknown;
   readonly operation: OperationDefinitionNode;
   readonly variableValues: { [variable: string]: unknown };
+  readonly priority: number;
+  readonly published: true | Promise<void>;
 }
 
 /**