@apollo/federation-internals 2.4.8 → 2.4.9

package/src/operations.ts

@@ -85,7 +85,11 @@ abstract class AbstractOperationElement<T extends AbstractOperationElement<T>> e
 
   abstract asPathElement(): string | undefined;
 
-  abstract rebaseOn(parentType: CompositeType): T;
+  abstract rebaseOn(args: { parentType: CompositeType, errorIfCannotRebase: boolean }): T | undefined;
+
+  rebaseOnOrError(parentType: CompositeType): T {
+    return this.rebaseOn({ parentType, errorIfCannotRebase: true })!;
+  }
 
   abstract withUpdatedDirectives(newDirectives: readonly Directive<any>[]): T;
 
@@ -290,7 +294,7 @@ export class Field<TArgs extends {[key: string]: any} = {[key: string]: any}> ex
     }
   }
 
-  rebaseOn(parentType: CompositeType): Field<TArgs> {
+  rebaseOn({ parentType, errorIfCannotRebase }: { parentType: CompositeType, errorIfCannotRebase: boolean }): Field<TArgs> | undefined {
     const fieldParent = this.definition.parent;
     if (parentType === fieldParent) {
       return this;
@@ -300,12 +304,16 @@ export class Field<TArgs extends {[key: string]: any} = {[key: string]: any}> ex
       return this.withUpdatedDefinition(parentType.typenameField()!);
     }
 
-    validate(
-      this.canRebaseOn(parentType),
-      () => `Cannot add selection of field "${this.definition.coordinate}" to selection set of parent type "${parentType}"`
-    );
     const fieldDef = parentType.field(this.name);
-    validate(fieldDef, () => `Cannot add selection of field "${this.definition.coordinate}" to selection set of parent type "${parentType}" (that does not declare that field)`);
+    const canRebase = this.canRebaseOn(parentType) && fieldDef;
+    if (!canRebase) {
+      validate(
+        !errorIfCannotRebase,
+        () => `Cannot add selection of field "${this.definition.coordinate}" to selection set of parent type "${parentType}"`
+      );
+      return undefined;
+    }
+
     return this.withUpdatedDefinition(fieldDef);
   }
 
@@ -466,7 +474,7 @@ export class FragmentElement extends AbstractOperationElement<FragmentElement> {
     return newFragment;
   }
 
-  rebaseOn(parentType: CompositeType): FragmentElement {
+  rebaseOn({ parentType, errorIfCannotRebase }: { parentType: CompositeType, errorIfCannotRebase: boolean }): FragmentElement | undefined {
     const fragmentParent = this.parentType;
     const typeCondition = this.typeCondition;
     if (parentType === fragmentParent) {
@@ -477,10 +485,13 @@ export class FragmentElement extends AbstractOperationElement<FragmentElement> {
     // to update the source type of the fragment, but also "rebase" the condition to the selection set
     // schema.
     const { canRebase, rebasedCondition } = this.canRebaseOn(parentType);
-    validate(
-      canRebase, 
-      () => `Cannot add fragment of condition "${typeCondition}" (runtimes: [${possibleRuntimeTypes(typeCondition!)}]) to parent type "${parentType}" (runtimes: ${possibleRuntimeTypes(parentType)})`
-    );
+    if (!canRebase) {
+      validate(
+        !errorIfCannotRebase,
+        () => `Cannot add fragment of condition "${typeCondition}" (runtimes: [${possibleRuntimeTypes(typeCondition!)}]) to parent type "${parentType}" (runtimes: ${possibleRuntimeTypes(parentType)})`
+      );
+      return undefined;
+    }
     return this.withUpdatedTypes(parentType, rebasedCondition);
   }
 
@@ -934,9 +945,17 @@ export class Operation {
       // leaving this is not a huge deal and it's not worth the complexity, but it could be that we can
       // refactor all this later to avoid this case without additional complexity.
       if (finalFragments) {
-        const usages = new Map<string, number>();
-        optimizedSelection.collectUsedFragmentNames(usages);
-        finalFragments = finalFragments.filter((f) => (usages.get(f.name) ?? 0) > 0);
+        // Note that removing a fragment might lead to another fragment being unused, so we need to iterate
+        // until there is nothing more to remove, or we're out of fragments.
+        let beforeRemoval: NamedFragments;
+        do {
+          beforeRemoval = finalFragments;
+          const usages = new Map<string, number>();
+          // Collecting all usages, both in the selection and within other fragments.
+          optimizedSelection.collectUsedFragmentNames(usages);
+          finalFragments.collectUsedFragmentNames(usages);
+          finalFragments = finalFragments.filter((f) => (usages.get(f.name) ?? 0) > 0);
+        } while (finalFragments && finalFragments.size < beforeRemoval.size);
       }
     }
 
@@ -1098,27 +1117,26 @@ export class NamedFragmentDefinition extends DirectiveTargetElement<NamedFragmen
 
   /**
    * Whether this fragment may apply _directly_ at the provided type, meaning that the fragment sub-selection
-   * could be put directly inside a `... on type {}` inline fragment (_without_ re-adding the fragment condition
-   * that is), and both be valid and not "lose context".
+   * (_without_ the fragment condition, hence the "directly") can be normalized at `type` and this without
+   * "widening" the runtime types to types that do not intersect the fragment condition.
    *
    * For that to be true, we need one of this to be true:
    * 1. the runtime types of the fragment condition must be at least as general as those of the provided `type`.
-   *    Otherwise, putting it at `type` without its condition would "generalize" more than fragment meant to (and
-   *    so we'd "lose context"
+   *    Otherwise, putting it at `type` without its condition would "generalize" more than the fragment meant to (and
+   *    so we'd "widen" the runtime types more than what the query meant to.
    * 2. either `type` and `this.typeCondition` are equal, or `type` is an object or `this.typeCondition` is a union
    *    The idea is that, assuming our 1st point, then:
    *    - if both are equal, things works trivially.
    *    - if `type` is an object, `this.typeCondition` is either the same object, or a union/interface for which
    *      type is a valid runtime. In all case, anything valid on `this.typeCondition` would apply to `type` too.
-   *    - if `this.typeCondition` is a union, then it's selection can only have fragments on object types at top-level
-   *      (save for `__typename`), and all those selection will work at `type` too.
+   *    - if `this.typeCondition` is a union, then it's selection can only have fragments at top-level
+   *      (no fields save for `__typename`), and normalising is always fine with top-level fragments.
    *    But in any other case, both types must be abstract (if `this.typeCondition` is an object, the 1st condition
    *    imply `type` can only be the same type) and we're in one of:
    *    - `type` and `this.typeCondition` are both different interfaces (that intersect but are different).
    *    - `type` is aunion and `this.typeCondition` an interface.
-   *       And in both cases, the selection of the fragment may selection an interface that is not valid at `type` (if `type`
-   *       is a union because a direct field is always wrong, and if `type` is another interface because that interface may
-   *       not have that particular field).
+   *    And in both cases, since `this.typeCondition` is an interface, the fragment selection set may have field selections
+   *    on that interface, and those fields may not be valid for `type`.
    *
    * @param type - the type at which we're looking at applying the fragment
    */
@@ -1225,7 +1243,7 @@ export class NamedFragmentDefinition extends DirectiveTargetElement<NamedFragmen
   }
 
   toString(indent?: string): string {
-    return (indent ?? '') + `fragment ${this.name} on ${this.typeCondition}${this.appliedDirectivesToString()} ${this.selectionSet.toString(false, true, indent)}`;
+    return `fragment ${this.name} on ${this.typeCondition}${this.appliedDirectivesToString()} ${this.selectionSet.toString(false, true, indent)}`;
   }
 }
 
@@ -1274,6 +1292,15 @@ export class NamedFragments {
     return this.fragments.values();
   }
 
+  /**
+   * Collect the usages of fragments that are used within the selection of other fragments.
+   */
+  collectUsedFragmentNames(collector: Map<string, number>) {
+    for (const fragment of this.definitions()) {
+      fragment.collectUsedFragmentNames(collector);
+    }
+  }
+
   map(mapper: (def: NamedFragmentDefinition) => NamedFragmentDefinition): NamedFragments {
     const mapped = new NamedFragments();
     for (const def of this.fragments.values()) {
@@ -1347,21 +1374,39 @@ export class NamedFragments {
     });
   }
 
+  // When we rebase named fragments on a subgraph schema, only a subset of what the fragment handles may belong
+  // to that particular subgraph. And there are a few sub-cases where that subset is such that we basically need or
+  // want to consider to ignore the fragment for that subgraph, and that is when:
+  // 1. the subset that apply is actually empty. The fragment wouldn't be valid in this case anyway.
+  // 2. the subset is a single leaf field: in that case, using the one field directly is just shorter than using
+  //   the fragment, so we consider the fragment don't really apply to that subgraph. Technically, using the
+  //   fragment could still be of value if the fragment name is a lot smaller than the one field name, but it's
+  //   enough of a niche case that we ignore it. Note in particular that one sub-case of this rule that is likely
+  //   to be common is when the subset ends up being just `__typename`: this would basically mean the fragment
+  //   don't really apply to the subgraph, and that this will ensure this is the case.
+  private selectionSetIsWorthUsing(selectionSet: SelectionSet): boolean {
+    const selections = selectionSet.selections();
+    if (selections.length === 0) {
+      return false;
+    }
+    if (selections.length === 1) {
+      const s = selections[0];
+      return !(s.kind === 'FieldSelection' && s.element.isLeafField());
+    }
+    return true;
+  }
+
   rebaseOn(schema: Schema): NamedFragments | undefined {
     return this.mapInDependencyOrder((fragment, newFragments) => {
       const rebasedType = schema.type(fragment.selectionSet.parentType.name);
-      try {
-        if (!rebasedType || !isCompositeType(rebasedType)) {
-          return undefined;
-        }
-
-        const rebasedSelection = fragment.selectionSet.rebaseOn(rebasedType, newFragments);
-        return new NamedFragmentDefinition(schema, fragment.name, rebasedType).setSelectionSet(rebasedSelection);
-      } catch (e) {
-        // This means we cannot rebase this selection on the schema and thus cannot reuse that fragment on that
-        // particular schema.
+      if (!rebasedType || !isCompositeType(rebasedType)) {
         return undefined;
       }
+
+      const rebasedSelection = fragment.selectionSet.rebaseOn({ parentType: rebasedType, fragments: newFragments, errorIfCannotRebase: false });
+      return this.selectionSetIsWorthUsing(rebasedSelection)
+        ? new NamedFragmentDefinition(schema, fragment.name, rebasedType).setSelectionSet(rebasedSelection)
+        : undefined;;
     });
   }
 
@@ -1499,6 +1544,20 @@ export class SelectionSet {
     return this._keyedSelections.has(typenameFieldName);
   }
 
+  withoutTopLevelTypenameField(): SelectionSet {
+    if (!this.hasTopLevelTypenameField) {
+      return this;
+    }
+
+    const newKeyedSelections = new Map<string, Selection>();
+    for (const [key, selection] of this._keyedSelections) {
+      if (key !== typenameFieldName) {
+        newKeyedSelections.set(key, selection);
+      }
+    }
+    return new SelectionSet(this.parentType, newKeyedSelections);
+  }
+
   fieldsInSet(): CollectedFieldsInSet {
     const fields = new Array<{ path: string[], field: FieldSelection }>();
     for (const selection of this.selections()) {
@@ -1570,7 +1629,7 @@ export class SelectionSet {
     // With that, `optimizeSelections` will correctly match on the `on Query` fragment; after which
     // we can unpack the final result.
     const wrapped = new InlineFragmentSelection(new FragmentElement(this.parentType, this.parentType), this);
-    const validator = FieldsConflictValidator.build(this);
+    const validator = FieldsConflictMultiBranchValidator.ofInitial(FieldsConflictValidator.build(this));
     const optimized = wrapped.optimize(fragments, validator);
 
     // Now, it's possible we matched a full fragment, in which case `optimized` will be just the named fragment,
@@ -1584,7 +1643,7 @@ export class SelectionSet {
   // Tries to match fragments inside each selections of this selection set, and this recursively. However, note that this
   // may not match fragments that would apply at top-level, so you should usually use `optimize` instead (this exists mostly
   // for the recursion).
-  optimizeSelections(fragments: NamedFragments, validator: FieldsConflictValidator): SelectionSet {
+  optimizeSelections(fragments: NamedFragments, validator: FieldsConflictMultiBranchValidator): SelectionSet {
     return this.lazyMap((selection) => selection.optimize(fragments, validator));
   }
 
@@ -1657,10 +1716,12 @@ export class SelectionSet {
    * }
    * ```
    *
-   * For this operation to be valid (to not throw), `parentType` must be such this selection set would
-   * be valid as a subselection of an inline fragment `... on parentType { <this selection set> }` (and
-   * so `this.normalize(this.parentType)` is always valid and useful, but it is possible to pass a `parentType`
-   * that is more "restrictive" than the selection current parent type).
+   * For this operation to be valid (to not throw), `parentType` must be such that every field selection in
+   * this selection set is such that the field parent type intersects `parentType` (there is no limitation
+   * on the fragment selections, though any fragment selections whose condition do not intersects `parentType`
+   * will be discarded). Note that `this.normalize(this.parentType)` is always valid and useful, but it is
+   * also possible to pass a `parentType` that is more "restrictive" than the selection current parent type
+   * (as long as the top-level fields of this selection set can be rebased on that type).
    *
    * Passing the option `recursive == false` makes the normalization only apply at the top-level, removing
    * any unecessary top-level inline fragments, possibly multiple layers of them, but we never recurse
@@ -1741,14 +1802,25 @@ export class SelectionSet {
     return updated.isEmpty() ? undefined : updated;
   }
 
-  rebaseOn(parentType: CompositeType, fragments: NamedFragments | undefined): SelectionSet {
+  rebaseOn({
+    parentType,
+    fragments,
+    errorIfCannotRebase,
+  }: {
+    parentType: CompositeType,
+    fragments: NamedFragments | undefined
+    errorIfCannotRebase: boolean,
+  }): SelectionSet {
     if (this.parentType === parentType) {
       return this;
     }
 
     const newSelections = new Map<string, Selection>();
     for (const selection of this.selections()) {
-      newSelections.set(selection.key(), selection.rebaseOn(parentType, fragments));
+      const rebasedSelection = selection.rebaseOn({ parentType, fragments, errorIfCannotRebase });
+      if (rebasedSelection) {
+        newSelections.set(selection.key(), rebasedSelection);
+      }
     }
 
     return new SelectionSet(parentType, newSelections);
@@ -1772,15 +1844,25 @@ export class SelectionSet {
     return true;
   }
 
-  contains(that: SelectionSet): ContainsResult {
+  contains(that: SelectionSet, options?: { ignoreMissingTypename?: boolean }): ContainsResult {
+    const ignoreMissingTypename = options?.ignoreMissingTypename ?? false;
     if (that._selections.length > this._selections.length) {
-      return ContainsResult.NOT_CONTAINED;
+      // If `that` has more selections but we're ignoring missing __typename, then in the case where
+      // `that` has a __typename but `this` does not, then we need the length of `that` to be at
+      // least 2 more than that of `this` to be able to conclude there is no contains.
+      if (!ignoreMissingTypename || that._selections.length > this._selections.length + 1 || this.hasTopLevelTypenameField() || !that.hasTopLevelTypenameField()) {
+        return ContainsResult.NOT_CONTAINED;
+      }
     }
 
     let isEqual = true;
     for (const [key, thatSelection] of that._keyedSelections) {
+      if (key === typenameFieldName && ignoreMissingTypename) {
+        continue;
+      }
+
       const thisSelection = this._keyedSelections.get(key);
-      const selectionResult = thisSelection?.contains(thatSelection);
+      const selectionResult = thisSelection?.contains(thatSelection, options);
       if (selectionResult === undefined || selectionResult === ContainsResult.NOT_CONTAINED) {
         return ContainsResult.NOT_CONTAINED;
       }
@@ -1792,6 +1874,11 @@ export class SelectionSet {
       : ContainsResult.STRICTLY_CONTAINED;
   }
 
+  containsTopLevelField(field: Field): boolean {
+    const selection = this._keyedSelections.get(field.key());
+    return !!selection && selection.element.equals(field);
+  }
+
   /**
    * Returns a selection set that correspond to this selection set but where any of the selections in the
    * provided selection set have been remove.
@@ -2141,10 +2228,10 @@ function makeSelection(parentType: CompositeType, updates: SelectionUpdate[], fr
 
   // Optimize for the simple case of a single selection, as we don't have to do anything complex to merge the sub-selections.
   if (updates.length === 1 && first instanceof AbstractSelection) {
-    return first.rebaseOn(parentType, fragments);
+    return first.rebaseOnOrError({ parentType, fragments });
   }
 
-  const element = updateElement(first).rebaseOn(parentType);
+  const element = updateElement(first).rebaseOnOrError(parentType);
   const subSelectionParentType = element.kind === 'Field' ? element.baseType() : element.castedType();
   if (!isCompositeType(subSelectionParentType)) {
     // This is a leaf, so all updates should correspond ot the same field and we just use the first.
@@ -2327,13 +2414,17 @@ abstract class AbstractSelection<TElement extends OperationElement, TIsLeaf exte
 
   abstract key(): string;
 
-  abstract optimize(fragments: NamedFragments, validator: FieldsConflictValidator): Selection;
+  abstract optimize(fragments: NamedFragments, validator: FieldsConflictMultiBranchValidator): Selection;
 
   abstract toSelectionNode(): SelectionNode;
 
   abstract validate(variableDefinitions: VariableDefinitions): void;
 
-  abstract rebaseOn(parentType: CompositeType, fragments: NamedFragments | undefined): TOwnType;
+  abstract rebaseOn(args: { parentType: CompositeType, fragments: NamedFragments | undefined, errorIfCannotRebase: boolean}): TOwnType | undefined;
+
+  rebaseOnOrError({ parentType, fragments }: { parentType: CompositeType, fragments: NamedFragments | undefined }): TOwnType {
+    return this.rebaseOn({ parentType, fragments, errorIfCannotRebase: true})!;
+  }
 
   get parentType(): CompositeType {
     return this.element.parentType;
@@ -2425,7 +2516,7 @@ abstract class AbstractSelection<TElement extends OperationElement, TIsLeaf exte
     parentType: CompositeType,
     subSelection: SelectionSet,
     fragments: NamedFragments,
-    validator: FieldsConflictValidator,
+    validator: FieldsConflictMultiBranchValidator,
     canUseFullMatchingFragment: (match: NamedFragmentDefinition) => boolean,
   }): SelectionSet | NamedFragmentDefinition {
     // We limit to fragments whose selection could be applied "directly" at `parentType`, meaning without taking the fragment condition
@@ -2444,8 +2535,7 @@ abstract class AbstractSelection<TElement extends OperationElement, TIsLeaf exte
     // applies to a subset of `subSelection`.
     const applyingFragments: { fragment: NamedFragmentDefinition, atType: FragmentRestrictionAtType }[] = [];
     for (const candidate of candidates) {
-      const atType = candidate.expandedSelectionSetAtType(parentType);
-      const selectionSetAtType = atType.selectionSet;
+      let atType = candidate.expandedSelectionSetAtType(parentType);
       // It's possible that while the fragment technically applies at `parentType`, it's "rebasing" on
       // `parentType` is empty, or contains only `__typename`. For instance, suppose we have
       // a union `U = A | B | C`, and then a fragment:
@@ -2464,11 +2554,22 @@ abstract class AbstractSelection<TElement extends OperationElement, TIsLeaf exte
       //
       // Using `F` in those cases is, while not 100% incorrect, at least not productive, and so we
       // skip it that case. This is essentially an optimisation.
-      if (selectionSetAtType.isEmpty() || (selectionSetAtType.selections().length === 1 && selectionSetAtType.selections()[0].isTypenameField())) {
+      if (atType.selectionSet.isEmpty() || (atType.selectionSet.selections().length === 1 && atType.selectionSet.selections()[0].isTypenameField())) {
         continue;
       }
 
-      const res = subSelection.contains(selectionSetAtType);
+      // As we check inclusion, we ignore the case where the fragment queries __typename but the subSelection does not.
+      // The rational is that querying `__typename` unecessarily is mostly harmless (it always works and it's super cheap)
+      // so we don't want to not use a fragment just to save querying a `__typename` in a few cases. But the underlying
+      // context of why this matters is that the query planner always requests __typename for abstract type, and will do
+      // so in fragments too, but we can have a field that _does_ return an abstract type within a fragment, but that
+      // _does not_ end up returning an abstract type when applied in a "more specific" context (think a fragment on
+      // an interface I1 where a inside field returns another interface I2, but applied in the context of a implementation
+      // type of I1 where that particular field returns an implementation of I2 rather than I2 directly; we would have
+      // added __typename to the fragment (because it's all interfaces), but the selection itself, which only deals
+      // with object type, may not have __typename requested; using the fragment might still be a good idea, and
+      // querying __typename needlessly is a very small price to pay for that).
+      const res = subSelection.contains(atType.selectionSet, { ignoreMissingTypename: true });
 
       if (res === ContainsResult.EQUAL) {
         if (canUseFullMatchingFragment(candidate)) {
@@ -2558,54 +2659,24 @@ abstract class AbstractSelection<TElement extends OperationElement, TIsLeaf exte
   }
 }
 
-class FieldsConflictValidator {
+class FieldsConflictMultiBranchValidator {
   private usedSpreadTrimmedPartAtLevel?: FieldsConflictValidator[];
 
-  private constructor(
-    private readonly byResponseName: Map<string, Map<Field, FieldsConflictValidator | null>>,
+  constructor(
+    private readonly validators: FieldsConflictValidator[],
   ) {
   }
 
-  static build(s: SelectionSet): FieldsConflictValidator {
-    return FieldsConflictValidator.forLevel(s.fieldsInSet());
+  static ofInitial(validator: FieldsConflictValidator): FieldsConflictMultiBranchValidator {
+    return new FieldsConflictMultiBranchValidator([validator]);
   }
 
-  private static forLevel(level: CollectedFieldsInSet): FieldsConflictValidator {
-    const atLevel = new Map<string, Map<Field, CollectedFieldsInSet | null>>();
-
-    for (const { field } of level) {
-      const responseName = field.element.responseName();
-      let atResponseName = atLevel.get(responseName);
-      if (!atResponseName) {
-        atResponseName = new Map<Field, CollectedFieldsInSet>();
-        atLevel.set(responseName, atResponseName);
-      }
-      if (field.selectionSet) {
-        let forField = atResponseName.get(field.element) ?? [];
-        atResponseName.set(field.element, forField.concat(field.selectionSet.fieldsInSet()));
-      } else {
-        atResponseName.set(field.element, null);
-      }
-    }
-
-    const byResponseName = new Map<string, Map<Field, FieldsConflictValidator | null>>();
-    for (const [name, level] of atLevel.entries()) {
-      const atResponseName = new Map<Field, FieldsConflictValidator | null>();
-      for (const [field, collectedFields] of level) {
-        const validator = collectedFields ? FieldsConflictValidator.forLevel(collectedFields) : null;
-        atResponseName.set(field, validator);
-      }
-      byResponseName.set(name, atResponseName);
-    }
-    return new FieldsConflictValidator(byResponseName);
-  }
-
-  forField(field: Field): FieldsConflictValidator {
-    const validator = this.byResponseName.get(field.responseName())?.get(field);
-    // This should be called on validator built on the exact selection set from field this `field` is coming, so
-    // we should find it or the code is buggy.
-    assert(validator, () => `Should have found validator for ${field}`);
-    return validator;
+  forField(field: Field): FieldsConflictMultiBranchValidator {
+    const forAllBranches = this.validators.flatMap((vs) => vs.forField(field));
+    // As this is called on (non-leaf) field from the same query on which we have build the initial validators, we
+    // should find at least one validator.
+    assert(forAllBranches.length > 0, `Shoud have found at least one validator for ${field}`);
+    return new FieldsConflictMultiBranchValidator(forAllBranches);
   }
 
   // At this point, we known that the fragment, restricted to the current parent type, matches a subset of the
@@ -2627,7 +2698,7 @@ class FieldsConflictValidator {
       return true;
     }
 
-    if (!this.doMergeWith(validator)) {
+    if (!this.validators.every((v) => v.doMergeWith(validator))) {
       return false;
     }
 
@@ -2654,6 +2725,61 @@ class FieldsConflictValidator {
     this.usedSpreadTrimmedPartAtLevel.push(validator);
     return true;
   }
+}
+
+class FieldsConflictValidator {
+  private constructor(
+    private readonly byResponseName: Map<string, Map<Field, FieldsConflictValidator | null>>,
+  ) {
+  }
+
+  static build(s: SelectionSet): FieldsConflictValidator {
+    return FieldsConflictValidator.forLevel(s.fieldsInSet());
+  }
+
+  private static forLevel(level: CollectedFieldsInSet): FieldsConflictValidator {
+    const atLevel = new Map<string, Map<Field, CollectedFieldsInSet | null>>();
+
+    for (const { field } of level) {
+      const responseName = field.element.responseName();
+      let atResponseName = atLevel.get(responseName);
+      if (!atResponseName) {
+        atResponseName = new Map<Field, CollectedFieldsInSet>();
+        atLevel.set(responseName, atResponseName);
+      }
+      if (field.selectionSet) {
+        // It's unlikely that we've seen the same `field.element` as we don't particularly "intern" `Field` object (so even if the exact same field
+        // is used in 2 parts of a selection set, it will probably be a different `Field` object), so the `get` below will probably mostly return `undefined`,
+        // but it wouldn't be incorrect to re-use a `Field` object multiple side, so no reason not to handle that correctly.
+        let forField = atResponseName.get(field.element) ?? [];
+        atResponseName.set(field.element, forField.concat(field.selectionSet.fieldsInSet()));
+      } else {
+        // Note that whether a `FieldSelection` has `selectionSet` or not is entirely determined by whether the field type is a composite type
+        // or not, so even if we've seen a previous version of `field.element` before, we know it's guarantee to have had no `selectionSet`.
+        // So the `set` below may overwrite a previous entry, but it would be a `null` so no harm done.
+        atResponseName.set(field.element, null);
+      }
+    }
+
+    const byResponseName = new Map<string, Map<Field, FieldsConflictValidator | null>>();
+    for (const [name, level] of atLevel.entries()) {
+      const atResponseName = new Map<Field, FieldsConflictValidator | null>();
+      for (const [field, collectedFields] of level) {
+        const validator = collectedFields ? FieldsConflictValidator.forLevel(collectedFields) : null;
+        atResponseName.set(field, validator);
+      }
+      byResponseName.set(name, atResponseName);
+    }
+    return new FieldsConflictValidator(byResponseName);
+  }
+
+  forField(field: Field): FieldsConflictValidator[] {
+    const byResponseName = this.byResponseName.get(field.responseName());
+    if (!byResponseName) {
+      return [];
+    }
+    return mapValues(byResponseName).filter((v): v is FieldsConflictValidator => !!v);
+  }
 
   doMergeWith(that: FieldsConflictValidator): boolean {
     for (const [responseName, thisFields] of this.byResponseName.entries()) {
@@ -2761,7 +2887,7 @@ export class FieldSelection extends AbstractSelection<Field<any>, undefined, Fie
     return this.element.key();
   }
 
-  optimize(fragments: NamedFragments, validator: FieldsConflictValidator): Selection {
+  optimize(fragments: NamedFragments, validator: FieldsConflictMultiBranchValidator): Selection {
     const fieldBaseType = baseType(this.element.definition.type!);
     if (!isCompositeType(fieldBaseType) || !this.selectionSet) {
       return this;
@@ -2770,22 +2896,20 @@ export class FieldSelection extends AbstractSelection<Field<any>, undefined, Fie
     const fieldValidator = validator.forField(this.element);
 
     // First, see if we can reuse fragments for the selection of this field.
-    let optimizedSelection = this.selectionSet;
-    if (isCompositeType(fieldBaseType) && this.selectionSet) {
-      const optimized = this.tryOptimizeSubselectionWithFragments({
-        parentType: fieldBaseType,
-        subSelection: this.selectionSet,
-        fragments,
-        validator: fieldValidator,
-        // We can never apply a fragments that has directives on it at the field level.
-        canUseFullMatchingFragment: (fragment) => fragment.appliedDirectives.length === 0,
-      });
+    const optimized = this.tryOptimizeSubselectionWithFragments({
+      parentType: fieldBaseType,
+      subSelection: this.selectionSet,
+      fragments,
+      validator: fieldValidator,
+      // We can never apply a fragments that has directives on it at the field level.
+      canUseFullMatchingFragment: (fragment) => fragment.appliedDirectives.length === 0,
+    });
 
-      if (optimized instanceof NamedFragmentDefinition) {
-        optimizedSelection = selectionSetOf(fieldBaseType, new FragmentSpreadSelection(fieldBaseType, fragments, optimized, []));
-      } else {
-        optimizedSelection = optimized;
-      }
+    let optimizedSelection;
+    if (optimized instanceof NamedFragmentDefinition) {
+      optimizedSelection = selectionSetOf(fieldBaseType, new FragmentSpreadSelection(fieldBaseType, fragments, optimized, []));
+    } else {
+      optimizedSelection = optimized;
     }
 
     // Then, recurse inside the field sub-selection (note that if we matched some fragments above,
@@ -2828,12 +2952,24 @@ export class FieldSelection extends AbstractSelection<Field<any>, undefined, Fie
    * Obviously, this operation will only succeed if this selection (both the field itself and its subselections)
    * make sense from the provided parent type. If this is not the case, this method will throw.
    */
-  rebaseOn(parentType: CompositeType, fragments: NamedFragments | undefined): FieldSelection {
+  rebaseOn({
+    parentType,
+    fragments,
+    errorIfCannotRebase,
+  }: {
+    parentType: CompositeType,
+    fragments: NamedFragments | undefined,
+    errorIfCannotRebase: boolean,
+  }): FieldSelection | undefined {
     if (this.element.parentType === parentType) {
       return this;
     }
 
-    const rebasedElement = this.element.rebaseOn(parentType);
+    const rebasedElement = this.element.rebaseOn({ parentType, errorIfCannotRebase });
+    if (!rebasedElement) {
+      return undefined;
+    }
+
     if (!this.selectionSet) {
       return this.withUpdatedElement(rebasedElement);
     }
@@ -2844,7 +2980,8 @@ export class FieldSelection extends AbstractSelection<Field<any>, undefined, Fie
     }
 
     validate(isCompositeType(rebasedBase), () => `Cannot rebase field selection ${this} on ${parentType}: rebased field base return type ${rebasedBase} is not composite`);
-    return this.withUpdatedComponents(rebasedElement, this.selectionSet.rebaseOn(rebasedBase, fragments));
+    const rebasedSelectionSet = this.selectionSet.rebaseOn({ parentType: rebasedBase, fragments, errorIfCannotRebase });
+    return rebasedSelectionSet.isEmpty() ? undefined : this.withUpdatedComponents(rebasedElement, rebasedSelectionSet);
   }
 
   /**
@@ -2951,7 +3088,7 @@ export class FieldSelection extends AbstractSelection<Field<any>, undefined, Fie
     return !!that.selectionSet && this.selectionSet.equals(that.selectionSet);
   }
 
-  contains(that: Selection): ContainsResult {
+  contains(that: Selection, options?: { ignoreMissingTypename?: boolean }): ContainsResult {
     if (!(that instanceof FieldSelection) || !this.element.equals(that.element)) {
       return ContainsResult.NOT_CONTAINED;
     }
@@ -2961,7 +3098,7 @@ export class FieldSelection extends AbstractSelection<Field<any>, undefined, Fie
       return ContainsResult.EQUAL;
     }
     assert(that.selectionSet, '`this` and `that` have the same element, so if one has sub-selection, the other one should too')
-    return this.selectionSet.contains(that.selectionSet);
+    return this.selectionSet.contains(that.selectionSet, options);
   }
 
   toString(expandFragments: boolean = true, indent?: string): string {
@@ -3005,7 +3142,27 @@ export abstract class FragmentSelection extends AbstractSelection<FragmentElemen
 
   abstract equals(that: Selection): boolean;
 
-  abstract contains(that: Selection): ContainsResult;
+  abstract contains(that: Selection, options?: { ignoreMissingTypename?: boolean }): ContainsResult;
+
+  normalize({ parentType, recursive }: { parentType: CompositeType, recursive? : boolean }): FragmentSelection | SelectionSet | undefined {
+    const thisCondition = this.element.typeCondition;
+
+    // This method assumes by contract that `parentType` runtimes intersects `this.parentType`'s, but `parentType`
+    // runtimes may be a subset. So first check if the selection should not be discarded on that account (that
+    // is, we should not keep the selection if its condition runtimes don't intersect at all with those of
+    // `parentType` as that would ultimately make an invalid selection set).
+    if (thisCondition && parentType !== this.parentType) {
+      const conditionRuntimes = possibleRuntimeTypes(thisCondition);
+      const typeRuntimes = possibleRuntimeTypes(parentType);
+      if (!conditionRuntimes.some((t) => typeRuntimes.includes(t))) {
+        return undefined;
+      }
+    }
+
+    return this.normalizeKnowingItIntersects({ parentType, recursive });
+  }
+
+  protected abstract normalizeKnowingItIntersects({ parentType, recursive }: { parentType: CompositeType, recursive? : boolean }): FragmentSelection | SelectionSet | undefined;
 }
 
 class InlineFragmentSelection extends FragmentSelection {
@@ -3042,18 +3199,31 @@ class InlineFragmentSelection extends FragmentSelection {
     this.selectionSet.validate(variableDefinitions);
   }
 
-  rebaseOn(parentType: CompositeType, fragments: NamedFragments | undefined): FragmentSelection {
+  rebaseOn({
+    parentType,
+    fragments,
+    errorIfCannotRebase,
+  }: {
+    parentType: CompositeType,
+    fragments: NamedFragments | undefined,
+    errorIfCannotRebase: boolean,
+  }): FragmentSelection | undefined {
     if (this.parentType === parentType) {
       return this;
     }
 
-    const rebasedFragment = this.element.rebaseOn(parentType);
+    const rebasedFragment = this.element.rebaseOn({ parentType, errorIfCannotRebase });
+    if (!rebasedFragment) {
+      return undefined;
+    }
+
     const rebasedCastedType = rebasedFragment.castedType();
     if (rebasedCastedType === this.selectionSet.parentType) {
       return this.withUpdatedElement(rebasedFragment);
     }
 
-    return this.withUpdatedComponents(rebasedFragment, this.selectionSet.rebaseOn(rebasedCastedType, fragments));
+    const rebasedSelectionSet = this.selectionSet.rebaseOn({ parentType: rebasedCastedType, fragments, errorIfCannotRebase });
+    return rebasedSelectionSet.isEmpty() ? undefined : this.withUpdatedComponents(rebasedFragment, rebasedSelectionSet);
   }
 
   canAddTo(parentType: CompositeType): boolean {
@@ -3090,7 +3260,7 @@ class InlineFragmentSelection extends FragmentSelection {
     };
   }
 
-  optimize(fragments: NamedFragments, validator: FieldsConflictValidator): FragmentSelection {
+  optimize(fragments: NamedFragments, validator: FieldsConflictMultiBranchValidator): FragmentSelection {
     let optimizedSelection = this.selectionSet;
 
     // First, see if we can reuse fragments for the selection of this field.
@@ -3173,21 +3343,9 @@ class InlineFragmentSelection extends FragmentSelection {
       : this.withUpdatedComponents(newElement, newSelection);
   }
 
-  normalize({ parentType, recursive }: { parentType: CompositeType, recursive? : boolean }): FragmentSelection | SelectionSet | undefined {
+  protected normalizeKnowingItIntersects({ parentType, recursive }: { parentType: CompositeType, recursive? : boolean }): FragmentSelection | SelectionSet | undefined {
     const thisCondition = this.element.typeCondition;
 
-    // This method assumes by contract that `parentType` runtimes intersects `this.parentType`'s, but `parentType`
-    // runtimes may be a subset. So first check if the selection should not be discarded on that account (that
-    // is, we should not keep the selection if its condition runtimes don't intersect at all with those of
-    // `parentType` as that would ultimately make an invalid selection set).
-    if (thisCondition && parentType !== this.parentType) {
-      const conditionRuntimes = possibleRuntimeTypes(thisCondition);
-      const typeRuntimes = possibleRuntimeTypes(parentType);
-      if (!conditionRuntimes.some((t) => typeRuntimes.includes(t))) {
-        return undefined;
-      }
-    }
-
     // We know the condition is "valid", but it may not be useful. That said, if the condition has directives,
     // we preserve the fragment no matter what.
     if (this.element.appliedDirectives.length === 0) {
@@ -3214,7 +3372,8 @@ class InlineFragmentSelection extends FragmentSelection {
           return undefined;
         } else {
           return this.withUpdatedComponents(
-            this.element.rebaseOn(parentType),
+            // We should be able to rebase, or there is a bug, so error if that is the case.
+            this.element.rebaseOnOrError(parentType),
             selectionSetOfElement(
               new Field(
                 (this.element.typeCondition ?? parentType).typenameField()!,
@@ -3266,7 +3425,7 @@ class InlineFragmentSelection extends FragmentSelection {
 
     return this.parentType === parentType && this.selectionSet === normalizedSelectionSet
       ? this
-      : this.withUpdatedComponents(this.element.rebaseOn(parentType), normalizedSelectionSet);
+      : this.withUpdatedComponents(this.element.rebaseOnOrError(parentType), normalizedSelectionSet);
   }
 
   expandFragments(updatedFragments: NamedFragments | undefined): FragmentSelection {
@@ -3283,12 +3442,12 @@ class InlineFragmentSelection extends FragmentSelection {
       && this.selectionSet.equals(that.selectionSet);
   }
 
-  contains(that: Selection): ContainsResult {
+  contains(that: Selection, options?: { ignoreMissingTypename?: boolean }): ContainsResult {
     if (!(that instanceof FragmentSelection) || !this.element.equals(that.element)) {
       return ContainsResult.NOT_CONTAINED;
     }
 
-    return this.selectionSet.contains(that.selectionSet);
+    return this.selectionSet.contains(that.selectionSet, options);
   }
 
   toString(expandFragments: boolean = true, indent?: string): string {
@@ -3327,11 +3486,11 @@ class FragmentSpreadSelection extends FragmentSelection {
     assert(false, `Unsupported`);
   }
 
-  normalize({ parentType }: { parentType: CompositeType }): FragmentSelection  {
+  normalizeKnowingItIntersects({ parentType }: { parentType: CompositeType }): FragmentSelection {
     // We must update the spread parent type if necessary since we're not going deeper,
     // or we'll be fundamentally losing context.
     assert(parentType.schema() === this.parentType.schema(), 'Should not try to normalize using a type from another schema');
-    return this.rebaseOn(parentType, this.fragments);
+    return this.rebaseOnOrError({ parentType, fragments: this.fragments });
   }
 
   validate(): void {
@@ -3363,11 +3522,19 @@ class FragmentSpreadSelection extends FragmentSelection {
     };
   }
 
-  optimize(_1: NamedFragments, _2: FieldsConflictValidator): FragmentSelection {
+  optimize(_1: NamedFragments, _2: FieldsConflictMultiBranchValidator): FragmentSelection {
     return this;
   }
 
-  rebaseOn(parentType: CompositeType, fragments: NamedFragments | undefined): FragmentSelection {
+  rebaseOn({
+    parentType,
+    fragments,
+    errorIfCannotRebase,
+  }: {
+    parentType: CompositeType,
+    fragments: NamedFragments | undefined,
+    errorIfCannotRebase: boolean,
+  }): FragmentSelection | undefined {
     // We preserve the parent type here, to make sure we don't lose context, but we actually don't
     // want to expand the spread  as that would compromise the code that optimize subgraph fetches to re-use named
     // fragments.
@@ -3387,7 +3554,14 @@ class FragmentSpreadSelection extends FragmentSelection {
     assert(fragments || this.parentType.schema() === parentType.schema(), `Must provide fragments is rebasing on other schema`);
     const newFragments = fragments ?? this.fragments;
     const namedFragment = newFragments.get(this.namedFragment.name);
-    assert(namedFragment, () => `Cannot rebase ${this} if it isn't part of the provided fragments`);
+    // If we're rebasing on another schema (think a subgraph), then named fragments will have been rebased on that, and some
+    // of them may not contain anything that is on that subgraph, in which case they will not have been included at all.
+    // If so, then as long as we're not ask to error if we cannot rebase, then we're happy to skip that spread (since again,
+    // it expands to nothing that apply on the schema).
+    if (!namedFragment) {
+      validate(!errorIfCannotRebase, () => `Cannot rebase ${this.toString(false)} if it isn't part of the provided fragments`);
+      return undefined;
+    }
     return new FragmentSpreadSelection(
       parentType,
       newFragments,
@@ -3443,7 +3617,7 @@ class FragmentSpreadSelection extends FragmentSelection {
       && sameDirectiveApplications(this.spreadDirectives, that.spreadDirectives);
   }
 
-  contains(that: Selection): ContainsResult {
+  contains(that: Selection, options?: { ignoreMissingTypename?: boolean }): ContainsResult {
     if (this.equals(that)) {
       return ContainsResult.EQUAL;
     }
@@ -3452,7 +3626,7 @@ class FragmentSpreadSelection extends FragmentSelection {
       return ContainsResult.NOT_CONTAINED;
     }
 
-    return  this.selectionSet.contains(that.selectionSet);
+    return this.selectionSet.contains(that.selectionSet, options);
   }
 
   toString(expandFragments: boolean = true, indent?: string): string {