@apollo/federation-internals 2.4.10 → 2.4.11

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);
   }
 
@@ -1232,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)}`;
   }
 }
 
@@ -1363,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;
     });
   }
 
@@ -1515,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()) {
@@ -1759,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);
@@ -1790,22 +1844,36 @@ 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;
+    let didIgnoreTypename = false;
     for (const [key, thatSelection] of that._keyedSelections) {
+      if (key === typenameFieldName && ignoreMissingTypename) {
+        if (!this._keyedSelections.has(typenameFieldName)) {
+          didIgnoreTypename = true;
+        }
+        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;
       }
       isEqual &&= selectionResult === ContainsResult.EQUAL;
     }
 
-    return isEqual && that._selections.length === this._selections.length
+    return isEqual && that._selections.length === (this._selections.length + (didIgnoreTypename ? 1 : 0))
       ? ContainsResult.EQUAL
       : ContainsResult.STRICTLY_CONTAINED;
   }
@@ -2164,10 +2232,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.
@@ -2356,7 +2424,11 @@ abstract class AbstractSelection<TElement extends OperationElement, TIsLeaf exte
 
   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;
@@ -2468,7 +2540,6 @@ abstract class AbstractSelection<TElement extends OperationElement, TIsLeaf exte
     const applyingFragments: { fragment: NamedFragmentDefinition, atType: FragmentRestrictionAtType }[] = [];
     for (const candidate of candidates) {
       const atType = candidate.expandedSelectionSetAtType(parentType);
-      const selectionSetAtType = atType.selectionSet;
       // 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:
@@ -2487,11 +2558,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)) {
@@ -2568,7 +2650,7 @@ abstract class AbstractSelection<TElement extends OperationElement, TIsLeaf exte
 
     let notCoveredByFragments = subSelection;
     const optimized = new SelectionSetUpdates();
-    for (const { fragment, atType} of filteredApplyingFragments) {
+    for (const { fragment, atType } of filteredApplyingFragments) {
       if (!validator.checkCanReuseFragmentAndTrackIt(atType)) {
         continue;
       }
@@ -2874,12 +2956,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);
     }
@@ -2890,7 +2984,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);
   }
 
   /**
@@ -2997,7 +3092,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;
     }
@@ -3007,7 +3102,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 {
@@ -3051,7 +3146,7 @@ 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;
@@ -3108,18 +3203,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 {
@@ -3268,7 +3376,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()!,
@@ -3320,7 +3429,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 {
@@ -3337,12 +3446,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 {
@@ -3385,7 +3494,7 @@ class FragmentSpreadSelection extends 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 {
@@ -3421,7 +3530,15 @@ class FragmentSpreadSelection extends 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.
@@ -3441,7 +3558,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,
@@ -3497,7 +3621,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;
     }
@@ -3506,7 +3630,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 {