switch from using a TaggedFieldNode to a map of deferDepth to Array<FieldNode>

Author: yaacovCR

src/execution/__tests__/executor-test.ts

@@ -230,22 +230,26 @@ describe('Execute: Handles basic execution tasks', () => {
     const operation = document.definitions[0];
     assert(operation.kind === Kind.OPERATION_DEFINITION);
 
-    expect(resolvedInfo).to.include({
+    expect(resolvedInfo).to.deep.include({
       fieldName: 'test',
       returnType: GraphQLString,
       parentType: testType,
       schema,
       rootValue,
       operation,
-    });
-
-    const fieldNode = operation.selectionSet.selections[0];
-    expect(resolvedInfo).to.deep.include({
-      fieldGroup: { depth: 0, fields: [{ fieldNode, deferDepth: undefined }] },
       deferDepth: undefined,
       variableValues: { var: 'abc' },
     });
 
+    expect(resolvedInfo?.fieldGroup).to.deep.include({
+      depth: 0,
+    });
+
+    const fieldNode = operation.selectionSet.selections[0];
+    expect(resolvedInfo?.fieldGroup.fields.get(undefined)).to.deep.equal([
+      fieldNode,
+    ]);
+
     expect(resolvedInfo?.path).to.deep.include({
       prev: undefined,
       key: 'result',

src/execution/collectFields.ts

@@ -1,3 +1,4 @@
+import { AccumulatorMap } from '../jsutils/AccumulatorMap.js';
 import { invariant } from '../jsutils/invariant.js';
 import type { ObjMap } from '../jsutils/ObjMap.js';
 
@@ -34,30 +35,20 @@ import { getDirectiveValues } from './values.js';
  *
  * The groups's depth is provided so that CollectField algorithm can compute the
  * depth of an inline or named fragment with a defer directive.
+ *
+ * The group is organized in a map of deferDepth to fields. The deferDepth is
+ * used to uniquely identify the set of fields within a deferred payload.
  */
 export interface FieldGroup {
   depth: number;
-  fields: ReadonlyArray<TaggedFieldNode>;
+  fields: Map<number | undefined, ReadonlyArray<FieldNode>>;
 }
 
 export type GroupedFieldSet = Map<string, FieldGroup>;
 
-interface MutableFieldSet {
+interface MutableFieldGroup {
   depth: number;
-  fields: Array<TaggedFieldNode>;
-}
-
-/**
- * A tagged field node includes the depth of any enclosing defer directive, or
- * undefined, if the field is not contained within a deferred fragment.
- *
- * Because deferred fragments at a given level are merged, the defer depth for a
- * field node may be used as a unique id to tag the fields for inclusion within a
- * given deferred payload.
- */
-export interface TaggedFieldNode {
-  fieldNode: FieldNode;
-  deferDepth: number | undefined;
+  fields: AccumulatorMap<number | undefined, FieldNode>;
 }
 
 /**
@@ -79,7 +70,7 @@ export function collectFields(
   groupedFieldSet: GroupedFieldSet;
   newDeferDepth: number | undefined;
 } {
-  const groupedFieldSet = new Map<string, MutableFieldSet>();
+  const groupedFieldSet = new Map<string, MutableFieldGroup>();
   const newDeferDepth = collectFieldsImpl(
     schema,
     fragments,
@@ -120,26 +111,28 @@ export function collectSubfields(
   groupedFieldSet: GroupedFieldSet;
   newDeferDepth: number | undefined;
 } {
-  const groupedFieldSet = new Map<string, MutableFieldSet>();
+  const groupedFieldSet = new Map<string, MutableFieldGroup>();
   let newDeferDepth: number | undefined;
   const visitedFragmentNames = new Set<string>();
 
-  for (const field of fieldGroup.fields) {
-    if (field.fieldNode.selectionSet) {
-      const nestedNewDeferDepth = collectFieldsImpl(
-        schema,
-        fragments,
-        variableValues,
-        operation,
-        returnType,
-        field.fieldNode.selectionSet,
-        groupedFieldSet,
-        visitedFragmentNames,
-        fieldGroup.depth + 1,
-        field.deferDepth,
-      );
-      if (nestedNewDeferDepth !== undefined) {
-        newDeferDepth = nestedNewDeferDepth;
+  for (const [deferDepth, fields] of fieldGroup.fields) {
+    for (const field of fields) {
+      if (field.selectionSet) {
+        const nestedNewDeferDepth = collectFieldsImpl(
+          schema,
+          fragments,
+          variableValues,
+          operation,
+          returnType,
+          field.selectionSet,
+          groupedFieldSet,
+          visitedFragmentNames,
+          fieldGroup.depth + 1,
+          deferDepth,
+        );
+        if (nestedNewDeferDepth !== undefined) {
+          newDeferDepth = nestedNewDeferDepth;
+        }
       }
     }
   }
@@ -158,7 +151,7 @@ function collectFieldsImpl(
   operation: OperationDefinitionNode,
   runtimeType: GraphQLObjectType,
   selectionSet: SelectionSetNode,
-  groupedFieldSet: Map<string, MutableFieldSet>,
+  groupedFieldSet: Map<string, MutableFieldGroup>,
   visitedFragmentNames: Set<string>,
   depth: number,
   deferDepth: number | undefined,
@@ -171,18 +164,15 @@ function collectFieldsImpl(
           continue;
         }
         const key = getFieldEntryKey(selection);
-        const fieldSet = groupedFieldSet.get(key);
-        if (fieldSet) {
-          fieldSet.fields.push({
-            fieldNode: selection,
-            deferDepth,
-          });
-        } else {
-          groupedFieldSet.set(key, {
+        let fieldGroup = groupedFieldSet.get(key);
+        if (!fieldGroup) {
+          fieldGroup = {
             depth,
-            fields: [{ fieldNode: selection, deferDepth }],
-          });
+            fields: new AccumulatorMap<number | undefined, FieldNode>(),
+          };
+          groupedFieldSet.set(key, fieldGroup);
         }
+        fieldGroup.fields.add(deferDepth, selection);
         break;
       }
       case Kind.INLINE_FRAGMENT: {

src/execution/execute.ts

@@ -660,9 +660,8 @@ function shouldExecute(
   fieldGroup: FieldGroup,
   deferDepth?: number | undefined,
 ): boolean {
-  return fieldGroup.fields.some(
-    ({ deferDepth: fieldDeferDepth }) => fieldDeferDepth === deferDepth,
-  );
+  const fieldGroupForDeferDepth = fieldGroup.fields.get(deferDepth);
+  return fieldGroupForDeferDepth !== undefined;
 }
 
 /**
@@ -724,7 +723,7 @@ function executeFields(
 }
 
 function toNodes(fieldGroup: FieldGroup): ReadonlyArray<FieldNode> {
-  return fieldGroup.fields.map(({ fieldNode }) => fieldNode);
+  return [...fieldGroup.fields.values()].flat();
 }
 /**
  * Implements the "Executing fields" section of the spec
@@ -741,7 +740,10 @@ function executeField(
   asyncPayloadRecord?: AsyncPayloadRecord,
 ): PromiseOrValue<unknown> {
   const errors = asyncPayloadRecord?.errors ?? exeContext.errors;
-  const fieldName = fieldGroup.fields[0].fieldNode.name.value;
+  const firstField = (
+    fieldGroup.fields.values().next().value as Array<FieldNode>
+  )[0];
+  const fieldName = firstField.name.value;
   const fieldDef = exeContext.schema.getField(parentType, fieldName);
   if (!fieldDef) {
     return;
@@ -766,7 +768,7 @@ function executeField(
     // TODO: find a way to memoize, in case this field is within a List type.
     const args = getArgumentValues(
       fieldDef,
-      fieldGroup.fields[0].fieldNode,
+      firstField,
       exeContext.variableValues,
     );
 
@@ -1043,9 +1045,12 @@ function getStreamValues(
 
   // validation only allows equivalent streams on multiple fields, so it is
   // safe to only check the first fieldNode for the stream directive
+  const firstField = (
+    fieldGroup.fields.values().next().value as Array<FieldNode>
+  )[0];
   const stream = getDirectiveValues(
     GraphQLStreamDirective,
-    fieldGroup.fields[0].fieldNode,
+    firstField,
     exeContext.variableValues,
   );
 
@@ -1778,7 +1783,10 @@ function executeSubscription(
     FieldGroup,
   ];
   const [responseName, fieldGroup] = firstRootField;
-  const fieldName = fieldGroup.fields[0].fieldNode.name.value;
+  const firstField = (
+    fieldGroup.fields.values().next().value as Array<FieldNode>
+  )[0];
+  const fieldName = firstField.name.value;
   const fieldDef = schema.getField(rootType, fieldName);
 
   if (!fieldDef) {
@@ -1803,11 +1811,7 @@ function executeSubscription(
 
     // Build a JS object of arguments from the field.arguments AST, using the
     // variables scope to fulfill any variable references.
-    const args = getArgumentValues(
-      fieldDef,
-      fieldGroup.fields[0].fieldNode,
-      variableValues,
-    );
+    const args = getArgumentValues(fieldDef, firstField, variableValues);
 
     // The resolve function's optional third argument is a context value that
     // is provided to every resolve function within an execution. It is commonly

src/type/definition.ts

@@ -892,10 +892,7 @@ export interface GraphQLResolveInfo {
   readonly fieldName: string;
   readonly fieldGroup: {
     depth: number;
-    fields: ReadonlyArray<{
-      fieldNode: FieldNode;
-      deferDepth: number | undefined;
-    }>;
+    fields: Map<number | undefined, ReadonlyArray<FieldNode>>;
   };
   readonly deferDepth: number | undefined;
   readonly returnType: GraphQLOutputType;

src/validation/rules/SingleFieldSubscriptionsRule.ts

@@ -52,9 +52,8 @@ export function SingleFieldSubscriptionsRule(
             const fieldGroups = [...groupedFieldSet.values()];
             const extraFieldGroups = fieldGroups.slice(1);
             const extraFields = extraFieldGroups
-              .map(({ fields }) => fields)
-              .flat()
-              .map(({ fieldNode }) => fieldNode);
+              .map(({ fields }) => [...fields.values()].flat())
+              .flat();
             context.reportError(
               new GraphQLError(
                 operationName != null
@@ -65,9 +64,7 @@ export function SingleFieldSubscriptionsRule(
             );
           }
           for (const fieldGroup of groupedFieldSet.values()) {
-            const fieldNodes = fieldGroup.fields.map(
-              ({ fieldNode }) => fieldNode,
-            );
+            const fieldNodes = [...fieldGroup.fields.values()].flat();
             const fieldName = fieldNodes[0].name.value;
             if (fieldName.startsWith('__')) {
               context.reportError(