f

Author: yaacovCR

src/execution/collectFields.ts

@@ -37,12 +37,13 @@ export const NON_DEFERRED_SET = new OrderedSet<DeferUsage | undefined>([
   undefined,
 ]).freeze();
 
-export type DeferUsageSet = ReadonlyOrderedSet<DeferUsage | undefined>;
+export type Target = DeferUsage | undefined;
+export type TargetSet = ReadonlyOrderedSet<Target>;
 
 export interface FieldGroup {
   fieldName: string;
   fields: Map<DeferUsage | undefined, ReadonlyArray<FieldNode>>;
-  deferUsages: DeferUsageSet;
+  targets: TargetSet;
 }
 interface MutableFieldGroup {
   fieldName: string;
@@ -56,7 +57,7 @@ type MutableGroupedFieldSet = Map<string, MutableFieldGroup>;
 export interface CollectFieldsResult {
   groupedFieldSet: GroupedFieldSet;
   newGroupedFieldSets: Map<
-    DeferUsageSet,
+    TargetSet,
     { groupedFieldSet: GroupedFieldSet; shouldInitiateDefer: boolean }
   >;
   newDeferUsages: ReadonlyArray<DeferUsage>;
@@ -142,7 +143,7 @@ export function collectSubfields(
   }
 
   return {
-    ...buildGroupedFieldSets(subGroupedFieldSet, fieldGroup.deferUsages),
+    ...buildGroupedFieldSets(subGroupedFieldSet, fieldGroup.targets),
     newDeferUsages: Array.from(deferUsages.values()),
   };
 }
@@ -153,54 +154,54 @@ function buildGroupedFieldSets(
 ): {
   groupedFieldSet: GroupedFieldSet;
   newGroupedFieldSets: Map<
-    DeferUsageSet,
+    TargetSet,
     { groupedFieldSet: GroupedFieldSet; shouldInitiateDefer: boolean }
   >;
 } {
   const groupedFieldSet: GroupedFieldSet = new Map();
   const newGroupedFieldSets = new Map<
-    DeferUsageSet,
+    TargetSet,
     { groupedFieldSet: GroupedFieldSet; shouldInitiateDefer: boolean }
   >();
 
   for (const [key, fieldGroup] of originalGroupedFieldSet) {
     const nonMaskedDeferUsageList: Array<DeferUsage | undefined> = [];
-    const originalDeferUsageSet = new Set(fieldGroup.fields.keys());
+    const originalTargetSet = new Set(fieldGroup.fields.keys());
     for (const [deferUsage] of fieldGroup.fields) {
       if (
         deferUsage === undefined ||
         deferUsage.ancestors.every(
-          (ancestor) => !originalDeferUsageSet.has(ancestor),
+          (ancestor) => !originalTargetSet.has(ancestor),
         )
       ) {
         nonMaskedDeferUsageList.push(deferUsage);
       }
     }
 
-    const newDeferUsageSet = new OrderedSet(nonMaskedDeferUsageList).freeze();
-    if (newDeferUsageSet === parentDeferUsages) {
+    const newTargetSet = new OrderedSet(nonMaskedDeferUsageList).freeze();
+    if (newTargetSet === parentDeferUsages) {
       groupedFieldSet.set(key, {
         ...fieldGroup,
-        deferUsages: newDeferUsageSet,
+        targets: newTargetSet,
       });
       continue;
     }
 
     let newGroupedFieldSet =
-      newGroupedFieldSets.get(newDeferUsageSet)?.groupedFieldSet;
+      newGroupedFieldSets.get(newTargetSet)?.groupedFieldSet;
     if (newGroupedFieldSet === undefined) {
       const shouldInitiateDefer = nonMaskedDeferUsageList.some(
         (deferUsage) => !parentDeferUsages.has(deferUsage),
       );
       newGroupedFieldSet = new Map();
-      newGroupedFieldSets.set(newDeferUsageSet, {
+      newGroupedFieldSets.set(newTargetSet, {
         groupedFieldSet: newGroupedFieldSet,
         shouldInitiateDefer,
       });
     }
     newGroupedFieldSet.set(key, {
       ...fieldGroup,
-      deferUsages: newDeferUsageSet,
+      targets: newTargetSet,
     });
   }
 

src/execution/execute.ts

@@ -51,9 +51,10 @@ import { assertValidSchema } from '../type/validate.js';
 
 import type {
   DeferUsage,
-  DeferUsageSet,
   FieldGroup,
   GroupedFieldSet,
+  Target,
+  TargetSet,
 } from './collectFields.js';
 import {
   collectFields,
@@ -1101,7 +1102,7 @@ function getStreamUsage(
     '`@stream` directive not supported on subscription operations. Disable `@stream` by setting the `if` argument to `false`.',
   );
 
-  const streamFields = new AccumulatorMap<DeferUsage | undefined, FieldNode>();
+  const streamFields = new AccumulatorMap<Target, FieldNode>();
   for (const [, fieldNodes] of fieldGroup.fields) {
     for (const node of fieldNodes) {
       streamFields.add(undefined, node);
@@ -1110,7 +1111,7 @@ function getStreamUsage(
   const streamedFieldGroup: FieldGroup = {
     ...fieldGroup,
     fields: streamFields,
-    deferUsages: NON_DEFERRED_SET,
+    targets: NON_DEFERRED_SET,
   };
 
   const streamUsage = {
@@ -1926,7 +1927,7 @@ function assertEventStream(result: unknown): AsyncIterable<unknown> {
 function prepareNewDeferRecords(
   exeContext: ExecutionContext,
   newGroupedFieldSets: Map<
-    DeferUsageSet,
+    TargetSet,
     { groupedFieldSet: GroupedFieldSet; shouldInitiateDefer: boolean }
   >,
   newDeferUsages: ReadonlyArray<DeferUsage>,
@@ -1989,12 +1990,12 @@ function prepareNewDeferRecords(
 }
 
 function getDeferredFragmentRecords(
-  deferUsages: DeferUsageSet,
+  targets: TargetSet,
   deferMap: Map<DeferUsage, DeferredFragmentRecord>,
 ): Array<DeferredFragmentRecord> {
-  return Array.from(deferUsages).map(
+  return Array.from(targets).map(
     // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-    (deferUsage) => deferMap.get(deferUsage!)!,
+    (target) => deferMap.get(target!)!,
   );
 }