@apollo/federation-internals 2.4.1 → 2.4.3

package/dist/operations.js

@@ -437,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) {
@@ -465,8 +465,11 @@ class Operation {
             }
         }
         const toDeoptimize = (0, utils_1.mapEntries)(usages).filter(([_, count]) => count < minUsagesToOptimize).map(([name]) => name);
-        const newFragments = (_a = optimizedSelection.fragments) === null || _a === void 0 ? void 0 : _a.without(toDeoptimize);
-        optimizedSelection = optimizedSelection.expandFragments(toDeoptimize, newFragments);
+        if (toDeoptimize.length > 0) {
+            const newFragments = (_a = optimizedSelection.fragments) === null || _a === void 0 ? void 0 : _a.without(toDeoptimize);
+            optimizedSelection = optimizedSelection.expandFragments(toDeoptimize, newFragments);
+            optimizedSelection = optimizedSelection.trimUnsatisfiableBranches(optimizedSelection.parentType);
+        }
         return new Operation(this.schema, this.rootKind, optimizedSelection, this.variableDefinitions, this.name);
     }
     expandAllFragments() {
@@ -525,9 +528,11 @@ class NamedFragmentDefinition extends definitions_1.DirectiveTargetElement {
         super(schema, directives);
         this.name = name;
         this.typeCondition = typeCondition;
+        this.selectionSetsAtTypesCache = new Map();
     }
     setSelectionSet(selectionSet) {
         (0, utils_1.assert)(!this._selectionSet, 'Attempting to set the selection set of a fragment definition already built');
+        (0, utils_1.assert)(selectionSet.parentType === this.typeCondition, `Fragment selection set parent is ${selectionSet.parentType} differs from the fragment condition type ${this.typeCondition}`);
         this._selectionSet = selectionSet;
         return this;
     }
@@ -559,25 +564,21 @@ class NamedFragmentDefinition extends definitions_1.DirectiveTargetElement {
         };
     }
     canApplyAtType(type) {
-        const applyAtType = (0, types_1.sameType)(type, this.typeCondition) || (0, definitions_1.runtimeTypesIntersects)(type, this.typeCondition);
-        return applyAtType
-            && this.validForSchema(type.schema());
+        return (0, types_1.sameType)(type, this.typeCondition) || (0, definitions_1.runtimeTypesIntersects)(type, this.typeCondition);
     }
-    validForSchema(schema) {
-        if (schema === this.schema()) {
-            return true;
+    selectionSetAtType(type) {
+        if ((0, types_1.sameType)(type, this.typeCondition) || (0, definitions_1.isObjectType)(this.typeCondition)) {
+            return this.selectionSet;
         }
-        const typeInSchema = schema.type(this.typeCondition.name);
-        if (!typeInSchema || !(0, definitions_1.isCompositeType)(typeInSchema)) {
-            return false;
+        if (!(0, definitions_1.isObjectType)(type)) {
+            return this.selectionSet;
         }
-        try {
-            this.selectionSet.rebaseOn(typeInSchema);
-            return true;
-        }
-        catch (e) {
-            return false;
+        let selectionSet = this.selectionSetsAtTypesCache.get(type.name);
+        if (!selectionSet) {
+            selectionSet = this.selectionSet.trimUnsatisfiableBranches(type, { recursive: false });
+            this.selectionSetsAtTypesCache.set(type.name, selectionSet);
         }
+        return selectionSet;
     }
     toString(indent) {
         return (indent !== null && indent !== void 0 ? indent : '') + `fragment ${this.name} on ${this.typeCondition}${this.appliedDirectivesToString()} ${this.selectionSet.toString(false, true, indent)}`;
@@ -640,6 +641,46 @@ class NamedFragments {
         }
         return mapped;
     }
+    mapToExpandedSelectionSets(mapper, recreateFct = (f, s) => f.withUpdatedSelectionSet(s)) {
+        const fragmentsMap = new Map();
+        const removedFragments = new Set();
+        for (const fragment of this.definitions()) {
+            const mappedSelectionSet = mapper(fragment.selectionSet.expandAllFragments().trimUnsatisfiableBranches(fragment.typeCondition));
+            if (!mappedSelectionSet) {
+                removedFragments.add(fragment.name);
+                continue;
+            }
+            const otherFragmentsUsages = new Map();
+            fragment.collectUsedFragmentNames(otherFragmentsUsages);
+            fragmentsMap.set(fragment.name, {
+                original: fragment,
+                mappedSelectionSet,
+                dependsOn: Array.from(otherFragmentsUsages.keys()),
+            });
+        }
+        const mappedFragments = new NamedFragments();
+        while (fragmentsMap.size > 0) {
+            for (const [name, info] of fragmentsMap) {
+                if (info.dependsOn.every((n) => mappedFragments.has(n) || removedFragments.has(n))) {
+                    const reoptimizedSelectionSet = info.mappedSelectionSet.optimize(mappedFragments);
+                    mappedFragments.add(recreateFct(info.original, reoptimizedSelectionSet));
+                    fragmentsMap.delete(name);
+                }
+            }
+        }
+        return mappedFragments.isEmpty() ? undefined : mappedFragments;
+    }
+    rebaseOn(schema) {
+        return this.mapToExpandedSelectionSets((s) => {
+            const rebasedType = schema.type(s.parentType.name);
+            try {
+                return rebasedType && (0, definitions_1.isCompositeType)(rebasedType) ? s.rebaseOn(rebasedType) : undefined;
+            }
+            catch (e) {
+                return undefined;
+            }
+        }, (orig, newSelection) => new NamedFragmentDefinition(schema, orig.name, newSelection.parentType).setSelectionSet(newSelection));
+    }
     validate(variableDefinitions) {
         for (const fragment of this.fragments.values()) {
             fragment.selectionSet.validate(variableDefinitions);
@@ -755,6 +796,13 @@ class SelectionSet {
         if (!fragments || fragments.isEmpty()) {
             return this;
         }
+        const wrapped = new InlineFragmentSelection(new FragmentElement(this.parentType, this.parentType), this);
+        const optimized = wrapped.optimize(fragments);
+        return optimized instanceof FragmentSpreadSelection
+            ? selectionSetOf(this.parentType, optimized, fragments)
+            : optimized.selectionSet;
+    }
+    optimizeSelections(fragments) {
         (0, utils_1.assert)(!this.fragments || this.fragments.isEmpty(), `Should not be called on selection that already has named fragments, but got ${this.fragments}`);
         return this.lazyMap((selection) => selection.optimize(fragments), { fragments });
     }
@@ -767,8 +815,8 @@ class SelectionSet {
         }
         return this.lazyMap((selection) => selection.expandFragments(names, updatedFragments), { fragments: updatedFragments !== null && updatedFragments !== void 0 ? updatedFragments : null });
     }
-    trimUnsatisfiableBranches(parentType) {
-        return this.lazyMap((selection) => selection.trimUnsatisfiableBranches(parentType), { parentType });
+    trimUnsatisfiableBranches(parentType, options) {
+        return this.lazyMap((selection) => selection.trimUnsatisfiableBranches(parentType, options), { parentType });
     }
     lazyMap(mapper, options) {
         var _a;
@@ -881,9 +929,14 @@ class SelectionSet {
         }
         return true;
     }
-    diffIfContains(that) {
+    diffWithNamedFragmentIfContained(candidate, parentType) {
+        const that = candidate.selectionSetAtType(parentType);
         if (this.contains(that)) {
-            const diff = this.minus(that);
+            let updatedThis = this.expandFragments([candidate.name], this.fragments);
+            if (updatedThis !== this) {
+                updatedThis = updatedThis.trimUnsatisfiableBranches(parentType);
+            }
+            const diff = updatedThis.minus(that);
             return { contains: true, diff: diff.isEmpty() ? undefined : diff };
         }
         return { contains: false };
@@ -1069,9 +1122,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) {
@@ -1321,7 +1382,7 @@ class FieldSelection extends AbstractSelection {
         return this.element.key();
     }
     optimize(fragments) {
-        let optimizedSelection = this.selectionSet ? this.selectionSet.optimize(fragments) : undefined;
+        let optimizedSelection = this.selectionSet ? this.selectionSet.optimizeSelections(fragments) : undefined;
         const fieldBaseType = (0, definitions_1.baseType)(this.element.definition.type);
         if ((0, definitions_1.isCompositeType)(fieldBaseType) && optimizedSelection) {
             const optimized = this.tryOptimizeSubselectionWithFragments({
@@ -1340,7 +1401,7 @@ class FieldSelection extends AbstractSelection {
     tryOptimizeSubselectionOnce({ parentType, subSelection, candidates, fragments, }) {
         let optimizedSelection = subSelection;
         for (const candidate of candidates) {
-            const { contains, diff } = optimizedSelection.diffIfContains(candidate.selectionSet);
+            const { contains, diff } = optimizedSelection.diffWithNamedFragmentIfContained(candidate, parentType);
             if (contains) {
                 const spread = new FragmentSpreadSelection(parentType, fragments, candidate, []);
                 optimizedSelection = diff
@@ -1425,15 +1486,15 @@ class FieldSelection extends AbstractSelection {
     expandAllFragments() {
         return this.mapToSelectionSet((s) => s.expandAllFragments());
     }
-    trimUnsatisfiableBranches(_) {
-        var _a;
+    trimUnsatisfiableBranches(_, options) {
+        var _a, _b;
         if (!this.selectionSet) {
             return this;
         }
         const base = (0, definitions_1.baseType)(this.element.definition.type);
         (0, utils_1.assert)((0, definitions_1.isCompositeType)(base), () => `Field ${this.element} should not have a sub-selection`);
-        const trimmed = this.mapToSelectionSet((s) => s.trimUnsatisfiableBranches(base));
-        if ((_a = trimmed.selectionSet) === null || _a === void 0 ? void 0 : _a.isEmpty()) {
+        const trimmed = ((_a = options === null || options === void 0 ? void 0 : options.recursive) !== null && _a !== void 0 ? _a : true) ? this.mapToSelectionSet((s) => s.trimUnsatisfiableBranches(base)) : this;
+        if ((_b = trimmed.selectionSet) === null || _b === void 0 ? void 0 : _b.isEmpty()) {
             return trimmed.withUpdatedSelectionSet(selectionSetOfElement(new Field(base.typenameField(), undefined, [new definitions_1.Directive('include', { 'if': false })])));
         }
         else {
@@ -1567,7 +1628,7 @@ class InlineFragmentSelection extends FragmentSelection {
         };
     }
     optimize(fragments) {
-        let optimizedSelection = this.selectionSet.optimize(fragments);
+        let optimizedSelection = this.selectionSet.optimizeSelections(fragments);
         const typeCondition = this.element.typeCondition;
         if (typeCondition) {
             const optimized = this.tryOptimizeSubselectionWithFragments({
@@ -1587,7 +1648,7 @@ class InlineFragmentSelection extends FragmentSelection {
     tryOptimizeSubselectionOnce({ parentType, subSelection, candidates, fragments, }) {
         let optimizedSelection = subSelection;
         for (const candidate of candidates) {
-            const { contains, diff } = optimizedSelection.diffIfContains(candidate.selectionSet);
+            const { contains, diff } = optimizedSelection.diffWithNamedFragmentIfContained(candidate, parentType);
             if (contains) {
                 if (!diff && (0, types_1.sameType)(this.element.typeCondition, candidate.typeCondition)) {
                     let spreadDirectives = this.element.appliedDirectives;
@@ -1637,12 +1698,13 @@ class InlineFragmentSelection extends FragmentSelection {
             ? this
             : this.withUpdatedComponents(newElement, newSelection);
     }
-    trimUnsatisfiableBranches(currentType) {
-        var _a, _b;
+    trimUnsatisfiableBranches(currentType, options) {
+        var _a, _b, _c;
+        const recursive = (_a = options === null || options === void 0 ? void 0 : options.recursive) !== null && _a !== void 0 ? _a : true;
         const thisCondition = this.element.typeCondition;
         if (this.element.appliedDirectives.length === 0) {
             if (!thisCondition || currentType === this.element.typeCondition) {
-                const trimmed = this.selectionSet.trimUnsatisfiableBranches(currentType);
+                const trimmed = this.selectionSet.trimUnsatisfiableBranches(currentType, options);
                 return trimmed.isEmpty() ? undefined : trimmed;
             }
             if ((0, definitions_1.isObjectType)(currentType)) {
@@ -1650,18 +1712,21 @@ class InlineFragmentSelection extends FragmentSelection {
                     return undefined;
                 }
                 else {
-                    const trimmed = this.selectionSet.trimUnsatisfiableBranches(currentType);
+                    const trimmed = this.selectionSet.trimUnsatisfiableBranches(currentType, options);
                     return trimmed.isEmpty() ? undefined : trimmed;
                 }
             }
         }
-        const trimmedSelectionSet = this.selectionSet.trimUnsatisfiableBranches((_a = this.element.typeCondition) !== null && _a !== void 0 ? _a : this.parentType);
+        if (!recursive) {
+            return this;
+        }
+        const trimmedSelectionSet = this.selectionSet.trimUnsatisfiableBranches((_b = this.element.typeCondition) !== null && _b !== void 0 ? _b : this.parentType);
         if (trimmedSelectionSet.isEmpty()) {
             if (this.element.appliedDirectives.length === 0) {
                 return undefined;
             }
             else {
-                return this.withUpdatedSelectionSet(selectionSetOfElement(new Field(((_b = this.element.typeCondition) !== null && _b !== void 0 ? _b : this.parentType).typenameField(), undefined, [new definitions_1.Directive('include', { 'if': false })])));
+                return this.withUpdatedSelectionSet(selectionSetOfElement(new Field(((_c = this.element.typeCondition) !== null && _c !== void 0 ? _c : this.parentType).typenameField(), undefined, [new definitions_1.Directive('include', { 'if': false })])));
             }
         }
         if (this.element.appliedDirectives.length === 0 && (0, definitions_1.isAbstractType)(thisCondition)) {