@apollo/federation-internals 2.4.5 → 2.4.7

package/dist/operations.js

@@ -1,6 +1,6 @@
 "use strict";
 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;
+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.ContainsResult = 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");
@@ -75,7 +75,10 @@ class Field extends AbstractOperationElement {
         return this.definition.parent;
     }
     isLeafField() {
-        return (0, definitions_1.isLeafType)((0, definitions_1.baseType)(this.definition.type));
+        return (0, definitions_1.isLeafType)(this.baseType());
+    }
+    baseType() {
+        return (0, definitions_1.baseType)(this.definition.type);
     }
     withUpdatedDefinition(newDefinition) {
         const newField = new Field(newDefinition, this.args, this.appliedDirectives, this.alias);
@@ -431,7 +434,7 @@ function concatOperationPaths(head, tail) {
 exports.concatOperationPaths = concatOperationPaths;
 function isUselessFollowupElement(first, followup, conditionals) {
     const typeOfFirst = first.kind === 'Field'
-        ? (0, definitions_1.baseType)(first.definition.type)
+        ? first.baseType()
         : first.typeCondition;
     return !!typeOfFirst
         && followup.kind === 'FragmentElement'
@@ -439,16 +442,92 @@ function isUselessFollowupElement(first, followup, conditionals) {
         && (followup.appliedDirectives.length === 0 || (0, definitions_1.isDirectiveApplicationsSubset)(conditionals, followup.appliedDirectives))
         && (0, types_1.isSubtype)(followup.typeCondition, typeOfFirst);
 }
+function computeFragmentsDependents(fragments) {
+    const reverseDeps = new utils_1.SetMultiMap();
+    for (const fragment of fragments.definitions()) {
+        for (const dependency of fragment.fragmentUsages().keys()) {
+            reverseDeps.add(dependency, fragment.name);
+        }
+    }
+    return reverseDeps;
+}
+function clearKeptFragments(usages, fragments, minUsagesToOptimize) {
+    let toCheck = Array.from(usages.entries()).filter(([_, count]) => count >= minUsagesToOptimize).map(([name, _]) => name);
+    while (toCheck.length > 0) {
+        const newToCheck = [];
+        for (const name of toCheck) {
+            usages.delete(name);
+            const ownUsages = fragments.get(name).fragmentUsages();
+            for (const [otherName, otherCount] of ownUsages.entries()) {
+                const prevCount = usages.get(otherName);
+                if (prevCount !== undefined) {
+                    const newCount = prevCount + otherCount;
+                    usages.set(otherName, newCount);
+                    if (prevCount < minUsagesToOptimize && newCount >= minUsagesToOptimize) {
+                        newToCheck.push(otherName);
+                    }
+                }
+            }
+        }
+        toCheck = newToCheck;
+    }
+}
+function computeFragmentsToKeep(selectionSet, fragments, minUsagesToOptimize) {
+    const usages = new Map();
+    selectionSet.collectUsedFragmentNames(usages);
+    if (usages.size === 0) {
+        return null;
+    }
+    for (const fragment of fragments.definitions()) {
+        if (usages.get(fragment.name) === undefined) {
+            usages.set(fragment.name, 0);
+        }
+    }
+    const reverseDependencies = computeFragmentsDependents(fragments);
+    const toExpand = new Set;
+    let shouldContinue = true;
+    while (shouldContinue) {
+        shouldContinue = false;
+        clearKeptFragments(usages, fragments, minUsagesToOptimize);
+        for (const name of (0, utils_1.mapKeys)(usages)) {
+            const count = usages.get(name);
+            if (count === 0) {
+                continue;
+            }
+            if (count >= minUsagesToOptimize) {
+                shouldContinue = true;
+                break;
+            }
+            const fragmentsUsingName = reverseDependencies.get(name);
+            if (!fragmentsUsingName || [...fragmentsUsingName].every((fragName) => toExpand.has(fragName) || !usages.get(fragName))) {
+                toExpand.add(name);
+                usages.delete(name);
+                shouldContinue = true;
+                const nameUsages = fragments.get(name).fragmentUsages();
+                for (const [otherName, otherCount] of nameUsages.entries()) {
+                    const prev = usages.get(otherName);
+                    if (prev !== undefined) {
+                        usages.set(otherName, prev + count * otherCount);
+                    }
+                }
+            }
+        }
+    }
+    for (const name of usages.keys()) {
+        toExpand.add(name);
+    }
+    return toExpand.size === 0 ? fragments : fragments.filter((f) => !toExpand.has(f.name));
+}
 class Operation {
-    constructor(schema, rootKind, selectionSet, variableDefinitions, name) {
+    constructor(schema, rootKind, selectionSet, variableDefinitions, fragments, name) {
         this.schema = schema;
         this.rootKind = rootKind;
         this.selectionSet = selectionSet;
         this.variableDefinitions = variableDefinitions;
+        this.fragments = fragments;
         this.name = name;
     }
     optimize(fragments, minUsagesToOptimize = 2) {
-        var _a;
         (0, utils_1.assert)(minUsagesToOptimize >= 1, `Expected 'minUsagesToOptimize' to be at least 1, but got ${minUsagesToOptimize}`);
         if (!fragments || fragments.isEmpty()) {
             return this;
@@ -457,50 +536,41 @@ class Operation {
         if (optimizedSelection === this.selectionSet) {
             return this;
         }
-        const usages = new Map();
-        optimizedSelection.collectUsedFragmentNames(usages);
-        for (const fragment of fragments.names()) {
-            if (!usages.has(fragment)) {
-                usages.set(fragment, 0);
-            }
-        }
-        const toDeoptimize = (0, utils_1.mapEntries)(usages).filter(([_, count]) => count < minUsagesToOptimize).map(([name]) => name);
-        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);
+        const finalFragments = computeFragmentsToKeep(optimizedSelection, fragments, minUsagesToOptimize);
+        if (finalFragments === null || (finalFragments === null || finalFragments === void 0 ? void 0 : finalFragments.size) === fragments.size) {
+            return new Operation(this.schema, this.rootKind, optimizedSelection, this.variableDefinitions, finalFragments !== null && finalFragments !== void 0 ? finalFragments : undefined, this.name);
         }
-        return new Operation(this.schema, this.rootKind, optimizedSelection, this.variableDefinitions, this.name);
+        optimizedSelection = optimizedSelection.expandFragments(finalFragments);
+        optimizedSelection = optimizedSelection.trimUnsatisfiableBranches(optimizedSelection.parentType);
+        return new Operation(this.schema, this.rootKind, optimizedSelection, this.variableDefinitions, finalFragments, this.name);
     }
     expandAllFragments() {
-        const expandedSelections = this.selectionSet.expandAllFragments();
+        const expandedSelections = this.selectionSet.expandFragments();
         if (expandedSelections === this.selectionSet) {
             return this;
         }
-        return new Operation(this.schema, this.rootKind, expandedSelections, this.variableDefinitions, this.name);
+        return new Operation(this.schema, this.rootKind, expandedSelections, this.variableDefinitions, undefined, this.name);
     }
     trimUnsatisfiableBranches() {
         const trimmedSelections = this.selectionSet.trimUnsatisfiableBranches(this.selectionSet.parentType);
         if (trimmedSelections === this.selectionSet) {
             return this;
         }
-        return new Operation(this.schema, this.rootKind, trimmedSelections, this.variableDefinitions, this.name);
+        return new Operation(this.schema, this.rootKind, trimmedSelections, this.variableDefinitions, this.fragments, this.name);
     }
     withoutDefer(labelsToRemove) {
-        (0, utils_1.assert)(!this.selectionSet.fragments || this.selectionSet.fragments.isEmpty(), 'Removing @defer currently only work on "expanded" selections (no named fragments)');
         const updated = this.selectionSet.withoutDefer(labelsToRemove);
         return updated == this.selectionSet
             ? this
-            : new Operation(this.schema, this.rootKind, updated, this.variableDefinitions, this.name);
+            : new Operation(this.schema, this.rootKind, updated, this.variableDefinitions, this.fragments, this.name);
     }
     withNormalizedDefer() {
-        (0, utils_1.assert)(!this.selectionSet.fragments || this.selectionSet.fragments.isEmpty(), 'Assigning @defer lables currently only work on "expanded" selections (no named fragments)');
         const normalizer = new DeferNormalizer();
         const { hasDefers, hasNonLabelledOrConditionalDefers } = normalizer.init(this.selectionSet);
         let updatedOperation = this;
         if (hasNonLabelledOrConditionalDefers) {
             const updated = this.selectionSet.withNormalizedDefer(normalizer);
-            updatedOperation = new Operation(this.schema, this.rootKind, updated, this.variableDefinitions, this.name);
+            updatedOperation = new Operation(this.schema, this.rootKind, updated, this.variableDefinitions, this.fragments, this.name);
         }
         return {
             operation: updatedOperation,
@@ -519,7 +589,7 @@ class Operation {
         return defaultedVariableValues;
     }
     toString(expandFragments = false, prettyPrint = true) {
-        return this.selectionSet.toOperationString(this.rootKind, this.variableDefinitions, this.name, expandFragments, prettyPrint);
+        return this.selectionSet.toOperationString(this.rootKind, this.variableDefinitions, this.fragments, this.name, expandFragments, prettyPrint);
     }
 }
 exports.Operation = Operation;
@@ -528,7 +598,7 @@ class NamedFragmentDefinition extends definitions_1.DirectiveTargetElement {
         super(schema, directives);
         this.name = name;
         this.typeCondition = typeCondition;
-        this.selectionSetsAtTypesCache = new Map();
+        this.expandedSelectionSetsAtTypesCache = new Map();
     }
     setSelectionSet(selectionSet) {
         (0, utils_1.assert)(!this._selectionSet, 'Attempting to set the selection set of a fragment definition already built');
@@ -540,11 +610,28 @@ class NamedFragmentDefinition extends definitions_1.DirectiveTargetElement {
         (0, utils_1.assert)(this._selectionSet, () => `Trying to access fragment definition ${this.name} before it is fully built`);
         return this._selectionSet;
     }
+    expandedSelectionSet() {
+        if (!this._expandedSelectionSet) {
+            this._expandedSelectionSet = this.selectionSet.expandFragments().trimUnsatisfiableBranches(this.typeCondition);
+        }
+        return this._expandedSelectionSet;
+    }
     withUpdatedSelectionSet(newSelectionSet) {
         return new NamedFragmentDefinition(this.schema(), this.name, this.typeCondition).setSelectionSet(newSelectionSet);
     }
+    fragmentUsages() {
+        if (!this._fragmentUsages) {
+            this._fragmentUsages = new Map();
+            this.selectionSet.collectUsedFragmentNames(this._fragmentUsages);
+        }
+        return this._fragmentUsages;
+    }
     collectUsedFragmentNames(collector) {
-        this.selectionSet.collectUsedFragmentNames(collector);
+        const usages = this.fragmentUsages();
+        for (const [name, count] of usages.entries()) {
+            const prevCount = collector.get(name);
+            collector.set(name, prevCount ? prevCount + count : count);
+        }
     }
     toFragmentDefinitionNode() {
         return {
@@ -564,21 +651,49 @@ class NamedFragmentDefinition extends definitions_1.DirectiveTargetElement {
         };
     }
     canApplyAtType(type) {
-        return (0, types_1.sameType)(type, this.typeCondition) || (0, definitions_1.runtimeTypesIntersects)(type, this.typeCondition);
+        if ((0, types_1.sameType)(type, this.typeCondition)) {
+            return true;
+        }
+        if (!(0, definitions_1.isAbstractType)(this.typeCondition)) {
+            return false;
+        }
+        const conditionRuntimes = (0, definitions_1.possibleRuntimeTypes)(this.typeCondition);
+        const typeRuntimes = (0, definitions_1.possibleRuntimeTypes)(type);
+        return conditionRuntimes.length >= typeRuntimes.length
+            && typeRuntimes.every((t1) => conditionRuntimes.some((t2) => (0, types_1.sameType)(t1, t2)));
     }
-    selectionSetAtType(type) {
+    expandedSelectionSetAtType(type) {
+        const expandedSelectionSet = this.expandedSelectionSet();
         if ((0, types_1.sameType)(type, this.typeCondition) || (0, definitions_1.isObjectType)(this.typeCondition)) {
-            return this.selectionSet;
+            return expandedSelectionSet;
         }
         if (!(0, definitions_1.isObjectType)(type)) {
-            return this.selectionSet;
+            return expandedSelectionSet;
+        }
+        let selectionAtType = this.expandedSelectionSetsAtTypesCache.get(type.name);
+        if (!selectionAtType) {
+            selectionAtType = expandedSelectionSet.trimUnsatisfiableBranches(type, { recursive: false });
+            this.expandedSelectionSetsAtTypesCache.set(type.name, selectionAtType);
+        }
+        return selectionAtType;
+    }
+    includes(otherFragment) {
+        if (this.name === otherFragment) {
+            return false;
         }
-        let selectionSet = this.selectionSetsAtTypesCache.get(type.name);
-        if (!selectionSet) {
-            selectionSet = this.selectionSet.trimUnsatisfiableBranches(type, { recursive: false });
-            this.selectionSetsAtTypesCache.set(type.name, selectionSet);
+        if (!this._includedFragmentNames) {
+            this._includedFragmentNames = this.computeIncludedFragmentNames();
         }
-        return selectionSet;
+        return this._includedFragmentNames.has(otherFragment);
+    }
+    computeIncludedFragmentNames() {
+        const included = new Set();
+        for (const selection of this.selectionSet.selections()) {
+            if (selection instanceof FragmentSpreadSelection) {
+                included.add(selection.namedFragment.name);
+            }
+        }
+        return included;
     }
     toString(indent) {
         return (indent !== null && indent !== void 0 ? indent : '') + `fragment ${this.name} on ${this.typeCondition}${this.appliedDirectivesToString()} ${this.selectionSet.toString(false, true, indent)}`;
@@ -590,7 +705,10 @@ class NamedFragments {
         this.fragments = new utils_1.MapWithCachedArrays();
     }
     isEmpty() {
-        return this.fragments.size === 0;
+        return this.size === 0;
+    }
+    get size() {
+        return this.fragments.size;
     }
     names() {
         return this.fragments.keys();
@@ -609,22 +727,6 @@ class NamedFragments {
     maybeApplyingAtType(type) {
         return this.fragments.values().filter(f => f.canApplyAtType(type));
     }
-    without(names) {
-        if (!names.some(n => this.fragments.has(n))) {
-            return this;
-        }
-        const newFragments = new NamedFragments();
-        for (const fragment of this.fragments.values()) {
-            if (!names.includes(fragment.name)) {
-                const updatedSelectionSet = fragment.selectionSet.expandFragments(names, newFragments);
-                const newFragment = updatedSelectionSet === fragment.selectionSet
-                    ? fragment
-                    : fragment.withUpdatedSelectionSet(updatedSelectionSet);
-                newFragments.add(newFragment);
-            }
-        }
-        return newFragments.isEmpty() ? undefined : newFragments;
-    }
     get(name) {
         return this.fragments.get(name);
     }
@@ -641,45 +743,70 @@ class NamedFragments {
         }
         return mapped;
     }
-    mapToExpandedSelectionSets(mapper, recreateFct = (f, s) => f.withUpdatedSelectionSet(s)) {
+    mapInDependencyOrder(mapper) {
         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()),
+                fragment,
+                dependsOn: Array.from(fragment.fragmentUsages().keys()),
             });
         }
+        const removedFragments = new Set();
         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));
+                    const mapped = mapper(info.fragment, mappedFragments);
                     fragmentsMap.delete(name);
+                    if (!mapped) {
+                        removedFragments.add(name);
+                    }
+                    else {
+                        mappedFragments.add(mapped);
+                    }
+                    break;
                 }
             }
         }
         return mappedFragments.isEmpty() ? undefined : mappedFragments;
     }
+    mapToExpandedSelectionSets(mapper) {
+        return this.mapInDependencyOrder((fragment, newFragments) => {
+            const mappedSelectionSet = mapper(fragment.selectionSet.expandFragments().trimUnsatisfiableBranches(fragment.typeCondition));
+            if (!mappedSelectionSet) {
+                return undefined;
+            }
+            const reoptimizedSelectionSet = mappedSelectionSet.optimize(newFragments);
+            return fragment.withUpdatedSelectionSet(reoptimizedSelectionSet);
+        });
+    }
     rebaseOn(schema) {
-        return this.mapToExpandedSelectionSets((s) => {
-            const rebasedType = schema.type(s.parentType.name);
+        return this.mapInDependencyOrder((fragment, newFragments) => {
+            const rebasedType = schema.type(fragment.selectionSet.parentType.name);
             try {
-                return rebasedType && (0, definitions_1.isCompositeType)(rebasedType) ? s.rebaseOn(rebasedType) : undefined;
+                if (!rebasedType || !(0, definitions_1.isCompositeType)(rebasedType)) {
+                    return undefined;
+                }
+                const rebasedSelection = fragment.selectionSet.rebaseOn(rebasedType, newFragments);
+                return new NamedFragmentDefinition(schema, fragment.name, rebasedType).setSelectionSet(rebasedSelection);
             }
             catch (e) {
                 return undefined;
             }
-        }, (orig, newSelection) => new NamedFragmentDefinition(schema, orig.name, newSelection.parentType).setSelectionSet(newSelection));
+        });
+    }
+    filter(predicate) {
+        return this.mapInDependencyOrder((fragment, newFragments) => {
+            if (predicate(fragment)) {
+                const updatedSelectionSet = fragment.selectionSet.expandFragments(newFragments);
+                return updatedSelectionSet === fragment.selectionSet
+                    ? fragment
+                    : fragment.withUpdatedSelectionSet(updatedSelectionSet);
+            }
+            else {
+                return undefined;
+            }
+        });
     }
     validate(variableDefinitions) {
         for (const fragment of this.fragments.values()) {
@@ -740,10 +867,15 @@ class DeferNormalizer {
         this.deferConditions.add(condition.name, label);
     }
 }
+var ContainsResult;
+(function (ContainsResult) {
+    ContainsResult[ContainsResult["NOT_CONTAINED"] = 0] = "NOT_CONTAINED";
+    ContainsResult[ContainsResult["STRICTLY_CONTAINED"] = 1] = "STRICTLY_CONTAINED";
+    ContainsResult[ContainsResult["EQUAL"] = 2] = "EQUAL";
+})(ContainsResult = exports.ContainsResult || (exports.ContainsResult = {}));
 class SelectionSet {
-    constructor(parentType, keyedSelections = new Map(), fragments) {
+    constructor(parentType, keyedSelections = new Map()) {
         this.parentType = parentType;
-        this.fragments = fragments;
         this._keyedSelections = keyedSelections;
         this._selections = (0, utils_1.mapValues)(keyedSelections);
     }
@@ -799,21 +931,14 @@ class SelectionSet {
         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)
+            ? selectionSetOf(this.parentType, optimized)
             : 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 });
-    }
-    expandAllFragments() {
-        return this.lazyMap((selection) => selection.expandAllFragments(), { fragments: null });
+        return this.lazyMap((selection) => selection.optimize(fragments));
     }
-    expandFragments(names, updatedFragments) {
-        if (names.length === 0) {
-            return this;
-        }
-        return this.lazyMap((selection) => selection.expandFragments(names, updatedFragments), { fragments: updatedFragments !== null && updatedFragments !== void 0 ? updatedFragments : null });
+    expandFragments(updatedFragments) {
+        return this.lazyMap((selection) => selection.expandFragments(updatedFragments));
     }
     trimUnsatisfiableBranches(parentType, options) {
         return this.lazyMap((selection) => selection.trimUnsatisfiableBranches(parentType, options), { parentType });
@@ -821,8 +946,6 @@ class SelectionSet {
     lazyMap(mapper, options) {
         var _a;
         const selections = this.selections();
-        const updatedFragments = options === null || options === void 0 ? void 0 : options.fragments;
-        const newFragments = updatedFragments === undefined ? this.fragments : (updatedFragments !== null && updatedFragments !== void 0 ? updatedFragments : undefined);
         let updatedSelections = undefined;
         for (let i = 0; i < selections.length; i++) {
             const selection = selections[i];
@@ -838,19 +961,14 @@ class SelectionSet {
             }
         }
         if (!updatedSelections) {
-            return this.withUpdatedFragments(newFragments);
+            return this;
         }
-        return updatedSelections.toSelectionSet((_a = options === null || options === void 0 ? void 0 : options.parentType) !== null && _a !== void 0 ? _a : this.parentType, newFragments);
-    }
-    withUpdatedFragments(newFragments) {
-        return this.fragments === newFragments ? this : new SelectionSet(this.parentType, this._keyedSelections, newFragments);
+        return updatedSelections.toSelectionSet((_a = options === null || options === void 0 ? void 0 : options.parentType) !== null && _a !== void 0 ? _a : this.parentType);
     }
     withoutDefer(labelsToRemove) {
-        (0, utils_1.assert)(!this.fragments, 'Not yet supported');
         return this.lazyMap((selection) => selection.withoutDefer(labelsToRemove));
     }
     withNormalizedDefer(normalizer) {
-        (0, utils_1.assert)(!this.fragments, 'Not yet supported');
         return this.lazyMap((selection) => selection.withNormalizedDefer(normalizer));
     }
     hasDefer() {
@@ -863,15 +981,15 @@ class SelectionSet {
         const updated = this.filter((selection) => { var _a; return ((_a = selection.selectionSet) === null || _a === void 0 ? void 0 : _a.isEmpty()) !== true; });
         return updated.isEmpty() ? undefined : updated;
     }
-    rebaseOn(parentType) {
+    rebaseOn(parentType, fragments) {
         if (this.parentType === parentType) {
             return this;
         }
         const newSelections = new Map();
         for (const selection of this.selections()) {
-            newSelections.set(selection.key(), selection.rebaseOn(parentType));
+            newSelections.set(selection.key(), selection.rebaseOn(parentType, fragments));
         }
-        return new SelectionSet(parentType, newSelections, this.fragments);
+        return new SelectionSet(parentType, newSelections);
     }
     equals(that) {
         if (this === that) {
@@ -888,51 +1006,30 @@ class SelectionSet {
         }
         return true;
     }
-    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) {
+        if (that._selections.length > this._selections.length) {
+            return ContainsResult.NOT_CONTAINED;
+        }
+        let isEqual = true;
         for (const [key, thatSelection] of that._keyedSelections) {
             const thisSelection = this._keyedSelections.get(key);
-            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;
+            const selectionResult = thisSelection === null || thisSelection === void 0 ? void 0 : thisSelection.contains(thatSelection);
+            if (selectionResult === undefined || selectionResult === ContainsResult.NOT_CONTAINED) {
+                return ContainsResult.NOT_CONTAINED;
             }
+            isEqual && (isEqual = selectionResult === ContainsResult.EQUAL);
         }
-        return true;
+        return isEqual && that._selections.length === this._selections.length
+            ? ContainsResult.EQUAL
+            : ContainsResult.STRICTLY_CONTAINED;
     }
-    diffWithNamedFragmentIfContained(candidate, parentType) {
-        const that = candidate.selectionSetAtType(parentType);
+    diffWithNamedFragmentIfContained(candidate, parentType, fragments) {
+        const that = candidate.expandedSelectionSetAtType(parentType);
+        if (that.isEmpty() || (that.selections().length === 1 && that.selections()[0].isTypenameField())) {
+            return { contains: false };
+        }
         if (this.contains(that)) {
-            let updatedThis = this.expandFragments([candidate.name], this.fragments);
+            let updatedThis = this.expandFragments(fragments.filter((f) => f.name !== candidate.name));
             if (updatedThis !== this) {
                 updatedThis = updatedThis.trimUnsatisfiableBranches(parentType);
             }
@@ -945,19 +1042,17 @@ class SelectionSet {
         const updated = new SelectionSetUpdates();
         for (const [key, thisSelection] of this._keyedSelections) {
             const thatSelection = that._keyedSelections.get(key);
-            const otherSelections = that.triviallyNestedSelectionsForKey(this.parentType, key);
-            const allSelections = thatSelection ? [thatSelection].concat(otherSelections) : otherSelections;
-            if (allSelections.length === 0) {
-                updated.add(thisSelection);
+            if (thatSelection) {
+                const remainder = thisSelection.minus(thatSelection);
+                if (remainder) {
+                    updated.add(remainder);
+                }
             }
             else {
-                const selectionDiff = allSelections.reduce((prev, val) => prev === null || prev === void 0 ? void 0 : prev.minus(val), thisSelection);
-                if (selectionDiff) {
-                    updated.add(selectionDiff);
-                }
+                updated.add(thisSelection);
             }
         }
-        return updated.toSelectionSet(this.parentType, this.fragments);
+        return updated.toSelectionSet(this.parentType);
     }
     canRebaseOn(parentTypeToTest) {
         return this.selections().every((selection) => selection.canAddTo(parentTypeToTest));
@@ -1027,10 +1122,10 @@ class SelectionSet {
         }
         return false;
     }
-    toOperationString(rootKind, variableDefinitions, operationName, expandFragments = false, prettyPrint = true) {
+    toOperationString(rootKind, variableDefinitions, fragments, operationName, expandFragments = false, prettyPrint = true) {
         const indent = prettyPrint ? '' : undefined;
-        const fragmentsDefinitions = !expandFragments && this.fragments && !this.fragments.isEmpty()
-            ? this.fragments.toString(indent) + "\n\n"
+        const fragmentsDefinitions = !expandFragments && fragments && !fragments.isEmpty()
+            ? fragments.toString(indent) + "\n\n"
             : "";
         if (rootKind == "query" && !operationName && variableDefinitions.isEmpty()) {
             return fragmentsDefinitions + this.toString(expandFragments, true, indent);
@@ -1165,10 +1260,10 @@ function makeSelection(parentType, updates, fragments) {
     (0, utils_1.assert)(updates.length > 0, 'Should not be called without any updates');
     const first = updates[0];
     if (updates.length === 1 && first instanceof AbstractSelection) {
-        return first.rebaseOn(parentType);
+        return first.rebaseOn(parentType, fragments);
     }
     const element = updateElement(first).rebaseOn(parentType);
-    const subSelectionParentType = element.kind === 'Field' ? (0, definitions_1.baseType)(element.definition.type) : element.castedType();
+    const subSelectionParentType = element.kind === 'Field' ? element.baseType() : element.castedType();
     if (!(0, definitions_1.isCompositeType)(subSelectionParentType)) {
         return selectionOfElement(element);
     }
@@ -1204,7 +1299,7 @@ function makeSelectionSet(parentType, keyedUpdates, fragments) {
     for (const [key, updates] of keyedUpdates.entries()) {
         selections.set(key, makeSelection(parentType, updates, fragments));
     }
-    return new SelectionSet(parentType, selections, fragments);
+    return new SelectionSet(parentType, selections);
 }
 class MutableSelectionSet {
     constructor(parentType, _updates, memoizer) {
@@ -1280,14 +1375,14 @@ function allFieldDefinitionsInSelectionSet(selection) {
     return allFields;
 }
 exports.allFieldDefinitionsInSelectionSet = allFieldDefinitionsInSelectionSet;
-function selectionSetOf(parentType, selection, fragments) {
+function selectionSetOf(parentType, selection) {
     const map = new Map();
     map.set(selection.key(), selection);
-    return new SelectionSet(parentType, map, fragments);
+    return new SelectionSet(parentType, map);
 }
 exports.selectionSetOf = selectionSetOf;
-function selectionSetOfElement(element, subSelection, fragments) {
-    return selectionSetOf(element.parentType, selectionOfElement(element, subSelection), fragments);
+function selectionSetOfElement(element, subSelection) {
+    return selectionSetOf(element.parentType, selectionOfElement(element, subSelection));
 }
 exports.selectionSetOfElement = selectionSetOfElement;
 function selectionOfElement(element, subSelection) {
@@ -1301,6 +1396,9 @@ class AbstractSelection {
     get parentType() {
         return this.element.parentType;
     }
+    isTypenameField() {
+        return false;
+    }
     collectVariables(collector) {
         var _a;
         this.element.collectVariables(collector);
@@ -1310,10 +1408,6 @@ class AbstractSelection {
         var _a;
         (_a = this.selectionSet) === null || _a === void 0 ? void 0 : _a.collectUsedFragmentNames(collector);
     }
-    namedFragments() {
-        var _a;
-        return (_a = this.selectionSet) === null || _a === void 0 ? void 0 : _a.fragments;
-    }
     withUpdatedSelectionSet(selectionSet) {
         return this.withUpdatedComponents(this.element, selectionSet);
     }
@@ -1329,6 +1423,9 @@ class AbstractSelection {
             ? this.us()
             : this.withUpdatedSelectionSet(updatedSelectionSet);
     }
+    isFragmentSpread() {
+        return false;
+    }
     minus(that) {
         if (this.selectionSet && that.selectionSet) {
             const updatedSubSelectionSet = this.selectionSet.minus(that.selectionSet);
@@ -1338,29 +1435,38 @@ class AbstractSelection {
         }
         return undefined;
     }
-    tryOptimizeSubselectionOnce(_) {
-        (0, utils_1.assert)(false, `UNSUPPORTED`);
-    }
-    tryOptimizeSubselectionWithFragments({ parentType, subSelection, fragments, fragmentFilter, }) {
+    tryOptimizeSubselectionWithFragments({ parentType, subSelection, fragments, canUseFullMatchingFragment, }) {
         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;
+        const applyingFragments = [];
+        for (const candidate of candidates) {
+            const fragmentSSet = candidate.expandedSelectionSetAtType(parentType);
+            if (fragmentSSet.isEmpty() || (fragmentSSet.selections().length === 1 && fragmentSSet.selections()[0].isTypenameField())) {
+                continue;
             }
-            else if (spread) {
-                return spread;
+            const res = subSelection.contains(fragmentSSet);
+            if (res === ContainsResult.EQUAL) {
+                if (canUseFullMatchingFragment(candidate)) {
+                    return candidate;
+                }
+                if (candidate.appliedDirectives.length === 0) {
+                    applyingFragments.push(candidate);
+                }
             }
-            shouldTryAgain = !!spread && !!hasDiff;
-            if (shouldTryAgain) {
-                candidates = candidates.filter((c) => c !== (spread === null || spread === void 0 ? void 0 : spread.namedFragment));
+            else if (res === ContainsResult.STRICTLY_CONTAINED && candidate.appliedDirectives.length === 0) {
+                applyingFragments.push(candidate);
             }
-        } while (shouldTryAgain);
-        return subSelection;
+        }
+        if (applyingFragments.length === 0) {
+            return subSelection;
+        }
+        const filteredApplyingFragments = applyingFragments.filter((f) => !applyingFragments.some((o) => o.includes(f.name)));
+        let notCoveredByFragments = subSelection;
+        const optimized = new SelectionSetUpdates();
+        for (const fragment of filteredApplyingFragments) {
+            notCoveredByFragments = notCoveredByFragments.minus(fragment.expandedSelectionSetAtType(parentType));
+            optimized.add(new FragmentSpreadSelection(parentType, fragments, fragment, []));
+        }
+        return optimized.add(notCoveredByFragments).toSelectionSet(parentType, fragments);
     }
 }
 class FieldSelection extends AbstractSelection {
@@ -1375,6 +1481,9 @@ class FieldSelection extends AbstractSelection {
     us() {
         return this;
     }
+    isTypenameField() {
+        return this.element.definition.name === definitions_1.typenameFieldName;
+    }
     withUpdatedComponents(field, selectionSet) {
         return new FieldSelection(field, selectionSet);
     }
@@ -1382,35 +1491,29 @@ class FieldSelection extends AbstractSelection {
         return this.element.key();
     }
     optimize(fragments) {
-        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) {
+        if (!(0, definitions_1.isCompositeType)(fieldBaseType) || !this.selectionSet) {
+            return this;
+        }
+        let optimizedSelection = this.selectionSet;
+        if ((0, definitions_1.isCompositeType)(fieldBaseType) && this.selectionSet) {
             const optimized = this.tryOptimizeSubselectionWithFragments({
                 parentType: fieldBaseType,
-                subSelection: optimizedSelection,
+                subSelection: this.selectionSet,
                 fragments,
-                fragmentFilter: (f) => f.appliedDirectives.length === 0,
+                canUseFullMatchingFragment: (fragment) => fragment.appliedDirectives.length === 0,
             });
-            (0, utils_1.assert)(!(optimized instanceof FragmentSpreadSelection), 'tryOptimizeSubselectionOnce should never return only a spread');
-            optimizedSelection = optimized;
+            if (optimized instanceof NamedFragmentDefinition) {
+                optimizedSelection = selectionSetOf(fieldBaseType, new FragmentSpreadSelection(fieldBaseType, fragments, optimized, []));
+            }
+            else {
+                optimizedSelection = optimized;
+            }
         }
+        optimizedSelection = optimizedSelection.optimize(fragments);
         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.diffWithNamedFragmentIfContained(candidate, parentType);
-            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 {};
+            : this.withUpdatedSelectionSet(optimizedSelection);
     }
     filter(predicate) {
         if (!this.selectionSet) {
@@ -1428,7 +1531,7 @@ class FieldSelection extends AbstractSelection {
         validate(this.element.isLeafField() || (this.selectionSet && !this.selectionSet.isEmpty()), () => `Invalid empty selection set for field "${this.element.definition.coordinate}" of non-leaf type ${this.element.definition.type}`, this.element.definition.sourceAST);
         (_a = this.selectionSet) === null || _a === void 0 ? void 0 : _a.validate(variableDefinitions);
     }
-    rebaseOn(parentType) {
+    rebaseOn(parentType, fragments) {
         if (this.element.parentType === parentType) {
             return this;
         }
@@ -1436,12 +1539,12 @@ class FieldSelection extends AbstractSelection {
         if (!this.selectionSet) {
             return this.withUpdatedElement(rebasedElement);
         }
-        const rebasedBase = (0, definitions_1.baseType)(rebasedElement.definition.type);
+        const rebasedBase = rebasedElement.baseType();
         if (rebasedBase === this.selectionSet.parentType) {
             return this.withUpdatedElement(rebasedElement);
         }
         validate((0, definitions_1.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));
+        return this.withUpdatedComponents(rebasedElement, this.selectionSet.rebaseOn(rebasedBase, fragments));
     }
     canAddTo(parentType) {
         if (this.element.parentType === parentType) {
@@ -1483,15 +1586,12 @@ class FieldSelection extends AbstractSelection {
         var _a;
         return !!((_a = this.selectionSet) === null || _a === void 0 ? void 0 : _a.hasDefer());
     }
-    expandAllFragments() {
-        return this.mapToSelectionSet((s) => s.expandAllFragments());
-    }
     trimUnsatisfiableBranches(_, options) {
         var _a, _b;
         if (!this.selectionSet) {
             return this;
         }
-        const base = (0, definitions_1.baseType)(this.element.definition.type);
+        const base = this.element.baseType();
         (0, utils_1.assert)((0, definitions_1.isCompositeType)(base), () => `Field ${this.element} should not have a sub-selection`);
         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()) {
@@ -1501,8 +1601,8 @@ class FieldSelection extends AbstractSelection {
             return trimmed;
         }
     }
-    expandFragments(names, updatedFragments) {
-        return this.mapToSelectionSet((s) => s.expandFragments(names, updatedFragments));
+    expandFragments(updatedFragments) {
+        return this.mapToSelectionSet((s) => s.expandFragments(updatedFragments));
     }
     equals(that) {
         if (this === that) {
@@ -1518,15 +1618,14 @@ class FieldSelection extends AbstractSelection {
     }
     contains(that) {
         if (!(that instanceof FieldSelection) || !this.element.equals(that.element)) {
-            return false;
+            return ContainsResult.NOT_CONTAINED;
         }
-        if (!that.selectionSet) {
-            return true;
+        if (!this.selectionSet) {
+            (0, utils_1.assert)(!that.selectionSet, '`this` and `that` have the same element, so if one does not have a sub-selection, neither should the other one');
+            return ContainsResult.EQUAL;
         }
-        return !!this.selectionSet && this.selectionSet.contains(that.selectionSet);
-    }
-    isUnecessaryInlineFragment(_) {
-        return false;
+        (0, utils_1.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);
     }
     toString(expandFragments = true, indent) {
         return (indent !== null && indent !== void 0 ? indent : '') + this.element + (this.selectionSet ? ' ' + this.selectionSet.toString(expandFragments, true, indent) : '');
@@ -1559,12 +1658,6 @@ class FragmentSelection extends AbstractSelection {
     hasDefer() {
         return this.element.hasDefer() || this.selectionSet.hasDefer();
     }
-    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;
 class InlineFragmentSelection extends FragmentSelection {
@@ -1586,7 +1679,7 @@ class InlineFragmentSelection extends FragmentSelection {
         validate(!this.selectionSet.isEmpty(), () => `Invalid empty selection set for fragment "${this.element}"`);
         this.selectionSet.validate(variableDefinitions);
     }
-    rebaseOn(parentType) {
+    rebaseOn(parentType, fragments) {
         if (this.parentType === parentType) {
             return this;
         }
@@ -1595,7 +1688,7 @@ class InlineFragmentSelection extends FragmentSelection {
         if (rebasedCastedType === this.selectionSet.parentType) {
             return this.withUpdatedElement(rebasedFragment);
         }
-        return this.withUpdatedComponents(rebasedFragment, this.selectionSet.rebaseOn(rebasedCastedType));
+        return this.withUpdatedComponents(rebasedFragment, this.selectionSet.rebaseOn(rebasedCastedType, fragments));
     }
     canAddTo(parentType) {
         if (this.element.parentType === parentType) {
@@ -1628,52 +1721,39 @@ class InlineFragmentSelection extends FragmentSelection {
         };
     }
     optimize(fragments) {
-        let optimizedSelection = this.selectionSet.optimizeSelections(fragments);
+        let optimizedSelection = this.selectionSet;
         const typeCondition = this.element.typeCondition;
         if (typeCondition) {
             const optimized = this.tryOptimizeSubselectionWithFragments({
                 parentType: typeCondition,
                 subSelection: optimizedSelection,
                 fragments,
+                canUseFullMatchingFragment: (fragment) => {
+                    return fragment.appliedDirectives.length === 0
+                        || ((0, types_1.sameType)(typeCondition, fragment.typeCondition)
+                            && fragment.appliedDirectives.every((d) => this.element.appliedDirectives.some((s) => (0, definitions_1.sameDirectiveApplication)(d, s))));
+                },
             });
-            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.diffWithNamedFragmentIfContained(candidate, parentType);
-            if (contains) {
-                if (!diff && (0, types_1.sameType)(this.element.typeCondition, candidate.typeCondition)) {
+            if (optimized instanceof NamedFragmentDefinition) {
+                if ((0, types_1.sameType)(typeCondition, optimized.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;
+                    if (optimized.appliedDirectives) {
+                        spreadDirectives = spreadDirectives.filter((s) => !optimized.appliedDirectives.some((d) => (0, definitions_1.sameDirectiveApplication)(d, s)));
                     }
-                    return {
-                        spread: new FragmentSpreadSelection(this.parentType, fragments, candidate, spreadDirectives),
-                    };
+                    return new FragmentSpreadSelection(this.parentType, fragments, optimized, spreadDirectives);
                 }
-                if (candidate.appliedDirectives.length > 0) {
-                    continue;
+                else {
+                    optimizedSelection = selectionSetOf(typeCondition, new FragmentSpreadSelection(typeCondition, fragments, optimized, []));
                 }
-                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 };
+            }
+            else {
+                optimizedSelection = optimized;
             }
         }
-        return {};
+        optimizedSelection = optimizedSelection.optimizeSelections(fragments);
+        return this.selectionSet === optimizedSelection
+            ? this
+            : new InlineFragmentSelection(this.element, optimizedSelection);
     }
     withoutDefer(labelsToRemove) {
         const newSelection = this.selectionSet.withoutDefer(labelsToRemove);
@@ -1753,11 +1833,8 @@ class InlineFragmentSelection extends FragmentSelection {
         }
         return this.selectionSet === trimmedSelectionSet ? this : this.withUpdatedSelectionSet(trimmedSelectionSet);
     }
-    expandAllFragments() {
-        return this.mapToSelectionSet((s) => s.expandAllFragments());
-    }
-    expandFragments(names, updatedFragments) {
-        return this.mapToSelectionSet((s) => s.expandFragments(names, updatedFragments));
+    expandFragments(updatedFragments) {
+        return this.mapToSelectionSet((s) => s.expandFragments(updatedFragments));
     }
     equals(that) {
         if (this === that) {
@@ -1768,22 +1845,15 @@ class InlineFragmentSelection extends FragmentSelection {
             && this.selectionSet.equals(that.selectionSet);
     }
     contains(that) {
-        return (that instanceof FragmentSelection)
-            && this.element.equals(that.element)
-            && this.selectionSet.contains(that.selectionSet);
+        if (!(that instanceof FragmentSelection) || !this.element.equals(that.element)) {
+            return ContainsResult.NOT_CONTAINED;
+        }
+        return this.selectionSet.contains(that.selectionSet);
     }
     toString(expandFragments = true, indent) {
         return (indent !== null && indent !== void 0 ? indent : '') + this.element + ' ' + this.selectionSet.toString(expandFragments, true, indent);
     }
 }
-function diffDirectives(superset, maybeSubset) {
-    if (maybeSubset.every((d) => superset.some((s) => (0, definitions_1.sameDirectiveApplication)(d, s)))) {
-        return { isSubset: true, difference: superset.filter((s) => !maybeSubset.some((d) => (0, definitions_1.sameDirectiveApplication)(d, s))) };
-    }
-    else {
-        return { isSubset: false, difference: [] };
-    }
-}
 class FragmentSpreadSelection extends FragmentSelection {
     constructor(sourceType, fragments, namedFragment, spreadDirectives) {
         super(new FragmentElement(sourceType, namedFragment.typeCondition, namedFragment.appliedDirectives.concat(spreadDirectives)));
@@ -1791,6 +1861,9 @@ class FragmentSpreadSelection extends FragmentSelection {
         this.namedFragment = namedFragment;
         this.spreadDirectives = spreadDirectives;
     }
+    isFragmentSpread() {
+        return true;
+    }
     get selectionSet() {
         return this.namedFragment.selectionSet;
     }
@@ -1803,11 +1876,9 @@ class FragmentSpreadSelection extends FragmentSelection {
     withUpdatedComponents(_fragment, _selectionSet) {
         (0, utils_1.assert)(false, `Unsupported`);
     }
-    trimUnsatisfiableBranches(_) {
-        return this;
-    }
-    namedFragments() {
-        return this.fragments;
+    trimUnsatisfiableBranches(parentType) {
+        (0, utils_1.assert)(parentType.schema() === this.parentType.schema(), 'Should not try to trim using a type from another schema');
+        return this.rebaseOn(parentType, this.fragments);
     }
     validate() {
         this.validateDeferAndStream();
@@ -1834,29 +1905,29 @@ class FragmentSpreadSelection extends FragmentSelection {
     optimize(_) {
         return this;
     }
-    rebaseOn(_parentType) {
-        return this;
+    rebaseOn(parentType, fragments) {
+        if (this.parentType === parentType) {
+            return this;
+        }
+        (0, utils_1.assert)(fragments || this.parentType.schema() === parentType.schema(), `Must provide fragments is rebasing on other schema`);
+        const newFragments = fragments !== null && fragments !== void 0 ? fragments : this.fragments;
+        const namedFragment = newFragments.get(this.namedFragment.name);
+        (0, utils_1.assert)(namedFragment, () => `Cannot rebase ${this} if it isn't part of the provided fragments`);
+        return new FragmentSpreadSelection(parentType, newFragments, namedFragment, this.spreadDirectives);
     }
     canAddTo(_) {
         return true;
     }
-    expandAllFragments() {
-        const expandedSubSelections = this.selectionSet.expandAllFragments();
-        return (0, types_1.sameType)(this.parentType, this.namedFragment.typeCondition) && this.element.appliedDirectives.length === 0
-            ? expandedSubSelections.selections()
-            : new InlineFragmentSelection(this.element, expandedSubSelections);
-    }
-    expandFragments(names, updatedFragments) {
-        if (!names.includes(this.namedFragment.name)) {
+    expandFragments(updatedFragments) {
+        if (updatedFragments === null || updatedFragments === void 0 ? void 0 : updatedFragments.has(this.namedFragment.name)) {
             return this;
         }
-        const expandedSubSelections = this.selectionSet.expandFragments(names, updatedFragments);
+        const expandedSubSelections = this.selectionSet.expandFragments(updatedFragments);
         return (0, types_1.sameType)(this.parentType, this.namedFragment.typeCondition) && this.element.appliedDirectives.length === 0
             ? expandedSubSelections.selections()
             : new InlineFragmentSelection(this.element, expandedSubSelections);
     }
     collectUsedFragmentNames(collector) {
-        this.selectionSet.collectUsedFragmentNames(collector);
         const usageCount = collector.get(this.namedFragment.name);
         collector.set(this.namedFragment.name, usageCount === undefined ? 1 : usageCount + 1);
     }
@@ -1880,11 +1951,12 @@ class FragmentSpreadSelection extends FragmentSelection {
     }
     contains(that) {
         if (this.equals(that)) {
-            return true;
+            return ContainsResult.EQUAL;
         }
-        return (that instanceof FragmentSelection)
-            && this.element.equals(that.element)
-            && this.selectionSet.contains(that.selectionSet);
+        if (!(that instanceof FragmentSelection) || !this.element.equals(that.element)) {
+            return ContainsResult.NOT_CONTAINED;
+        }
+        return this.selectionSet.contains(that.selectionSet);
     }
     toString(expandFragments = true, indent) {
         if (expandFragments) {
@@ -1899,7 +1971,7 @@ class FragmentSpreadSelection extends FragmentSelection {
 }
 function selectionSetOfNode(parentType, node, variableDefinitions, fragments, fieldAccessor = (type, name) => type.field(name)) {
     if (node.selections.length === 1) {
-        return selectionSetOf(parentType, selectionOfNode(parentType, node.selections[0], variableDefinitions, fragments, fieldAccessor), fragments);
+        return selectionSetOf(parentType, selectionOfNode(parentType, node.selections[0], variableDefinitions, fragments, fieldAccessor));
     }
     const selections = new SelectionSetUpdates();
     for (const selectionNode of node.selections) {
@@ -1990,13 +2062,14 @@ function operationFromAST({ schema, operation, variableDefinitions, fragments, v
     var _a;
     const rootType = schema.schemaDefinition.root(operation.operation);
     validate(rootType, () => `The schema has no "${operation.operation}" root type defined`);
+    const fragmentsIfAny = fragments.isEmpty() ? undefined : fragments;
     return new Operation(schema, operation.operation, parseSelectionSet({
         parentType: rootType.type,
         source: operation.selectionSet,
         variableDefinitions,
-        fragments: fragments.isEmpty() ? undefined : fragments,
+        fragments: fragmentsIfAny,
         validate: validateInput,
-    }), variableDefinitions, (_a = operation.name) === null || _a === void 0 ? void 0 : _a.value);
+    }), variableDefinitions, fragmentsIfAny, (_a = operation.name) === null || _a === void 0 ? void 0 : _a.value);
 }
 function parseOperation(schema, operation, options) {
     return operationFromDocument(schema, (0, graphql_1.parse)(operation), options);
@@ -2028,8 +2101,8 @@ function operationToDocument(operation) {
         selectionSet: operation.selectionSet.toSelectionSetNode(),
         variableDefinitions: operation.variableDefinitions.toVariableDefinitionNodes(),
     };
-    const fragmentASTs = operation.selectionSet.fragments
-        ? (_a = operation.selectionSet.fragments) === null || _a === void 0 ? void 0 : _a.toFragmentDefinitionNodes()
+    const fragmentASTs = operation.fragments
+        ? (_a = operation.fragments) === null || _a === void 0 ? void 0 : _a.toFragmentDefinitionNodes()
         : [];
     return {
         kind: graphql_1.Kind.DOCUMENT,