@apollo/federation-internals 2.4.8 → 2.4.10

package/src/operations.ts

@@ -478,7 +478,7 @@ export class FragmentElement extends AbstractOperationElement<FragmentElement> {
     // schema.
     const { canRebase, rebasedCondition } = this.canRebaseOn(parentType);
     validate(
-      canRebase, 
+      canRebase,
       () => `Cannot add fragment of condition "${typeCondition}" (runtimes: [${possibleRuntimeTypes(typeCondition!)}]) to parent type "${parentType}" (runtimes: ${possibleRuntimeTypes(parentType)})`
     );
     return this.withUpdatedTypes(parentType, rebasedCondition);
@@ -697,7 +697,7 @@ export type RootOperationPath = {
   path: OperationPath
 }
 
-// Computes for every fragment, which other fragments use it (so the reverse of it's dependencies, the other fragment it uses). 
+// Computes for every fragment, which other fragments use it (so the reverse of it's dependencies, the other fragment it uses).
 function computeFragmentsDependents(fragments: NamedFragments): SetMultiMap<string, string> {
   const reverseDeps = new SetMultiMap<string, string>();
   for (const fragment of fragments.definitions()) {
@@ -934,9 +934,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 +1106,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
    */
@@ -1274,6 +1281,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()) {
@@ -1460,7 +1476,7 @@ class DeferNormalizer {
 }
 
 export enum ContainsResult {
-  // Note: enum values are numbers in the end, and 0 means false in JS, so we should keep `NOT_CONTAINED` first 
+  // Note: enum values are numbers in the end, and 0 means false in JS, so we should keep `NOT_CONTAINED` first
   // so that using the result of `contains` as a boolean works.
   NOT_CONTAINED,
   STRICTLY_CONTAINED,
@@ -1570,7 +1586,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 +1600,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));
   }
 
@@ -1593,7 +1609,7 @@ export class SelectionSet {
   }
 
   /**
-   * Applies some normalization rules to this selection set in the context of the provided `parentType`. 
+   * Applies some normalization rules to this selection set in the context of the provided `parentType`.
    *
    * Normalization mostly removes unecessary/redundant inline fragments, so that for instance, with
    * schema:
@@ -1657,10 +1673,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
@@ -1792,6 +1810,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.
@@ -2192,7 +2215,7 @@ function makeSelectionSet(parentType: CompositeType, keyedUpdates: MultiMap<stri
 }
 
 /**
- * A simple wrapper over a `SelectionSetUpdates` that allows to conveniently build a selection set, then add some more updates and build it again, etc... 
+ * A simple wrapper over a `SelectionSetUpdates` that allows to conveniently build a selection set, then add some more updates and build it again, etc...
  */
 export class MutableSelectionSet<TMemoizedValue extends { [key: string]: any } = {}> {
   private computed: SelectionSet | undefined;
@@ -2327,7 +2350,7 @@ 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;
 
@@ -2425,7 +2448,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
@@ -2433,7 +2456,7 @@ abstract class AbstractSelection<TElement extends OperationElement, TIsLeaf exte
     // have been "normalized away" and so we want for this very call to be called on the fragment whose type _is_ the fragment condition (at
     // which point, this `maybeApplyingDirectlyAtType` method will apply.
     // Also note that this is because we have this restriction that calling `expandedSelectionSetAtType` is ok.
-    let candidates = fragments.maybeApplyingDirectlyAtType(parentType);
+    const candidates = fragments.maybeApplyingDirectlyAtType(parentType);
     if (candidates.length === 0) {
       return subSelection;
     }
@@ -2558,54 +2581,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 +2620,7 @@ class FieldsConflictValidator {
       return true;
     }
 
-    if (!this.doMergeWith(validator)) {
+    if (!this.validators.every((v) => v.doMergeWith(validator))) {
       return false;
     }
 
@@ -2654,6 +2647,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.
+        const 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 +2809,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 +2818,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,
@@ -2822,7 +2868,7 @@ export class FieldSelection extends AbstractSelection<Field<any>, undefined, Fie
   }
 
   /**
-   * Returns a field selection "equivalent" to the one represented by this object, but such that its parent type 
+   * Returns a field selection "equivalent" to the one represented by this object, but such that its parent type
    * is the one provided as argument.
    *
    * Obviously, this operation will only succeed if this selection (both the field itself and its subselections)
@@ -2988,7 +3034,7 @@ export abstract class FragmentSelection extends AbstractSelection<FragmentElemen
       );
     }
   }
-  
+
   filterRecursiveDepthFirst(predicate: (selection: Selection) => boolean): FragmentSelection | undefined {
     // Note that we essentially expand all fragments as part of this.
     const updatedSelectionSet = this.selectionSet.filterRecursiveDepthFirst(predicate);
@@ -2998,7 +3044,7 @@ export abstract class FragmentSelection extends AbstractSelection<FragmentElemen
 
     return predicate(thisWithFilteredSelectionSet) ? thisWithFilteredSelectionSet : undefined;
   }
- 
+
   hasDefer(): boolean {
     return this.element.hasDefer() || this.selectionSet.hasDefer();
   }
@@ -3006,6 +3052,26 @@ export abstract class FragmentSelection extends AbstractSelection<FragmentElemen
   abstract equals(that: Selection): boolean;
 
   abstract contains(that: Selection): 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 {
@@ -3090,7 +3156,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 +3239,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) {
@@ -3327,7 +3381,7 @@ 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');
@@ -3363,7 +3417,7 @@ class FragmentSpreadSelection extends FragmentSelection {
     };
   }
 
-  optimize(_1: NamedFragments, _2: FieldsConflictValidator): FragmentSelection {
+  optimize(_1: NamedFragments, _2: FieldsConflictMultiBranchValidator): FragmentSelection {
     return this;
   }