@apollo/federation-internals 2.4.0 → 2.4.2

package/dist/operations.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.operationToDocument = exports.parseSelectionSet = exports.parseOperation = exports.operationFromDocument = exports.FragmentSelection = exports.FieldSelection = exports.selectionOfElement = exports.selectionSetOfElement = exports.selectionSetOf = exports.allFieldDefinitionsInSelectionSet = exports.MutableSelectionSet = exports.SelectionSetUpdates = exports.SelectionSet = exports.NamedFragments = exports.NamedFragmentDefinition = exports.Operation = exports.concatOperationPaths = exports.conditionalDirectivesInOperationPath = exports.sameOperationPaths = exports.operationPathToStringPath = exports.FragmentElement = exports.Field = void 0;
 const graphql_1 = require("graphql");
 const definitions_1 = require("./definitions");
+const federation_1 = require("./federation");
 const error_1 = require("./error");
 const types_1 = require("./types");
 const utils_1 = require("./utils");
@@ -174,7 +175,8 @@ class Field extends AbstractOperationElement {
     canRebaseOn(parentType) {
         const fieldParentType = this.definition.parent;
         return parentType.name === fieldParentType.name
-            || ((0, definitions_1.isInterfaceType)(fieldParentType) && fieldParentType.allImplementations().some(i => i.name === parentType.name));
+            || (0, definitions_1.isInterfaceType)(fieldParentType)
+            || (0, federation_1.isInterfaceObjectType)(fieldParentType);
     }
     typeIfAddedTo(parentType) {
         var _a, _b;
@@ -435,7 +437,7 @@ function isUselessFollowupElement(first, followup, conditionals) {
         && followup.kind === 'FragmentElement'
         && !!followup.typeCondition
         && (followup.appliedDirectives.length === 0 || (0, definitions_1.isDirectiveApplicationsSubset)(conditionals, followup.appliedDirectives))
-        && (0, types_1.sameType)(typeOfFirst, followup.typeCondition);
+        && (0, types_1.isSubtype)(followup.typeCondition, typeOfFirst);
 }
 class Operation {
     constructor(schema, rootKind, selectionSet, variableDefinitions, name) {
@@ -557,8 +559,7 @@ class NamedFragmentDefinition extends definitions_1.DirectiveTargetElement {
         };
     }
     canApplyAtType(type) {
-        const applyAtType = (0, types_1.sameType)(this.typeCondition, type)
-            || ((0, definitions_1.isAbstractType)(this.typeCondition) && !(0, definitions_1.isUnionType)(type) && (0, types_1.isDirectSubtype)(this.typeCondition, type));
+        const applyAtType = (0, types_1.sameType)(type, this.typeCondition) || (0, definitions_1.runtimeTypesIntersects)(type, this.typeCondition);
         return applyAtType
             && this.validForSchema(type.schema());
     }
@@ -839,31 +840,67 @@ class SelectionSet {
         }
         return true;
     }
-    contains(that) {
-        if (this._selections.length < that._selections.length) {
-            return false;
+    triviallyNestedSelectionsForKey(parentType, key) {
+        const found = [];
+        for (const selection of this.selections()) {
+            if (selection.isUnecessaryInlineFragment(parentType)) {
+                const selectionForKey = selection.selectionSet._keyedSelections.get(key);
+                if (selectionForKey) {
+                    found.push(selectionForKey);
+                }
+                for (const nestedSelection of selection.selectionSet.triviallyNestedSelectionsForKey(parentType, key)) {
+                    found.push(nestedSelection);
+                }
+            }
         }
+        return found;
+    }
+    mergeSameKeySelections(selections) {
+        if (selections.length === 0) {
+            return undefined;
+        }
+        const first = selections[0];
+        if (!first.selectionSet || (first instanceof FragmentSpreadSelection) || selections.length === 1) {
+            return first;
+        }
+        const mergedSubselections = new SelectionSetUpdates();
+        for (const selection of selections) {
+            mergedSubselections.add(selection.selectionSet);
+        }
+        return first.withUpdatedSelectionSet(mergedSubselections.toSelectionSet(first.selectionSet.parentType));
+    }
+    contains(that) {
         for (const [key, thatSelection] of that._keyedSelections) {
             const thisSelection = this._keyedSelections.get(key);
-            if (!thisSelection || !thisSelection.contains(thatSelection)) {
+            const otherSelections = this.triviallyNestedSelectionsForKey(this.parentType, key);
+            const mergedSelection = this.mergeSameKeySelections([thisSelection].concat(otherSelections).filter(utils_1.isDefined));
+            if (!(mergedSelection && mergedSelection.contains(thatSelection))
+                && !(thatSelection.isUnecessaryInlineFragment(this.parentType) && this.contains(thatSelection.selectionSet))) {
                 return false;
             }
         }
         return true;
     }
+    diffIfContains(that) {
+        if (this.contains(that)) {
+            const diff = this.minus(that);
+            return { contains: true, diff: diff.isEmpty() ? undefined : diff };
+        }
+        return { contains: false };
+    }
     minus(that) {
         const updated = new SelectionSetUpdates();
         for (const [key, thisSelection] of this._keyedSelections) {
             const thatSelection = that._keyedSelections.get(key);
-            if (!thatSelection) {
+            const otherSelections = that.triviallyNestedSelectionsForKey(this.parentType, key);
+            const allSelections = thatSelection ? [thatSelection].concat(otherSelections) : otherSelections;
+            if (allSelections.length === 0) {
                 updated.add(thisSelection);
             }
             else {
-                if (thisSelection.selectionSet && thatSelection.selectionSet) {
-                    const updatedSubSelectionSet = thisSelection.selectionSet.minus(thatSelection.selectionSet);
-                    if (!updatedSubSelectionSet.isEmpty()) {
-                        updated.add(thisSelection.withUpdatedSelectionSet(updatedSubSelectionSet));
-                    }
+                const selectionDiff = allSelections.reduce((prev, val) => prev === null || prev === void 0 ? void 0 : prev.minus(val), thisSelection);
+                if (selectionDiff) {
+                    updated.add(selectionDiff);
                 }
             }
         }
@@ -1032,9 +1069,17 @@ function addOneToKeyedUpdates(keyedUpdates, selection) {
         keyedUpdates.add(selection.key(), selection);
     }
 }
+function maybeRebaseOnSchema(toRebase, schema) {
+    if (toRebase.schema() === schema) {
+        return toRebase;
+    }
+    const rebased = schema.type(toRebase.name);
+    (0, utils_1.assert)(rebased && (0, definitions_1.isCompositeType)(rebased), () => `Expected ${toRebase} to exists and be composite in the rebased schema, but got ${rebased === null || rebased === void 0 ? void 0 : rebased.kind}`);
+    return rebased;
+}
 function isUnecessaryFragment(parentType, fragment) {
     return fragment.element.appliedDirectives.length === 0
-        && (!fragment.element.typeCondition || (0, types_1.sameType)(parentType, fragment.element.typeCondition));
+        && (!fragment.element.typeCondition || (0, types_1.isSubtype)(maybeRebaseOnSchema(fragment.element.typeCondition, parentType.schema()), parentType));
 }
 function withUnecessaryFragmentsRemoved(parentType, selections) {
     if (selections instanceof AbstractSelection) {
@@ -1231,6 +1276,39 @@ class AbstractSelection {
             ? this.us()
             : this.withUpdatedSelectionSet(updatedSelectionSet);
     }
+    minus(that) {
+        if (this.selectionSet && that.selectionSet) {
+            const updatedSubSelectionSet = this.selectionSet.minus(that.selectionSet);
+            if (!updatedSubSelectionSet.isEmpty()) {
+                return this.withUpdatedSelectionSet(updatedSubSelectionSet);
+            }
+        }
+        return undefined;
+    }
+    tryOptimizeSubselectionOnce(_) {
+        (0, utils_1.assert)(false, `UNSUPPORTED`);
+    }
+    tryOptimizeSubselectionWithFragments({ parentType, subSelection, fragments, fragmentFilter, }) {
+        let candidates = fragments.maybeApplyingAtType(parentType);
+        if (fragmentFilter) {
+            candidates = candidates.filter(fragmentFilter);
+        }
+        let shouldTryAgain;
+        do {
+            const { spread, optimizedSelection, hasDiff } = this.tryOptimizeSubselectionOnce({ parentType, subSelection, candidates, fragments });
+            if (optimizedSelection) {
+                subSelection = optimizedSelection;
+            }
+            else if (spread) {
+                return spread;
+            }
+            shouldTryAgain = !!spread && !!hasDiff;
+            if (shouldTryAgain) {
+                candidates = candidates.filter((c) => c !== (spread === null || spread === void 0 ? void 0 : spread.namedFragment));
+            }
+        } while (shouldTryAgain);
+        return subSelection;
+    }
 }
 class FieldSelection extends AbstractSelection {
     constructor(field, _selectionSet) {
@@ -1251,20 +1329,36 @@ class FieldSelection extends AbstractSelection {
         return this.element.key();
     }
     optimize(fragments) {
-        const optimizedSelection = this.selectionSet ? this.selectionSet.optimize(fragments) : undefined;
+        let optimizedSelection = this.selectionSet ? this.selectionSet.optimize(fragments) : undefined;
         const fieldBaseType = (0, definitions_1.baseType)(this.element.definition.type);
         if ((0, definitions_1.isCompositeType)(fieldBaseType) && optimizedSelection) {
-            for (const candidate of fragments.maybeApplyingAtType(fieldBaseType)) {
-                if (optimizedSelection.equals(candidate.selectionSet)) {
-                    const fragmentSelection = new FragmentSpreadSelection(fieldBaseType, fragments, candidate, []);
-                    return new FieldSelection(this.element, selectionSetOf(fieldBaseType, fragmentSelection));
-                }
-            }
+            const optimized = this.tryOptimizeSubselectionWithFragments({
+                parentType: fieldBaseType,
+                subSelection: optimizedSelection,
+                fragments,
+                fragmentFilter: (f) => f.appliedDirectives.length === 0,
+            });
+            (0, utils_1.assert)(!(optimized instanceof FragmentSpreadSelection), 'tryOptimizeSubselectionOnce should never return only a spread');
+            optimizedSelection = optimized;
         }
         return this.selectionSet === optimizedSelection
             ? this
             : new FieldSelection(this.element, optimizedSelection);
     }
+    tryOptimizeSubselectionOnce({ parentType, subSelection, candidates, fragments, }) {
+        let optimizedSelection = subSelection;
+        for (const candidate of candidates) {
+            const { contains, diff } = optimizedSelection.diffIfContains(candidate.selectionSet);
+            if (contains) {
+                const spread = new FragmentSpreadSelection(parentType, fragments, candidate, []);
+                optimizedSelection = diff
+                    ? new SelectionSetUpdates().add(spread).add(diff).toSelectionSet(parentType, fragments)
+                    : selectionSetOf(parentType, spread);
+                return { spread, optimizedSelection, hasDiff: !!diff };
+            }
+        }
+        return {};
+    }
     filter(predicate) {
         if (!this.selectionSet) {
             return predicate(this) ? this : undefined;
@@ -1378,6 +1472,9 @@ class FieldSelection extends AbstractSelection {
         }
         return !!this.selectionSet && this.selectionSet.contains(that.selectionSet);
     }
+    isUnecessaryInlineFragment(_) {
+        return false;
+    }
     toString(expandFragments = true, indent) {
         return (indent !== null && indent !== void 0 ? indent : '') + this.element + (this.selectionSet ? ' ' + this.selectionSet.toString(expandFragments, true, indent) : '');
     }
@@ -1409,18 +1506,11 @@ class FragmentSelection extends AbstractSelection {
     hasDefer() {
         return this.element.hasDefer() || this.selectionSet.hasDefer();
     }
-    equals(that) {
-        if (this === that) {
-            return true;
-        }
-        return (that instanceof FragmentSelection)
-            && this.element.equals(that.element)
-            && this.selectionSet.equals(that.selectionSet);
-    }
-    contains(that) {
-        return (that instanceof FragmentSelection)
-            && this.element.equals(that.element)
-            && this.selectionSet.contains(that.selectionSet);
+    isUnecessaryInlineFragment(parentType) {
+        return this.element.appliedDirectives.length === 0
+            && !!this.element.typeCondition
+            && (this.element.typeCondition.name === parentType.name
+                || ((0, definitions_1.isObjectType)(parentType) && (0, definitions_1.possibleRuntimeTypes)(this.element.typeCondition).some((t) => t.name === parentType.name)));
     }
 }
 exports.FragmentSelection = FragmentSelection;
@@ -1488,28 +1578,49 @@ class InlineFragmentSelection extends FragmentSelection {
         let optimizedSelection = this.selectionSet.optimize(fragments);
         const typeCondition = this.element.typeCondition;
         if (typeCondition) {
-            for (const candidate of fragments.maybeApplyingAtType(typeCondition)) {
-                if (optimizedSelection.equals(candidate.selectionSet)) {
-                    let spreadDirectives = [];
-                    if (this.element.appliedDirectives) {
+            const optimized = this.tryOptimizeSubselectionWithFragments({
+                parentType: typeCondition,
+                subSelection: optimizedSelection,
+                fragments,
+            });
+            if (optimized instanceof FragmentSpreadSelection) {
+                return optimized;
+            }
+            optimizedSelection = optimized;
+        }
+        return this.selectionSet === optimizedSelection
+            ? this
+            : new InlineFragmentSelection(this.element, optimizedSelection);
+    }
+    tryOptimizeSubselectionOnce({ parentType, subSelection, candidates, fragments, }) {
+        let optimizedSelection = subSelection;
+        for (const candidate of candidates) {
+            const { contains, diff } = optimizedSelection.diffIfContains(candidate.selectionSet);
+            if (contains) {
+                if (!diff && (0, types_1.sameType)(this.element.typeCondition, candidate.typeCondition)) {
+                    let spreadDirectives = this.element.appliedDirectives;
+                    if (candidate.appliedDirectives.length > 0) {
                         const { isSubset, difference } = diffDirectives(this.element.appliedDirectives, candidate.appliedDirectives);
                         if (!isSubset) {
                             continue;
                         }
                         spreadDirectives = difference;
                     }
-                    const newSelection = new FragmentSpreadSelection(this.parentType, fragments, candidate, spreadDirectives);
-                    if ((0, types_1.sameType)(typeCondition, candidate.typeCondition)) {
-                        return newSelection;
-                    }
-                    optimizedSelection = selectionSetOf(this.parentType, newSelection);
-                    break;
+                    return {
+                        spread: new FragmentSpreadSelection(this.parentType, fragments, candidate, spreadDirectives),
+                    };
+                }
+                if (candidate.appliedDirectives.length > 0) {
+                    continue;
                 }
+                const spread = new FragmentSpreadSelection(parentType, fragments, candidate, []);
+                optimizedSelection = diff
+                    ? new SelectionSetUpdates().add(spread).add(diff).toSelectionSet(parentType, fragments)
+                    : selectionSetOf(parentType, spread);
+                return { spread, optimizedSelection, hasDiff: !!diff };
             }
         }
-        return this.selectionSet === optimizedSelection
-            ? this
-            : new InlineFragmentSelection(this.element, optimizedSelection);
+        return {};
     }
     withoutDefer(labelsToRemove) {
         const newSelection = this.selectionSet.withoutDefer(labelsToRemove);
@@ -1543,7 +1654,7 @@ class InlineFragmentSelection extends FragmentSelection {
                 return trimmed.isEmpty() ? undefined : trimmed;
             }
             if ((0, definitions_1.isObjectType)(currentType)) {
-                if ((0, definitions_1.isObjectType)(thisCondition)) {
+                if ((0, definitions_1.isObjectType)(thisCondition) || !(0, definitions_1.possibleRuntimeTypes)(thisCondition).includes(currentType)) {
                     return undefined;
                 }
                 else {
@@ -1591,6 +1702,19 @@ class InlineFragmentSelection extends FragmentSelection {
     expandFragments(names, updatedFragments) {
         return this.mapToSelectionSet((s) => s.expandFragments(names, updatedFragments));
     }
+    equals(that) {
+        if (this === that) {
+            return true;
+        }
+        return (that instanceof FragmentSelection)
+            && this.element.equals(that.element)
+            && this.selectionSet.equals(that.selectionSet);
+    }
+    contains(that) {
+        return (that instanceof FragmentSelection)
+            && this.element.equals(that.element)
+            && this.selectionSet.contains(that.selectionSet);
+    }
     toString(expandFragments = true, indent) {
         return (indent !== null && indent !== void 0 ? indent : '') + this.element + ' ' + this.selectionSet.toString(expandFragments, true, indent);
     }
@@ -1685,6 +1809,26 @@ class FragmentSpreadSelection extends FragmentSelection {
     withNormalizedDefer(_normalizer) {
         (0, utils_1.assert)(false, 'Unsupported, see `Operation.withAllDeferLabelled`');
     }
+    minus(that) {
+        (0, utils_1.assert)(this.equals(that), () => `Invalid operation for ${this.toString(false)} and ${that.toString(false)}`);
+        return undefined;
+    }
+    equals(that) {
+        if (this === that) {
+            return true;
+        }
+        return (that instanceof FragmentSpreadSelection)
+            && this.namedFragment.name === that.namedFragment.name
+            && (0, definitions_1.sameDirectiveApplications)(this.spreadDirectives, that.spreadDirectives);
+    }
+    contains(that) {
+        if (this.equals(that)) {
+            return true;
+        }
+        return (that instanceof FragmentSelection)
+            && this.element.equals(that.element)
+            && this.selectionSet.contains(that.selectionSet);
+    }
     toString(expandFragments = true, indent) {
         if (expandFragments) {
             return (indent !== null && indent !== void 0 ? indent : '') + this.element + ' ' + this.selectionSet.toString(true, true, indent);