@depup/graphql-tools__delegate 12.0.13-depup.0 → 12.1.0-depup.0

package/dist/index.cjs

@@ -382,7 +382,7 @@ function resolveExternalObject(type, object, unpathedErrors, subschema, context,
           sourceSubschema,
           targetSubschemas
         ] of potentialMergedTypeInfo.targetSubschemas) {
-          if (targetSubschemas.length && sourceSubschema.name === subschema.name) {
+          if (targetSubschemas.length && sourceSubschema.name != null && sourceSubschema.name === subschema.name) {
             subschema = sourceSubschema;
             mergedTypeInfo = potentialMergedTypeInfo;
           }
@@ -590,7 +590,7 @@ const handleOverrideByDelegation = utils.memoize3(
   }
 );
 
-function finalizeGatewayDocument(targetSchema, fragments, operations, onOverlappingAliases, delegationContext) {
+function finalizeGatewayDocument(targetSchema, originalDocument, fragments, operations, onOverlappingAliases, delegationContext) {
   let usedVariables = [];
   let usedFragments = [];
   const newOperations = [];
@@ -682,47 +682,128 @@ function finalizeGatewayDocument(targetSchema, fragments, operations, onOverlapp
       }
     );
   }
+  const includedFragmentNames = new Set(newFragments.map((f) => f.name.value));
+  const hasDroppedFragments = includedFragmentNames.size < usedFragments.length;
   let newDocument = {
     kind: graphql.Kind.DOCUMENT,
     definitions: [...newOperations, ...newFragments]
   };
   const stitchingInfo = delegationContext.info?.schema?.extensions?.["stitchingInfo"];
-  if (stitchingInfo != null) {
+  if (stitchingInfo != null && subschemaHasProvidedSelections(
+    stitchingInfo,
+    delegationContext.subschema
+  )) {
+    const {
+      selectionSetsByPath: originalFieldSelectionSetsByPath,
+      fragments: originalFragmentsByName
+    } = collectFieldSelectionSetsByPath(originalDocument);
     const typeInfo = getTypeInfo(targetSchema);
+    const pathStack = [];
+    const inlineFragmentCounterStack = [];
     newDocument = graphql.visit(
       newDocument,
       graphql.visitWithTypeInfo(typeInfo, {
-        [graphql.Kind.FIELD](fieldNode) {
-          const parentType = typeInfo.getParentType();
-          if (parentType) {
-            const parentTypeName = parentType.name;
-            const typeConfig = stitchingInfo?.mergedTypes?.[parentTypeName];
-            if (typeConfig) {
+        [graphql.Kind.SELECTION_SET]: {
+          enter() {
+            inlineFragmentCounterStack.push(/* @__PURE__ */ new Map());
+          },
+          leave() {
+            inlineFragmentCounterStack.pop();
+          }
+        },
+        [graphql.Kind.OPERATION_DEFINITION]: {
+          enter(node) {
+            pathStack.push(`op:${node.operation}:${node.name?.value ?? ""}`);
+          },
+          leave() {
+            pathStack.pop();
+          }
+        },
+        [graphql.Kind.FRAGMENT_DEFINITION]: {
+          enter(node) {
+            pathStack.push(`frag:${node.name.value}`);
+          },
+          leave() {
+            pathStack.pop();
+          }
+        },
+        [graphql.Kind.INLINE_FRAGMENT]: {
+          enter(node) {
+            pathStack.push(
+              nextInlineFragmentPathSegment(
+                node,
+                inlineFragmentCounterStack[inlineFragmentCounterStack.length - 1]
+              )
+            );
+          },
+          leave() {
+            pathStack.pop();
+          }
+        },
+        [graphql.Kind.FIELD]: {
+          enter(fieldNode) {
+            pathStack.push(fieldNode.alias?.value ?? fieldNode.name.value);
+          },
+          leave(fieldNode) {
+            try {
+              const parentType = typeInfo.getParentType();
+              if (!parentType) {
+                return void 0;
+              }
+              const typeConfig = stitchingInfo?.mergedTypes?.[parentType.name];
               const providedSelectionsByField = typeConfig?.providedSelectionsByField?.get(
                 delegationContext.subschema
               );
-              if (providedSelectionsByField) {
-                const providedSelection = providedSelectionsByField[fieldNode.name.value];
-                if (providedSelection) {
-                  return {
-                    ...fieldNode,
-                    selectionSet: {
-                      kind: graphql.Kind.SELECTION_SET,
-                      selections: [
-                        ...providedSelection.selections,
-                        ...fieldNode.selectionSet?.selections ?? []
-                      ]
-                    }
-                  };
-                }
+              const providedSelection = providedSelectionsByField?.[fieldNode.name.value];
+              if (!providedSelection) {
+                return void 0;
               }
+              const originalSelectionSet = lookupOriginalSelectionSet(
+                pathStack,
+                fieldNode,
+                originalFieldSelectionSetsByPath
+              );
+              const requestedProvidedSelections = intersectProvidedSelections(
+                providedSelection.selections,
+                originalSelectionSet,
+                originalFragmentsByName
+              );
+              if (!requestedProvidedSelections.length) {
+                return void 0;
+              }
+              return {
+                ...fieldNode,
+                selectionSet: {
+                  kind: graphql.Kind.SELECTION_SET,
+                  selections: [
+                    ...requestedProvidedSelections,
+                    ...fieldNode.selectionSet?.selections ?? []
+                  ]
+                }
+              };
+            } finally {
+              pathStack.pop();
             }
           }
-          return fieldNode;
         }
       })
     );
   }
+  if (hasDroppedFragments) {
+    const ops = newDocument.definitions.filter(
+      (d) => d.kind === graphql.Kind.OPERATION_DEFINITION
+    );
+    const frags = newDocument.definitions.filter(
+      (d) => d.kind === graphql.Kind.FRAGMENT_DEFINITION
+    );
+    newDocument = {
+      kind: graphql.Kind.DOCUMENT,
+      definitions: [
+        ...removeDeadFragmentSpreads(ops, includedFragmentNames),
+        ...frags
+      ]
+    };
+  }
   return {
     usedVariables,
     newDocument
@@ -733,6 +814,7 @@ function finalizeGatewayRequest(originalRequest, delegationContext, onOverlappin
   const { targetSchema } = delegationContext;
   const { usedVariables, newDocument } = finalizeGatewayDocument(
     targetSchema,
+    originalRequest.document,
     fragments,
     operations,
     onOverlappingAliases,
@@ -758,9 +840,293 @@ function finalizeGatewayRequest(originalRequest, delegationContext, onOverlappin
     variables: newVariables
   };
 }
+function removeDeadFragmentSpreads(operations, included) {
+  function cleanSelections(selections) {
+    const out = [];
+    for (const sel of selections) {
+      if (sel.kind === graphql.Kind.FRAGMENT_SPREAD) {
+        if (included.has(sel.name.value)) {
+          out.push(sel);
+        }
+      } else if ((sel.kind === graphql.Kind.FIELD || sel.kind === graphql.Kind.INLINE_FRAGMENT) && sel.selectionSet) {
+        const cleaned = cleanSelections(sel.selectionSet.selections);
+        if (cleaned.length === 0 && sel.kind === graphql.Kind.INLINE_FRAGMENT) {
+          continue;
+        }
+        if (cleaned.length === 0 && sel.kind === graphql.Kind.FIELD) {
+          continue;
+        }
+        out.push(
+          cleaned === sel.selectionSet.selections ? sel : {
+            ...sel,
+            selectionSet: {
+              kind: graphql.Kind.SELECTION_SET,
+              selections: cleaned
+            }
+          }
+        );
+      } else {
+        out.push(sel);
+      }
+    }
+    return out;
+  }
+  return operations.map((op) => ({
+    ...op,
+    selectionSet: {
+      ...op.selectionSet,
+      selections: cleanSelections(op.selectionSet.selections)
+    }
+  }));
+}
 function isTypeNameField(selection) {
   return selection.kind === graphql.Kind.FIELD && !selection.alias && selection.name.value === "__typename";
 }
+function collectFieldSelectionSetsByPathImpl(document) {
+  const selectionSetsByPath = /* @__PURE__ */ new Map();
+  const fragments = /* @__PURE__ */ new Map();
+  for (const def of document.definitions) {
+    if (def.kind === graphql.Kind.FRAGMENT_DEFINITION) {
+      fragments.set(def.name.value, def);
+    }
+  }
+  const pathStack = [];
+  const inlineFragmentCounterStack = [];
+  graphql.visit(document, {
+    [graphql.Kind.SELECTION_SET]: {
+      enter() {
+        inlineFragmentCounterStack.push(/* @__PURE__ */ new Map());
+      },
+      leave() {
+        inlineFragmentCounterStack.pop();
+      }
+    },
+    [graphql.Kind.OPERATION_DEFINITION]: {
+      enter(node) {
+        pathStack.push(`op:${node.operation}:${node.name?.value ?? ""}`);
+      },
+      leave() {
+        pathStack.pop();
+      }
+    },
+    [graphql.Kind.FRAGMENT_DEFINITION]: {
+      enter(node) {
+        pathStack.push(`frag:${node.name.value}`);
+      },
+      leave() {
+        pathStack.pop();
+      }
+    },
+    [graphql.Kind.INLINE_FRAGMENT]: {
+      enter(node) {
+        pathStack.push(
+          nextInlineFragmentPathSegment(
+            node,
+            inlineFragmentCounterStack[inlineFragmentCounterStack.length - 1]
+          )
+        );
+      },
+      leave() {
+        pathStack.pop();
+      }
+    },
+    [graphql.Kind.FIELD]: {
+      enter(node) {
+        pathStack.push(node.alias?.value ?? node.name.value);
+        if (node.selectionSet) {
+          selectionSetsByPath.set(pathStack.join(">"), node.selectionSet);
+          if (node.alias) {
+            const namePath = [...pathStack.slice(0, -1), node.name.value].join(
+              ">"
+            );
+            if (!selectionSetsByPath.has(namePath)) {
+              selectionSetsByPath.set(namePath, node.selectionSet);
+            }
+          }
+        }
+      },
+      leave() {
+        pathStack.pop();
+      }
+    }
+  });
+  return { selectionSetsByPath, fragments };
+}
+const collectFieldSelectionSetsByPath = utils.memoize1(
+  collectFieldSelectionSetsByPathImpl
+);
+function nextInlineFragmentPathSegment(node, counter) {
+  const typeName = node.typeCondition?.name.value ?? "";
+  if (!counter) {
+    return `inline:${typeName}:0`;
+  }
+  const idx = counter.get(typeName) ?? 0;
+  counter.set(typeName, idx + 1);
+  return `inline:${typeName}:${idx}`;
+}
+function subschemaHasProvidedSelectionsImpl(stitchingInfo, subschema) {
+  const mergedTypes = stitchingInfo.mergedTypes;
+  if (!mergedTypes) {
+    return false;
+  }
+  for (const typeConfig of Object.values(mergedTypes)) {
+    if (typeConfig?.providedSelectionsByField?.has(subschema)) {
+      return true;
+    }
+  }
+  return false;
+}
+const subschemaHasProvidedSelections = utils.memoize2(
+  subschemaHasProvidedSelectionsImpl
+);
+function lookupOriginalSelectionSet(pathStack, fieldNode, selectionSetsByPath) {
+  const exact = selectionSetsByPath.get(pathStack.join(">"));
+  if (exact || !fieldNode.alias) {
+    return exact;
+  }
+  const fallback = [...pathStack.slice(0, -1), fieldNode.name.value].join(">");
+  return selectionSetsByPath.get(fallback);
+}
+function intersectProvidedSelections(providedSelections, originalSelectionSet, fragments) {
+  if (!originalSelectionSet) {
+    return [];
+  }
+  const providedFieldsByName = /* @__PURE__ */ new Map();
+  const otherProvided = [];
+  for (const provided of providedSelections) {
+    if (provided.kind === graphql.Kind.FIELD) {
+      providedFieldsByName.set(provided.name.value, provided);
+    } else {
+      otherProvided.push(provided);
+    }
+  }
+  const result = [];
+  collectMatchingOriginalSelections(
+    originalSelectionSet,
+    providedFieldsByName,
+    fragments,
+    /* @__PURE__ */ new Set(),
+    /* @__PURE__ */ new Set(),
+    result
+  );
+  return [...result, ...otherProvided];
+}
+function collectMatchingOriginalSelections(selectionSet, providedFieldsByName, fragments, seenFieldNames, seenFragmentNames, result) {
+  for (const sel of selectionSet.selections) {
+    if (sel.kind === graphql.Kind.FIELD) {
+      const provided = providedFieldsByName.get(sel.name.value);
+      if (!provided) {
+        continue;
+      }
+      const dedupKey = sel.alias?.value ?? sel.name.value;
+      if (seenFieldNames.has(dedupKey)) {
+        continue;
+      }
+      seenFieldNames.add(dedupKey);
+      if (provided.selectionSet && sel.selectionSet) {
+        const nested = intersectProvidedSelections(
+          provided.selectionSet.selections,
+          sel.selectionSet,
+          fragments
+        );
+        if (!nested.length) {
+          continue;
+        }
+        result.push({
+          ...sel,
+          selectionSet: {
+            kind: graphql.Kind.SELECTION_SET,
+            selections: nested
+          }
+        });
+      } else {
+        result.push(sel);
+      }
+    } else if (sel.kind === graphql.Kind.INLINE_FRAGMENT && sel.selectionSet) {
+      const hasDirectives = (sel.directives?.length ?? 0) > 0;
+      const hasTypeCondition = sel.typeCondition != null;
+      if (hasDirectives || hasTypeCondition) {
+        const inner = [];
+        collectMatchingOriginalSelections(
+          sel.selectionSet,
+          providedFieldsByName,
+          fragments,
+          /* @__PURE__ */ new Set(),
+          /* @__PURE__ */ new Set(),
+          inner
+        );
+        if (inner.length === 0) {
+          continue;
+        }
+        result.push({
+          kind: graphql.Kind.INLINE_FRAGMENT,
+          typeCondition: sel.typeCondition,
+          directives: sel.directives,
+          selectionSet: {
+            kind: graphql.Kind.SELECTION_SET,
+            selections: inner
+          }
+        });
+      } else {
+        collectMatchingOriginalSelections(
+          sel.selectionSet,
+          providedFieldsByName,
+          fragments,
+          seenFieldNames,
+          seenFragmentNames,
+          result
+        );
+      }
+    } else if (sel.kind === graphql.Kind.FRAGMENT_SPREAD) {
+      const fragmentDef = fragments.get(sel.name.value);
+      if (!fragmentDef) {
+        continue;
+      }
+      const hasSpreadDirectives = (sel.directives?.length ?? 0) > 0;
+      const hasFragmentDirectives = (fragmentDef.directives?.length ?? 0) > 0;
+      if (hasSpreadDirectives || hasFragmentDirectives) {
+        const inner = [];
+        collectMatchingOriginalSelections(
+          fragmentDef.selectionSet,
+          providedFieldsByName,
+          fragments,
+          /* @__PURE__ */ new Set(),
+          /* @__PURE__ */ new Set(),
+          inner
+        );
+        if (inner.length === 0) {
+          continue;
+        }
+        const combinedDirectives = [
+          ...sel.directives ?? [],
+          ...fragmentDef.directives ?? []
+        ];
+        result.push({
+          kind: graphql.Kind.INLINE_FRAGMENT,
+          typeCondition: fragmentDef.typeCondition,
+          directives: combinedDirectives.length > 0 ? combinedDirectives : void 0,
+          selectionSet: {
+            kind: graphql.Kind.SELECTION_SET,
+            selections: inner
+          }
+        });
+      } else {
+        if (seenFragmentNames.has(sel.name.value)) {
+          continue;
+        }
+        seenFragmentNames.add(sel.name.value);
+        collectMatchingOriginalSelections(
+          fragmentDef.selectionSet,
+          providedFieldsByName,
+          fragments,
+          seenFieldNames,
+          seenFragmentNames,
+          result
+        );
+      }
+    }
+  }
+}
 function filterTypenameFields(selections) {
   let hasTypeNameField = false;
   const filteredSelections = selections.filter((selection) => {
@@ -809,15 +1175,17 @@ function collectFragmentVariables(targetSchema, fragmentSet, validFragments, val
       usedVariables = union(usedVariables, fragmentUsedVariables);
       if (name && !(name in fragmentSet)) {
         fragmentSet[name] = true;
-        newFragments.push({
-          kind: graphql.Kind.FRAGMENT_DEFINITION,
-          name: {
-            kind: graphql.Kind.NAME,
-            value: name
-          },
-          typeCondition: fragment.typeCondition,
-          selectionSet
-        });
+        if (selectionSet.selections.length > 0) {
+          newFragments.push({
+            kind: graphql.Kind.FRAGMENT_DEFINITION,
+            name: {
+              kind: graphql.Kind.NAME,
+              value: name
+            },
+            typeCondition: fragment.typeCondition,
+            selectionSet
+          });
+        }
       }
     }
   }
@@ -1986,10 +2354,18 @@ function createRequest({
       const existingArgNode = fieldNode?.arguments?.find(
         (argNode) => argNode.name.value === argName
       );
-      if (existingArgNode?.value.kind === graphql.Kind.VARIABLE) {
+      if (existingArgNode?.value.kind === graphql.Kind.VARIABLE && argInstance) {
         const varName = existingArgNode.value.name.value;
         const varValue = newVariables[varName];
-        if (varValue === argValue) {
+        const variableDefinition = variableDefinitions.find(
+          (definition) => definition.variable.name.value === varName
+        );
+        const variableType = variableDefinition && targetSchema ? graphql.typeFromAST(info?.schema ?? targetSchema, variableDefinition.type) : void 0;
+        if (varValue === argValue && variableType && graphql.isTypeSubTypeOf(
+          info?.schema ?? targetSchema,
+          variableType,
+          argInstance.type
+        )) {
           argNodes.push(existingArgNode);
           continue;
         }
@@ -2010,6 +2386,16 @@ function createRequest({
             varName = `_${i++}_${rootFieldName}_${argName}`;
           }
         }
+        if (existingArgNode?.value.kind === graphql.Kind.VARIABLE) {
+          const existingVarName = existingArgNode.value.name.value;
+          const existingVarIndex = variableDefinitions.findIndex(
+            (definition) => definition.variable.name.value === existingVarName
+          );
+          if (existingVarIndex !== -1) {
+            variableDefinitions.splice(existingVarIndex, 1);
+            delete newVariables[existingVarName];
+          }
+        }
         variableDefinitions.push({
           kind: graphql.Kind.VARIABLE_DEFINITION,
           variable: {
@@ -2181,6 +2567,9 @@ function defaultMergedResolver(parent, args, context, info) {
       }
       return deferred.promise;
     }
+    if (Object.prototype.hasOwnProperty.call(parent, info.fieldName)) {
+      return graphql.defaultFieldResolver(parent, args, context, info);
+    }
     return void 0;
   }
   return handleResult(parent, responseKey, context, info);
@@ -2609,7 +2998,7 @@ function delegateToSchema(options) {
   const request = createRequest({
     subgraphName: schema.name,
     fragments,
-    targetSchema,
+    targetSchema: targetSchema.getQueryType()?.getFields()[fieldName] == null && isSubschemaConfig(schema) ? schema.schema : targetSchema,
     rootValue,
     targetOperationName: operationName,
     targetOperation: operation,
@@ -2647,9 +3036,9 @@ function delegateRequest(options) {
     () => getExecutor(delegationContext)(processedRequest),
     function handleExecutorResult(executorResult) {
       if (utils.isAsyncIterable(executorResult)) {
-        if (delegationContext.operation === "query" && graphql.isListType(delegationContext.returnType)) {
+        if (delegationContext.operation === "query" && graphql.isListType(graphql.getNullableType(delegationContext.returnType))) {
           return new repeater.Repeater(async (push, stop) => {
-            const pushed = /* @__PURE__ */ new WeakSet();
+            let pushedCount = 0;
             let stopped = false;
             stop.finally(() => {
               stopped = true;
@@ -2681,15 +3070,12 @@ function delegateRequest(options) {
                 }
                 const transformedResult = await transformer.transformResult(result);
                 if (Array.isArray(transformedResult)) {
-                  for (const individualResult$ of transformedResult) {
+                  for (let i = pushedCount; i < transformedResult.length; i++) {
                     if (stopped) {
                       break;
                     }
-                    const individualResult = await individualResult$;
-                    if (!pushed.has(individualResult)) {
-                      pushed.add(individualResult);
-                      await push(individualResult);
-                    }
+                    await push(await transformedResult[i]);
+                    pushedCount = i + 1;
                   }
                 } else {
                   await push(await transformedResult);
@@ -2765,7 +3151,9 @@ function getDelegationContext({
     ),
     transforms,
     transformedSchema: transformedSchema ?? subschemaOrSubschemaConfig,
-    skipTypeMerging
+    skipTypeMerging,
+    onLocatedError,
+    args
   };
 }
 function validateRequest(delegationContext, document) {
@@ -2896,6 +3284,7 @@ function extractUnavailableFieldsFromSelectionSet(schema, fieldType, fieldSelect
           });
         }
       } else if (graphql.isObjectType(subFieldType) || graphql.isInterfaceType(subFieldType)) {
+        const unavailableSubSelections = [];
         const subFieldTypeFields = subFieldType.getFields();
         for (const subSelection of selection.selectionSet.selections) {
           if (subSelection.kind === graphql.Kind.FIELD) {
@@ -2906,11 +3295,20 @@ function extractUnavailableFieldsFromSelectionSet(schema, fieldType, fieldSelect
             const subSelectionField = subFieldTypeFields[subSelection.name.value];
             if (!subSelectionField) {
               if (shouldAdd(subFieldType, subSelection)) {
-                unavailableSelections.push(subSelection);
+                unavailableSubSelections.push(subSelection);
               }
             }
           }
         }
+        if (unavailableSubSelections.length) {
+          unavailableSelections.push({
+            ...selection,
+            selectionSet: {
+              kind: graphql.Kind.SELECTION_SET,
+              selections: unavailableSubSelections
+            }
+          });
+        }
       }
     } else if (selection.kind === graphql.Kind.FRAGMENT_SPREAD) {
       const fragment = fragments[selection.name.value];
@@ -2958,7 +3356,7 @@ function extractUnavailableFields(schema, field, fieldNode, shouldAdd, fragments
   }
   return [];
 }
-function subtractSelectionSets(selectionSetA, selectionSetB) {
+function subtractSelectionSets(selectionSetA, selectionSetB, fragments = {}) {
   const newSelections = [];
   for (const selectionA of selectionSetA.selections) {
     switch (selectionA.kind) {
@@ -2974,7 +3372,7 @@ function subtractSelectionSets(selectionSetA, selectionSetB) {
         );
         if (fieldsInOtherSelectionSet.length > 0 && fieldA.selectionSet?.selections?.length) {
           const newSubSelection = fieldsInOtherSelectionSet.reduce(
-            (acc, fieldB) => fieldB.selectionSet ? subtractSelectionSets(acc, fieldB.selectionSet) : acc,
+            (acc, fieldB) => fieldB.selectionSet ? subtractSelectionSets(acc, fieldB.selectionSet, fragments) : acc,
             {
               kind: graphql.Kind.SELECTION_SET,
               selections: fieldA.selectionSet.selections
@@ -3004,7 +3402,11 @@ function subtractSelectionSets(selectionSetA, selectionSetB) {
         );
         if (inlineFragmentsFromB.length > 0) {
           const newSubSelection = inlineFragmentsFromB.reduce(
-            (acc, subselectionB) => subselectionB.selectionSet ? subtractSelectionSets(acc, subselectionB.selectionSet) : acc,
+            (acc, subselectionB) => subselectionB.selectionSet ? subtractSelectionSets(
+              acc,
+              subselectionB.selectionSet,
+              fragments
+            ) : acc,
             {
               kind: graphql.Kind.SELECTION_SET,
               selections: inlineFragmentA.selectionSet.selections
@@ -3032,7 +3434,25 @@ function subtractSelectionSets(selectionSetA, selectionSetB) {
       }
       case graphql.Kind.FRAGMENT_SPREAD: {
         const fragmentSpreadA = selectionA;
-        if (!selectionSetB.selections.some(
+        const fragment = fragments[fragmentSpreadA.name.value];
+        if (fragment) {
+          const newSubSelection = subtractSelectionSets(
+            fragment.selectionSet,
+            selectionSetB,
+            fragments
+          );
+          if (newSubSelection.selections.length) {
+            newSelections.push({
+              kind: graphql.Kind.INLINE_FRAGMENT,
+              typeCondition: fragment.typeCondition,
+              directives: [
+                ...fragment.directives ?? [],
+                ...fragmentSpreadA.directives ?? []
+              ],
+              selectionSet: newSubSelection
+            });
+          }
+        } else if (!selectionSetB.selections.some(
           (subselectionB) => subselectionB.kind === graphql.Kind.FRAGMENT_SPREAD && subselectionB.name.value === fragmentSpreadA.name.value
         )) {
           newSelections.push(selectionA);