@apollo/federation-internals 2.4.7 → 2.4.9

package/dist/operations.js

@@ -25,6 +25,9 @@ class AbstractOperationElement extends definitions_1.DirectiveTargetElement {
         this.collectVariablesInElement(collector);
         this.collectVariablesInAppliedDirectives(collector);
     }
+    rebaseOnOrError(parentType) {
+        return this.rebaseOn({ parentType, errorIfCannotRebase: true });
+    }
     addAttachement(key, value) {
         if (!this.attachements) {
             this.attachements = new Map();
@@ -162,7 +165,7 @@ class Field extends AbstractOperationElement {
             }
         }
     }
-    rebaseOn(parentType) {
+    rebaseOn({ parentType, errorIfCannotRebase }) {
         const fieldParent = this.definition.parent;
         if (parentType === fieldParent) {
             return this;
@@ -170,9 +173,12 @@ class Field extends AbstractOperationElement {
         if (this.name === definitions_1.typenameFieldName) {
             return this.withUpdatedDefinition(parentType.typenameField());
         }
-        validate(this.canRebaseOn(parentType), () => `Cannot add selection of field "${this.definition.coordinate}" to selection set of parent type "${parentType}"`);
         const fieldDef = parentType.field(this.name);
-        validate(fieldDef, () => `Cannot add selection of field "${this.definition.coordinate}" to selection set of parent type "${parentType}" (that does not declare that field)`);
+        const canRebase = this.canRebaseOn(parentType) && fieldDef;
+        if (!canRebase) {
+            validate(!errorIfCannotRebase, () => `Cannot add selection of field "${this.definition.coordinate}" to selection set of parent type "${parentType}"`);
+            return undefined;
+        }
         return this.withUpdatedDefinition(fieldDef);
     }
     canRebaseOn(parentType) {
@@ -276,14 +282,17 @@ class FragmentElement extends AbstractOperationElement {
         this.copyAttachementsTo(newFragment);
         return newFragment;
     }
-    rebaseOn(parentType) {
+    rebaseOn({ parentType, errorIfCannotRebase }) {
         const fragmentParent = this.parentType;
         const typeCondition = this.typeCondition;
         if (parentType === fragmentParent) {
             return this;
         }
         const { canRebase, rebasedCondition } = this.canRebaseOn(parentType);
-        validate(canRebase, () => `Cannot add fragment of condition "${typeCondition}" (runtimes: [${(0, definitions_1.possibleRuntimeTypes)(typeCondition)}]) to parent type "${parentType}" (runtimes: ${(0, definitions_1.possibleRuntimeTypes)(parentType)})`);
+        if (!canRebase) {
+            validate(!errorIfCannotRebase, () => `Cannot add fragment of condition "${typeCondition}" (runtimes: [${(0, definitions_1.possibleRuntimeTypes)(typeCondition)}]) to parent type "${parentType}" (runtimes: ${(0, definitions_1.possibleRuntimeTypes)(parentType)})`);
+            return undefined;
+        }
         return this.withUpdatedTypes(parentType, rebasedCondition);
     }
     canRebaseOn(parentType) {
@@ -527,6 +536,18 @@ class Operation {
         this.fragments = fragments;
         this.name = name;
     }
+    withUpdatedSelectionSet(newSelectionSet) {
+        if (this.selectionSet === newSelectionSet) {
+            return this;
+        }
+        return new Operation(this.schema, this.rootKind, newSelectionSet, this.variableDefinitions, this.fragments, this.name);
+    }
+    withUpdatedSelectionSetAndFragments(newSelectionSet, newFragments) {
+        if (this.selectionSet === newSelectionSet && newFragments === this.fragments) {
+            return this;
+        }
+        return new Operation(this.schema, this.rootKind, newSelectionSet, this.variableDefinitions, newFragments, this.name);
+    }
     optimize(fragments, minUsagesToOptimize = 2) {
         (0, utils_1.assert)(minUsagesToOptimize >= 1, `Expected 'minUsagesToOptimize' to be at least 1, but got ${minUsagesToOptimize}`);
         if (!fragments || fragments.isEmpty()) {
@@ -536,41 +557,39 @@ class Operation {
         if (optimizedSelection === this.selectionSet) {
             return this;
         }
-        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);
+        let finalFragments = computeFragmentsToKeep(optimizedSelection, fragments, minUsagesToOptimize);
+        if (finalFragments !== null && (finalFragments === null || finalFragments === void 0 ? void 0 : finalFragments.size) !== fragments.size) {
+            optimizedSelection = optimizedSelection.expandFragments(finalFragments);
+            optimizedSelection = optimizedSelection.normalize({ parentType: optimizedSelection.parentType });
+            if (finalFragments) {
+                let beforeRemoval;
+                do {
+                    beforeRemoval = finalFragments;
+                    const usages = new Map();
+                    optimizedSelection.collectUsedFragmentNames(usages);
+                    finalFragments.collectUsedFragmentNames(usages);
+                    finalFragments = finalFragments.filter((f) => { var _a; return ((_a = usages.get(f.name)) !== null && _a !== void 0 ? _a : 0) > 0; });
+                } while (finalFragments && finalFragments.size < beforeRemoval.size);
+            }
         }
-        optimizedSelection = optimizedSelection.expandFragments(finalFragments);
-        optimizedSelection = optimizedSelection.trimUnsatisfiableBranches(optimizedSelection.parentType);
-        return new Operation(this.schema, this.rootKind, optimizedSelection, this.variableDefinitions, finalFragments, this.name);
+        return this.withUpdatedSelectionSetAndFragments(optimizedSelection, finalFragments !== null && finalFragments !== void 0 ? finalFragments : undefined);
     }
     expandAllFragments() {
-        const expandedSelections = this.selectionSet.expandFragments();
-        if (expandedSelections === this.selectionSet) {
-            return this;
-        }
-        return new Operation(this.schema, this.rootKind, expandedSelections, this.variableDefinitions, undefined, this.name);
+        const expanded = this.selectionSet.expandFragments();
+        return this.withUpdatedSelectionSetAndFragments(expanded.normalize({ parentType: expanded.parentType }), undefined);
     }
-    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.fragments, this.name);
+    normalize() {
+        return this.withUpdatedSelectionSet(this.selectionSet.normalize({ parentType: this.selectionSet.parentType }));
     }
     withoutDefer(labelsToRemove) {
-        const updated = this.selectionSet.withoutDefer(labelsToRemove);
-        return updated == this.selectionSet
-            ? this
-            : new Operation(this.schema, this.rootKind, updated, this.variableDefinitions, this.fragments, this.name);
+        return this.withUpdatedSelectionSet(this.selectionSet.withoutDefer(labelsToRemove));
     }
     withNormalizedDefer() {
         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.fragments, this.name);
+            updatedOperation = this.withUpdatedSelectionSet(this.selectionSet.withNormalizedDefer(normalizer));
         }
         return {
             operation: updatedOperation,
@@ -612,7 +631,7 @@ class NamedFragmentDefinition extends definitions_1.DirectiveTargetElement {
     }
     expandedSelectionSet() {
         if (!this._expandedSelectionSet) {
-            this._expandedSelectionSet = this.selectionSet.expandFragments().trimUnsatisfiableBranches(this.typeCondition);
+            this._expandedSelectionSet = this.selectionSet.expandFragments().normalize({ parentType: this.typeCondition });
         }
         return this._expandedSelectionSet;
     }
@@ -650,7 +669,7 @@ class NamedFragmentDefinition extends definitions_1.DirectiveTargetElement {
             selectionSet: this.selectionSet.toSelectionSetNode()
         };
     }
-    canApplyAtType(type) {
+    canApplyDirectlyAtType(type) {
         if ((0, types_1.sameType)(type, this.typeCondition)) {
             return true;
         }
@@ -659,23 +678,29 @@ class NamedFragmentDefinition extends definitions_1.DirectiveTargetElement {
         }
         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)));
+        if (conditionRuntimes.length < typeRuntimes.length
+            || !typeRuntimes.every((t1) => conditionRuntimes.some((t2) => (0, types_1.sameType)(t1, t2)))) {
+            return false;
+        }
+        return (0, definitions_1.isObjectType)(type) || (0, definitions_1.isUnionType)(this.typeCondition);
     }
     expandedSelectionSetAtType(type) {
-        const expandedSelectionSet = this.expandedSelectionSet();
         if ((0, types_1.sameType)(type, this.typeCondition) || (0, definitions_1.isObjectType)(this.typeCondition)) {
-            return expandedSelectionSet;
-        }
-        if (!(0, definitions_1.isObjectType)(type)) {
-            return expandedSelectionSet;
+            return { selectionSet: this.expandedSelectionSet() };
         }
-        let selectionAtType = this.expandedSelectionSetsAtTypesCache.get(type.name);
-        if (!selectionAtType) {
-            selectionAtType = expandedSelectionSet.trimUnsatisfiableBranches(type, { recursive: false });
-            this.expandedSelectionSetsAtTypesCache.set(type.name, selectionAtType);
+        let cached = this.expandedSelectionSetsAtTypesCache.get(type.name);
+        if (!cached) {
+            cached = this.computeExpandedSelectionSetAtType(type);
+            this.expandedSelectionSetsAtTypesCache.set(type.name, cached);
         }
-        return selectionAtType;
+        return cached;
+    }
+    computeExpandedSelectionSetAtType(type) {
+        const expandedSelectionSet = this.expandedSelectionSet();
+        const selectionSet = expandedSelectionSet.normalize({ parentType: type, recursive: false });
+        const trimmed = expandedSelectionSet.minus(selectionSet);
+        const validator = trimmed.isEmpty() ? undefined : FieldsConflictValidator.build(trimmed);
+        return { selectionSet, validator };
     }
     includes(otherFragment) {
         if (this.name === otherFragment) {
@@ -696,7 +721,7 @@ class NamedFragmentDefinition extends definitions_1.DirectiveTargetElement {
         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)}`;
+        return `fragment ${this.name} on ${this.typeCondition}${this.appliedDirectivesToString()} ${this.selectionSet.toString(false, true, indent)}`;
     }
 }
 exports.NamedFragmentDefinition = NamedFragmentDefinition;
@@ -724,8 +749,8 @@ class NamedFragments {
             this.fragments.set(fragment.name, fragment);
         }
     }
-    maybeApplyingAtType(type) {
-        return this.fragments.values().filter(f => f.canApplyAtType(type));
+    maybeApplyingDirectlyAtType(type) {
+        return this.fragments.values().filter(f => f.canApplyDirectlyAtType(type));
     }
     get(name) {
         return this.fragments.get(name);
@@ -736,6 +761,11 @@ class NamedFragments {
     definitions() {
         return this.fragments.values();
     }
+    collectUsedFragmentNames(collector) {
+        for (const fragment of this.definitions()) {
+            fragment.collectUsedFragmentNames(collector);
+        }
+    }
     map(mapper) {
         const mapped = new NamedFragments();
         for (const def of this.fragments.values()) {
@@ -772,7 +802,7 @@ class NamedFragments {
     }
     mapToExpandedSelectionSets(mapper) {
         return this.mapInDependencyOrder((fragment, newFragments) => {
-            const mappedSelectionSet = mapper(fragment.selectionSet.expandFragments().trimUnsatisfiableBranches(fragment.typeCondition));
+            const mappedSelectionSet = mapper(fragment.selectionSet.expandFragments().normalize({ parentType: fragment.typeCondition }));
             if (!mappedSelectionSet) {
                 return undefined;
             }
@@ -780,19 +810,28 @@ class NamedFragments {
             return fragment.withUpdatedSelectionSet(reoptimizedSelectionSet);
         });
     }
+    selectionSetIsWorthUsing(selectionSet) {
+        const selections = selectionSet.selections();
+        if (selections.length === 0) {
+            return false;
+        }
+        if (selections.length === 1) {
+            const s = selections[0];
+            return !(s.kind === 'FieldSelection' && s.element.isLeafField());
+        }
+        return true;
+    }
     rebaseOn(schema) {
         return this.mapInDependencyOrder((fragment, newFragments) => {
             const rebasedType = schema.type(fragment.selectionSet.parentType.name);
-            try {
-                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) {
+            if (!rebasedType || !(0, definitions_1.isCompositeType)(rebasedType)) {
                 return undefined;
             }
+            const rebasedSelection = fragment.selectionSet.rebaseOn({ parentType: rebasedType, fragments: newFragments, errorIfCannotRebase: false });
+            return this.selectionSetIsWorthUsing(rebasedSelection)
+                ? new NamedFragmentDefinition(schema, fragment.name, rebasedType).setSelectionSet(rebasedSelection)
+                : undefined;
+            ;
         });
     }
     filter(predicate) {
@@ -872,7 +911,7 @@ var 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 = {}));
+})(ContainsResult || (exports.ContainsResult = ContainsResult = {}));
 class SelectionSet {
     constructor(parentType, keyedSelections = new Map()) {
         this.parentType = parentType;
@@ -893,6 +932,18 @@ class SelectionSet {
     hasTopLevelTypenameField() {
         return this._keyedSelections.has(definitions_1.typenameFieldName);
     }
+    withoutTopLevelTypenameField() {
+        if (!this.hasTopLevelTypenameField) {
+            return this;
+        }
+        const newKeyedSelections = new Map();
+        for (const [key, selection] of this._keyedSelections) {
+            if (key !== definitions_1.typenameFieldName) {
+                newKeyedSelections.set(key, selection);
+            }
+        }
+        return new SelectionSet(this.parentType, newKeyedSelections);
+    }
     fieldsInSet() {
         const fields = new Array();
         for (const selection of this.selections()) {
@@ -909,6 +960,21 @@ class SelectionSet {
         }
         return fields;
     }
+    fieldsByResponseName() {
+        const byResponseName = new utils_1.MultiMap();
+        this.collectFieldsByResponseName(byResponseName);
+        return byResponseName;
+    }
+    collectFieldsByResponseName(collector) {
+        for (const selection of this.selections()) {
+            if (selection.kind === 'FieldSelection') {
+                collector.add(selection.element.responseName(), selection);
+            }
+            else {
+                selection.selectionSet.collectFieldsByResponseName(collector);
+            }
+        }
+    }
     usedVariables() {
         const collector = new definitions_1.VariableCollector();
         this.collectVariables(collector);
@@ -929,19 +995,20 @@ class SelectionSet {
             return this;
         }
         const wrapped = new InlineFragmentSelection(new FragmentElement(this.parentType, this.parentType), this);
-        const optimized = wrapped.optimize(fragments);
+        const validator = FieldsConflictMultiBranchValidator.ofInitial(FieldsConflictValidator.build(this));
+        const optimized = wrapped.optimize(fragments, validator);
         return optimized instanceof FragmentSpreadSelection
             ? selectionSetOf(this.parentType, optimized)
             : optimized.selectionSet;
     }
-    optimizeSelections(fragments) {
-        return this.lazyMap((selection) => selection.optimize(fragments));
+    optimizeSelections(fragments, validator) {
+        return this.lazyMap((selection) => selection.optimize(fragments, validator));
     }
     expandFragments(updatedFragments) {
         return this.lazyMap((selection) => selection.expandFragments(updatedFragments));
     }
-    trimUnsatisfiableBranches(parentType, options) {
-        return this.lazyMap((selection) => selection.trimUnsatisfiableBranches(parentType, options), { parentType });
+    normalize({ parentType, recursive }) {
+        return this.lazyMap((selection) => selection.normalize({ parentType, recursive }), { parentType });
     }
     lazyMap(mapper, options) {
         var _a;
@@ -975,19 +1042,25 @@ class SelectionSet {
         return this.selections().some((s) => s.hasDefer());
     }
     filter(predicate) {
-        return this.lazyMap((selection) => selection.filter(predicate));
+        return this.lazyMap((selection) => predicate(selection) ? selection : undefined);
+    }
+    filterRecursiveDepthFirst(predicate) {
+        return this.lazyMap((selection) => selection.filterRecursiveDepthFirst(predicate));
     }
     withoutEmptyBranches() {
-        const updated = this.filter((selection) => { var _a; return ((_a = selection.selectionSet) === null || _a === void 0 ? void 0 : _a.isEmpty()) !== true; });
+        const updated = this.filterRecursiveDepthFirst((selection) => { var _a; return ((_a = selection.selectionSet) === null || _a === void 0 ? void 0 : _a.isEmpty()) !== true; });
         return updated.isEmpty() ? undefined : updated;
     }
-    rebaseOn(parentType, fragments) {
+    rebaseOn({ parentType, fragments, errorIfCannotRebase, }) {
         if (this.parentType === parentType) {
             return this;
         }
         const newSelections = new Map();
         for (const selection of this.selections()) {
-            newSelections.set(selection.key(), selection.rebaseOn(parentType, fragments));
+            const rebasedSelection = selection.rebaseOn({ parentType, fragments, errorIfCannotRebase });
+            if (rebasedSelection) {
+                newSelections.set(selection.key(), rebasedSelection);
+            }
         }
         return new SelectionSet(parentType, newSelections);
     }
@@ -1006,14 +1079,21 @@ class SelectionSet {
         }
         return true;
     }
-    contains(that) {
+    contains(that, options) {
+        var _a;
+        const ignoreMissingTypename = (_a = options === null || options === void 0 ? void 0 : options.ignoreMissingTypename) !== null && _a !== void 0 ? _a : false;
         if (that._selections.length > this._selections.length) {
-            return ContainsResult.NOT_CONTAINED;
+            if (!ignoreMissingTypename || that._selections.length > this._selections.length + 1 || this.hasTopLevelTypenameField() || !that.hasTopLevelTypenameField()) {
+                return ContainsResult.NOT_CONTAINED;
+            }
         }
         let isEqual = true;
         for (const [key, thatSelection] of that._keyedSelections) {
+            if (key === definitions_1.typenameFieldName && ignoreMissingTypename) {
+                continue;
+            }
             const thisSelection = this._keyedSelections.get(key);
-            const selectionResult = thisSelection === null || thisSelection === void 0 ? void 0 : thisSelection.contains(thatSelection);
+            const selectionResult = thisSelection === null || thisSelection === void 0 ? void 0 : thisSelection.contains(thatSelection, options);
             if (selectionResult === undefined || selectionResult === ContainsResult.NOT_CONTAINED) {
                 return ContainsResult.NOT_CONTAINED;
             }
@@ -1023,20 +1103,9 @@ class SelectionSet {
             ? ContainsResult.EQUAL
             : ContainsResult.STRICTLY_CONTAINED;
     }
-    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(fragments.filter((f) => f.name !== candidate.name));
-            if (updatedThis !== this) {
-                updatedThis = updatedThis.trimUnsatisfiableBranches(parentType);
-            }
-            const diff = updatedThis.minus(that);
-            return { contains: true, diff: diff.isEmpty() ? undefined : diff };
-        }
-        return { contains: false };
+    containsTopLevelField(field) {
+        const selection = this._keyedSelections.get(field.key());
+        return !!selection && selection.element.equals(field);
     }
     minus(that) {
         const updated = new SelectionSetUpdates();
@@ -1054,6 +1123,25 @@ class SelectionSet {
         }
         return updated.toSelectionSet(this.parentType);
     }
+    intersectionWith(that) {
+        if (this.isEmpty()) {
+            return this;
+        }
+        if (that.isEmpty()) {
+            return that;
+        }
+        const intersection = new SelectionSetUpdates();
+        for (const [key, thisSelection] of this._keyedSelections) {
+            const thatSelection = that._keyedSelections.get(key);
+            if (thatSelection) {
+                const selection = thisSelection.intersectionWith(thatSelection);
+                if (selection) {
+                    intersection.add(selection);
+                }
+            }
+        }
+        return intersection.toSelectionSet(this.parentType);
+    }
     canRebaseOn(parentTypeToTest) {
         return this.selections().every((selection) => selection.canAddTo(parentTypeToTest));
     }
@@ -1196,6 +1284,16 @@ class SelectionSetUpdates {
     toSelectionSet(parentType, fragments) {
         return makeSelectionSet(parentType, this.keyedUpdates, fragments);
     }
+    toString() {
+        return '{\n'
+            + [...this.keyedUpdates.entries()].map(([k, updates]) => {
+                const updStr = updates.map((upd) => upd instanceof AbstractSelection
+                    ? upd.toString()
+                    : `${upd.path} -> ${upd.selections}`);
+                return ` - ${k}: ${updStr}`;
+            }).join('\n')
+            + '\n\}';
+    }
 }
 exports.SelectionSetUpdates = SelectionSetUpdates;
 function addToKeyedUpdates(keyedUpdates, selections) {
@@ -1260,9 +1358,9 @@ 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, fragments);
+        return first.rebaseOnOrError({ parentType, fragments });
     }
-    const element = updateElement(first).rebaseOn(parentType);
+    const element = updateElement(first).rebaseOnOrError(parentType);
     const subSelectionParentType = element.kind === 'Field' ? element.baseType() : element.castedType();
     if (!(0, definitions_1.isCompositeType)(subSelectionParentType)) {
         return selectionOfElement(element);
@@ -1393,6 +1491,9 @@ class AbstractSelection {
     constructor(element) {
         this.element = element;
     }
+    rebaseOnOrError({ parentType, fragments }) {
+        return this.rebaseOn({ parentType, fragments, errorIfCannotRebase: true });
+    }
     get parentType() {
         return this.element.parentType;
     }
@@ -1435,40 +1536,200 @@ class AbstractSelection {
         }
         return undefined;
     }
-    tryOptimizeSubselectionWithFragments({ parentType, subSelection, fragments, canUseFullMatchingFragment, }) {
-        let candidates = fragments.maybeApplyingAtType(parentType);
+    intersectionWith(that) {
+        if (this.selectionSet && that.selectionSet) {
+            const subSelectionSetIntersection = this.selectionSet.intersectionWith(that.selectionSet);
+            if (subSelectionSetIntersection.isEmpty()) {
+                return undefined;
+            }
+            else {
+                return this.withUpdatedSelectionSet(subSelectionSetIntersection);
+            }
+        }
+        else {
+            return this.us();
+        }
+    }
+    tryOptimizeSubselectionWithFragments({ parentType, subSelection, fragments, validator, canUseFullMatchingFragment, }) {
+        let candidates = fragments.maybeApplyingDirectlyAtType(parentType);
+        if (candidates.length === 0) {
+            return subSelection;
+        }
         const applyingFragments = [];
         for (const candidate of candidates) {
-            const fragmentSSet = candidate.expandedSelectionSetAtType(parentType);
-            if (fragmentSSet.isEmpty() || (fragmentSSet.selections().length === 1 && fragmentSSet.selections()[0].isTypenameField())) {
+            let atType = candidate.expandedSelectionSetAtType(parentType);
+            if (atType.selectionSet.isEmpty() || (atType.selectionSet.selections().length === 1 && atType.selectionSet.selections()[0].isTypenameField())) {
                 continue;
             }
-            const res = subSelection.contains(fragmentSSet);
+            const res = subSelection.contains(atType.selectionSet, { ignoreMissingTypename: true });
             if (res === ContainsResult.EQUAL) {
                 if (canUseFullMatchingFragment(candidate)) {
+                    if (!validator.checkCanReuseFragmentAndTrackIt(atType)) {
+                        continue;
+                    }
                     return candidate;
                 }
                 if (candidate.appliedDirectives.length === 0) {
-                    applyingFragments.push(candidate);
+                    applyingFragments.push({ fragment: candidate, atType });
                 }
             }
             else if (res === ContainsResult.STRICTLY_CONTAINED && candidate.appliedDirectives.length === 0) {
-                applyingFragments.push(candidate);
+                applyingFragments.push({ fragment: candidate, atType });
             }
         }
         if (applyingFragments.length === 0) {
             return subSelection;
         }
-        const filteredApplyingFragments = applyingFragments.filter((f) => !applyingFragments.some((o) => o.includes(f.name)));
+        const filteredApplyingFragments = applyingFragments.filter(({ fragment }) => !applyingFragments.some((o) => o.fragment.includes(fragment.name)));
         let notCoveredByFragments = subSelection;
         const optimized = new SelectionSetUpdates();
-        for (const fragment of filteredApplyingFragments) {
-            notCoveredByFragments = notCoveredByFragments.minus(fragment.expandedSelectionSetAtType(parentType));
+        for (const { fragment, atType } of filteredApplyingFragments) {
+            if (!validator.checkCanReuseFragmentAndTrackIt(atType)) {
+                continue;
+            }
+            const notCovered = subSelection.minus(atType.selectionSet);
+            notCoveredByFragments = notCoveredByFragments.intersectionWith(notCovered);
             optimized.add(new FragmentSpreadSelection(parentType, fragments, fragment, []));
         }
         return optimized.add(notCoveredByFragments).toSelectionSet(parentType, fragments);
     }
 }
+class FieldsConflictMultiBranchValidator {
+    constructor(validators) {
+        this.validators = validators;
+    }
+    static ofInitial(validator) {
+        return new FieldsConflictMultiBranchValidator([validator]);
+    }
+    forField(field) {
+        const forAllBranches = this.validators.flatMap((vs) => vs.forField(field));
+        (0, utils_1.assert)(forAllBranches.length > 0, `Shoud have found at least one validator for ${field}`);
+        return new FieldsConflictMultiBranchValidator(forAllBranches);
+    }
+    checkCanReuseFragmentAndTrackIt(fragment) {
+        const validator = fragment.validator;
+        if (!validator) {
+            return true;
+        }
+        if (!this.validators.every((v) => v.doMergeWith(validator))) {
+            return false;
+        }
+        if (this.usedSpreadTrimmedPartAtLevel) {
+            if (!this.usedSpreadTrimmedPartAtLevel.every((t) => validator.doMergeWith(t))) {
+                return false;
+            }
+        }
+        else {
+            this.usedSpreadTrimmedPartAtLevel = [];
+        }
+        this.usedSpreadTrimmedPartAtLevel.push(validator);
+        return true;
+    }
+}
+class FieldsConflictValidator {
+    constructor(byResponseName) {
+        this.byResponseName = byResponseName;
+    }
+    static build(s) {
+        return FieldsConflictValidator.forLevel(s.fieldsInSet());
+    }
+    static forLevel(level) {
+        var _a;
+        const atLevel = new Map();
+        for (const { field } of level) {
+            const responseName = field.element.responseName();
+            let atResponseName = atLevel.get(responseName);
+            if (!atResponseName) {
+                atResponseName = new Map();
+                atLevel.set(responseName, atResponseName);
+            }
+            if (field.selectionSet) {
+                let forField = (_a = atResponseName.get(field.element)) !== null && _a !== void 0 ? _a : [];
+                atResponseName.set(field.element, forField.concat(field.selectionSet.fieldsInSet()));
+            }
+            else {
+                atResponseName.set(field.element, null);
+            }
+        }
+        const byResponseName = new Map();
+        for (const [name, level] of atLevel.entries()) {
+            const atResponseName = new Map();
+            for (const [field, collectedFields] of level) {
+                const validator = collectedFields ? FieldsConflictValidator.forLevel(collectedFields) : null;
+                atResponseName.set(field, validator);
+            }
+            byResponseName.set(name, atResponseName);
+        }
+        return new FieldsConflictValidator(byResponseName);
+    }
+    forField(field) {
+        const byResponseName = this.byResponseName.get(field.responseName());
+        if (!byResponseName) {
+            return [];
+        }
+        return (0, utils_1.mapValues)(byResponseName).filter((v) => !!v);
+    }
+    doMergeWith(that) {
+        var _a, _b;
+        for (const [responseName, thisFields] of this.byResponseName.entries()) {
+            const thatFields = that.byResponseName.get(responseName);
+            if (!thatFields) {
+                continue;
+            }
+            for (const [thisField, thisValidator] of thisFields.entries()) {
+                for (const [thatField, thatValidator] of thatFields.entries()) {
+                    if (!(0, types_1.typesCanBeMerged)(thisField.definition.type, thatField.definition.type)) {
+                        return false;
+                    }
+                    const p1 = thisField.parentType;
+                    const p2 = thatField.parentType;
+                    if ((0, types_1.sameType)(p1, p2) || !(0, definitions_1.isObjectType)(p1) || !(0, definitions_1.isObjectType)(p2)) {
+                        if (thisField.name !== thatField.name
+                            || !(0, values_1.argumentsEquals)((_a = thisField.args) !== null && _a !== void 0 ? _a : {}, (_b = thatField.args) !== null && _b !== void 0 ? _b : {})
+                            || (thisValidator && thatValidator && !thisValidator.doMergeWith(thatValidator))) {
+                            return false;
+                        }
+                    }
+                    else {
+                        if (thisValidator && thatValidator && !thisValidator.hasSameResponseShapeThan(thatValidator)) {
+                            return false;
+                        }
+                    }
+                }
+            }
+        }
+        return true;
+    }
+    hasSameResponseShapeThan(that) {
+        for (const [responseName, thisFields] of this.byResponseName.entries()) {
+            const thatFields = that.byResponseName.get(responseName);
+            if (!thatFields) {
+                continue;
+            }
+            for (const [thisField, thisValidator] of thisFields.entries()) {
+                for (const [thatField, thatValidator] of thatFields.entries()) {
+                    if (!(0, types_1.typesCanBeMerged)(thisField.definition.type, thatField.definition.type)
+                        || (thisValidator && thatValidator && !thisValidator.hasSameResponseShapeThan(thatValidator))) {
+                        return false;
+                    }
+                }
+            }
+        }
+        return true;
+    }
+    toString(indent = '') {
+        return '{\n'
+            + [...this.byResponseName.entries()].map(([name, byFields]) => {
+                const innerIndent = indent + '  ';
+                return `${innerIndent}${name}: [\n`
+                    + [...byFields.entries()]
+                        .map(([field, next]) => `${innerIndent}  ${field.parentType}.${field}${next ? next.toString(innerIndent + '  ') : ''}`)
+                        .join('\n')
+                    + `\n${innerIndent}]`;
+            }).join('\n')
+            + `\n${indent}}`;
+    }
+}
 class FieldSelection extends AbstractSelection {
     constructor(field, _selectionSet) {
         super(field);
@@ -1485,41 +1746,44 @@ class FieldSelection extends AbstractSelection {
         return this.element.definition.name === definitions_1.typenameFieldName;
     }
     withUpdatedComponents(field, selectionSet) {
+        if (this.element === field && this.selectionSet === selectionSet) {
+            return this;
+        }
         return new FieldSelection(field, selectionSet);
     }
     key() {
         return this.element.key();
     }
-    optimize(fragments) {
+    optimize(fragments, validator) {
         const fieldBaseType = (0, definitions_1.baseType)(this.element.definition.type);
         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: this.selectionSet,
-                fragments,
-                canUseFullMatchingFragment: (fragment) => fragment.appliedDirectives.length === 0,
-            });
-            if (optimized instanceof NamedFragmentDefinition) {
-                optimizedSelection = selectionSetOf(fieldBaseType, new FragmentSpreadSelection(fieldBaseType, fragments, optimized, []));
-            }
-            else {
-                optimizedSelection = optimized;
-            }
+        const fieldValidator = validator.forField(this.element);
+        const optimized = this.tryOptimizeSubselectionWithFragments({
+            parentType: fieldBaseType,
+            subSelection: this.selectionSet,
+            fragments,
+            validator: fieldValidator,
+            canUseFullMatchingFragment: (fragment) => fragment.appliedDirectives.length === 0,
+        });
+        let optimizedSelection;
+        if (optimized instanceof NamedFragmentDefinition) {
+            optimizedSelection = selectionSetOf(fieldBaseType, new FragmentSpreadSelection(fieldBaseType, fragments, optimized, []));
+        }
+        else {
+            optimizedSelection = optimized;
         }
-        optimizedSelection = optimizedSelection.optimize(fragments);
+        optimizedSelection = optimizedSelection.optimizeSelections(fragments, fieldValidator);
         return this.selectionSet === optimizedSelection
             ? this
             : this.withUpdatedSelectionSet(optimizedSelection);
     }
-    filter(predicate) {
+    filterRecursiveDepthFirst(predicate) {
         if (!this.selectionSet) {
             return predicate(this) ? this : undefined;
         }
-        const updatedSelectionSet = this.selectionSet.filter(predicate);
+        const updatedSelectionSet = this.selectionSet.filterRecursiveDepthFirst(predicate);
         const thisWithFilteredSelectionSet = this.selectionSet === updatedSelectionSet
             ? this
             : new FieldSelection(this.element, updatedSelectionSet);
@@ -1531,11 +1795,14 @@ 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, fragments) {
+    rebaseOn({ parentType, fragments, errorIfCannotRebase, }) {
         if (this.element.parentType === parentType) {
             return this;
         }
-        const rebasedElement = this.element.rebaseOn(parentType);
+        const rebasedElement = this.element.rebaseOn({ parentType, errorIfCannotRebase });
+        if (!rebasedElement) {
+            return undefined;
+        }
         if (!this.selectionSet) {
             return this.withUpdatedElement(rebasedElement);
         }
@@ -1544,7 +1811,8 @@ class FieldSelection extends AbstractSelection {
             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, fragments));
+        const rebasedSelectionSet = this.selectionSet.rebaseOn({ parentType: rebasedBase, fragments, errorIfCannotRebase });
+        return rebasedSelectionSet.isEmpty() ? undefined : this.withUpdatedComponents(rebasedElement, rebasedSelectionSet);
     }
     canAddTo(parentType) {
         if (this.element.parentType === parentType) {
@@ -1586,19 +1854,23 @@ class FieldSelection extends AbstractSelection {
         var _a;
         return !!((_a = this.selectionSet) === null || _a === void 0 ? void 0 : _a.hasDefer());
     }
-    trimUnsatisfiableBranches(_, options) {
-        var _a, _b;
+    normalize({ parentType, recursive }) {
+        const definition = parentType === this.parentType
+            ? this.element.definition
+            : parentType.field(this.element.name);
+        (0, utils_1.assert)(definition, `Cannot normalize ${this.element} at ${parentType} which does not have that field`);
+        const element = this.element.definition === definition ? this.element : this.element.withUpdatedDefinition(definition);
         if (!this.selectionSet) {
-            return this;
+            return this.withUpdatedElement(element);
         }
-        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()) {
-            return trimmed.withUpdatedSelectionSet(selectionSetOfElement(new Field(base.typenameField(), undefined, [new definitions_1.Directive('include', { 'if': false })])));
+        const base = element.baseType();
+        (0, utils_1.assert)((0, definitions_1.isCompositeType)(base), () => `Field ${element} should not have a sub-selection`);
+        const normalizedSubSelection = (recursive !== null && recursive !== void 0 ? recursive : true) ? this.selectionSet.normalize({ parentType: base }) : this.selectionSet;
+        if (normalizedSubSelection === null || normalizedSubSelection === void 0 ? void 0 : normalizedSubSelection.isEmpty()) {
+            return this.withUpdatedComponents(element, selectionSetOfElement(new Field(base.typenameField(), undefined, [new definitions_1.Directive('include', { 'if': false })])));
         }
         else {
-            return trimmed;
+            return this.withUpdatedComponents(element, normalizedSubSelection);
         }
     }
     expandFragments(updatedFragments) {
@@ -1616,7 +1888,7 @@ class FieldSelection extends AbstractSelection {
         }
         return !!that.selectionSet && this.selectionSet.equals(that.selectionSet);
     }
-    contains(that) {
+    contains(that, options) {
         if (!(that instanceof FieldSelection) || !this.element.equals(that.element)) {
             return ContainsResult.NOT_CONTAINED;
         }
@@ -1625,7 +1897,7 @@ class FieldSelection extends AbstractSelection {
             return ContainsResult.EQUAL;
         }
         (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);
+        return this.selectionSet.contains(that.selectionSet, options);
     }
     toString(expandFragments = true, indent) {
         return (indent !== null && indent !== void 0 ? indent : '') + this.element + (this.selectionSet ? ' ' + this.selectionSet.toString(expandFragments, true, indent) : '');
@@ -1647,10 +1919,9 @@ class FragmentSelection extends AbstractSelection {
             validate(schemaDef.rootType('mutation') !== parentType && schemaDef.rootType('subscription') !== parentType, () => { var _a; return `The @defer and @stream directives cannot be used on ${(_a = schemaDef.roots().filter((t) => t.type === parentType).pop()) === null || _a === void 0 ? void 0 : _a.rootKind} root type "${parentType}"`; });
         }
     }
-    filter(predicate) {
-        const selectionSet = this.selectionSet;
-        const updatedSelectionSet = selectionSet.filter(predicate);
-        const thisWithFilteredSelectionSet = updatedSelectionSet === selectionSet
+    filterRecursiveDepthFirst(predicate) {
+        const updatedSelectionSet = this.selectionSet.filterRecursiveDepthFirst(predicate);
+        const thisWithFilteredSelectionSet = updatedSelectionSet === this.selectionSet
             ? this
             : new InlineFragmentSelection(this.element, updatedSelectionSet);
         return predicate(thisWithFilteredSelectionSet) ? thisWithFilteredSelectionSet : undefined;
@@ -1658,6 +1929,17 @@ class FragmentSelection extends AbstractSelection {
     hasDefer() {
         return this.element.hasDefer() || this.selectionSet.hasDefer();
     }
+    normalize({ parentType, recursive }) {
+        const thisCondition = this.element.typeCondition;
+        if (thisCondition && parentType !== this.parentType) {
+            const conditionRuntimes = (0, definitions_1.possibleRuntimeTypes)(thisCondition);
+            const typeRuntimes = (0, definitions_1.possibleRuntimeTypes)(parentType);
+            if (!conditionRuntimes.some((t) => typeRuntimes.includes(t))) {
+                return undefined;
+            }
+        }
+        return this.normalizeKnowingItIntersects({ parentType, recursive });
+    }
 }
 exports.FragmentSelection = FragmentSelection;
 class InlineFragmentSelection extends FragmentSelection {
@@ -1672,6 +1954,9 @@ class InlineFragmentSelection extends FragmentSelection {
         return this.element.key();
     }
     withUpdatedComponents(fragment, selectionSet) {
+        if (fragment === this.element && selectionSet === this.selectionSet) {
+            return this;
+        }
         return new InlineFragmentSelection(fragment, selectionSet);
     }
     validate(variableDefinitions) {
@@ -1679,16 +1964,20 @@ class InlineFragmentSelection extends FragmentSelection {
         validate(!this.selectionSet.isEmpty(), () => `Invalid empty selection set for fragment "${this.element}"`);
         this.selectionSet.validate(variableDefinitions);
     }
-    rebaseOn(parentType, fragments) {
+    rebaseOn({ parentType, fragments, errorIfCannotRebase, }) {
         if (this.parentType === parentType) {
             return this;
         }
-        const rebasedFragment = this.element.rebaseOn(parentType);
+        const rebasedFragment = this.element.rebaseOn({ parentType, errorIfCannotRebase });
+        if (!rebasedFragment) {
+            return undefined;
+        }
         const rebasedCastedType = rebasedFragment.castedType();
         if (rebasedCastedType === this.selectionSet.parentType) {
             return this.withUpdatedElement(rebasedFragment);
         }
-        return this.withUpdatedComponents(rebasedFragment, this.selectionSet.rebaseOn(rebasedCastedType, fragments));
+        const rebasedSelectionSet = this.selectionSet.rebaseOn({ parentType: rebasedCastedType, fragments, errorIfCannotRebase });
+        return rebasedSelectionSet.isEmpty() ? undefined : this.withUpdatedComponents(rebasedFragment, rebasedSelectionSet);
     }
     canAddTo(parentType) {
         if (this.element.parentType === parentType) {
@@ -1720,7 +2009,7 @@ class InlineFragmentSelection extends FragmentSelection {
             selectionSet: this.selectionSet.toSelectionSetNode()
         };
     }
-    optimize(fragments) {
+    optimize(fragments, validator) {
         let optimizedSelection = this.selectionSet;
         const typeCondition = this.element.typeCondition;
         if (typeCondition) {
@@ -1728,6 +2017,7 @@ class InlineFragmentSelection extends FragmentSelection {
                 parentType: typeCondition,
                 subSelection: optimizedSelection,
                 fragments,
+                validator,
                 canUseFullMatchingFragment: (fragment) => {
                     return fragment.appliedDirectives.length === 0
                         || ((0, types_1.sameType)(typeCondition, fragment.typeCondition)
@@ -1750,7 +2040,7 @@ class InlineFragmentSelection extends FragmentSelection {
                 optimizedSelection = optimized;
             }
         }
-        optimizedSelection = optimizedSelection.optimizeSelections(fragments);
+        optimizedSelection = optimizedSelection.optimizeSelections(fragments, validator);
         return this.selectionSet === optimizedSelection
             ? this
             : new InlineFragmentSelection(this.element, optimizedSelection);
@@ -1778,42 +2068,35 @@ class InlineFragmentSelection extends FragmentSelection {
             ? this
             : this.withUpdatedComponents(newElement, newSelection);
     }
-    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;
+    normalizeKnowingItIntersects({ parentType, recursive }) {
+        var _a;
         const thisCondition = this.element.typeCondition;
         if (this.element.appliedDirectives.length === 0) {
-            if (!thisCondition || currentType === this.element.typeCondition) {
-                const trimmed = this.selectionSet.trimUnsatisfiableBranches(currentType, options);
-                return trimmed.isEmpty() ? undefined : trimmed;
+            if (!thisCondition || parentType === this.element.typeCondition || (0, definitions_1.isObjectType)(parentType)) {
+                const normalized = this.selectionSet.normalize({ parentType, recursive });
+                return normalized.isEmpty() ? undefined : normalized;
             }
-            if ((0, definitions_1.isObjectType)(currentType)) {
-                if ((0, definitions_1.isObjectType)(thisCondition) || !(0, definitions_1.possibleRuntimeTypes)(thisCondition).includes(currentType)) {
+        }
+        let normalizedSelectionSet;
+        if (recursive !== null && recursive !== void 0 ? recursive : true) {
+            normalizedSelectionSet = this.selectionSet.normalize({ parentType: thisCondition !== null && thisCondition !== void 0 ? thisCondition : parentType });
+            if (normalizedSelectionSet.isEmpty()) {
+                if (this.element.appliedDirectives.length === 0) {
                     return undefined;
                 }
                 else {
-                    const trimmed = this.selectionSet.trimUnsatisfiableBranches(currentType, options);
-                    return trimmed.isEmpty() ? undefined : trimmed;
+                    return this.withUpdatedComponents(this.element.rebaseOnOrError(parentType), selectionSetOfElement(new Field(((_a = this.element.typeCondition) !== null && _a !== void 0 ? _a : parentType).typenameField(), undefined, [new definitions_1.Directive('include', { 'if': false })])));
                 }
             }
         }
-        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(((_c = this.element.typeCondition) !== null && _c !== void 0 ? _c : this.parentType).typenameField(), undefined, [new definitions_1.Directive('include', { 'if': false })])));
-            }
+        else {
+            normalizedSelectionSet = this.selectionSet;
         }
         if (this.element.appliedDirectives.length === 0 && (0, definitions_1.isAbstractType)(thisCondition)) {
-            (0, utils_1.assert)(!(0, definitions_1.isObjectType)(currentType), () => `Should not have got here if ${currentType} is an object type`);
-            const currentRuntimes = (0, definitions_1.possibleRuntimeTypes)(currentType);
+            (0, utils_1.assert)(!(0, definitions_1.isObjectType)(parentType), () => `Should not have got here if ${parentType} is an object type`);
+            const currentRuntimes = (0, definitions_1.possibleRuntimeTypes)(parentType);
             const liftableSelections = [];
-            for (const selection of trimmedSelectionSet.selections()) {
+            for (const selection of normalizedSelectionSet.selections()) {
                 if (selection.kind === 'FragmentSelection'
                     && selection.element.typeCondition
                     && (0, definitions_1.isObjectType)(selection.element.typeCondition)
@@ -1821,17 +2104,19 @@ class InlineFragmentSelection extends FragmentSelection {
                     liftableSelections.push(selection);
                 }
             }
-            if (liftableSelections.length === trimmedSelectionSet.selections().length) {
-                return trimmedSelectionSet;
+            if (liftableSelections.length === normalizedSelectionSet.selections().length) {
+                return normalizedSelectionSet;
             }
             if (liftableSelections.length > 0) {
                 const newSet = new SelectionSetUpdates();
                 newSet.add(liftableSelections);
-                newSet.add(this.withUpdatedSelectionSet(trimmedSelectionSet.filter((s) => !liftableSelections.includes(s))));
-                return newSet.toSelectionSet(this.parentType);
+                newSet.add(this.withUpdatedSelectionSet(normalizedSelectionSet.filter((s) => !liftableSelections.includes(s))));
+                return newSet.toSelectionSet(parentType);
             }
         }
-        return this.selectionSet === trimmedSelectionSet ? this : this.withUpdatedSelectionSet(trimmedSelectionSet);
+        return this.parentType === parentType && this.selectionSet === normalizedSelectionSet
+            ? this
+            : this.withUpdatedComponents(this.element.rebaseOnOrError(parentType), normalizedSelectionSet);
     }
     expandFragments(updatedFragments) {
         return this.mapToSelectionSet((s) => s.expandFragments(updatedFragments));
@@ -1844,11 +2129,11 @@ class InlineFragmentSelection extends FragmentSelection {
             && this.element.equals(that.element)
             && this.selectionSet.equals(that.selectionSet);
     }
-    contains(that) {
+    contains(that, options) {
         if (!(that instanceof FragmentSelection) || !this.element.equals(that.element)) {
             return ContainsResult.NOT_CONTAINED;
         }
-        return this.selectionSet.contains(that.selectionSet);
+        return this.selectionSet.contains(that.selectionSet, options);
     }
     toString(expandFragments = true, indent) {
         return (indent !== null && indent !== void 0 ? indent : '') + this.element + ' ' + this.selectionSet.toString(expandFragments, true, indent);
@@ -1876,12 +2161,13 @@ class FragmentSpreadSelection extends FragmentSelection {
     withUpdatedComponents(_fragment, _selectionSet) {
         (0, utils_1.assert)(false, `Unsupported`);
     }
-    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);
+    normalizeKnowingItIntersects({ parentType }) {
+        (0, utils_1.assert)(parentType.schema() === this.parentType.schema(), 'Should not try to normalize using a type from another schema');
+        return this.rebaseOnOrError({ parentType, fragments: this.fragments });
     }
     validate() {
         this.validateDeferAndStream();
+        validate((0, definitions_1.runtimeTypesIntersects)(this.parentType, this.namedFragment.typeCondition), () => `Fragment "${this.namedFragment.name}" cannot be spread inside type ${this.parentType} as the runtime types do not intersect ${this.namedFragment.typeCondition}`);
     }
     toSelectionNode() {
         const directiveNodes = this.spreadDirectives.length === 0
@@ -1902,17 +2188,20 @@ class FragmentSpreadSelection extends FragmentSelection {
             directives: directiveNodes,
         };
     }
-    optimize(_) {
+    optimize(_1, _2) {
         return this;
     }
-    rebaseOn(parentType, fragments) {
+    rebaseOn({ parentType, fragments, errorIfCannotRebase, }) {
         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`);
+        if (!namedFragment) {
+            validate(!errorIfCannotRebase, () => `Cannot rebase ${this.toString(false)} if it isn't part of the provided fragments`);
+            return undefined;
+        }
         return new FragmentSpreadSelection(parentType, newFragments, namedFragment, this.spreadDirectives);
     }
     canAddTo(_) {
@@ -1949,14 +2238,14 @@ class FragmentSpreadSelection extends FragmentSelection {
             && this.namedFragment.name === that.namedFragment.name
             && (0, definitions_1.sameDirectiveApplications)(this.spreadDirectives, that.spreadDirectives);
     }
-    contains(that) {
+    contains(that, options) {
         if (this.equals(that)) {
             return ContainsResult.EQUAL;
         }
         if (!(that instanceof FragmentSelection) || !this.element.equals(that.element)) {
             return ContainsResult.NOT_CONTAINED;
         }
-        return this.selectionSet.contains(that.selectionSet);
+        return this.selectionSet.contains(that.selectionSet, options);
     }
     toString(expandFragments = true, indent) {
         if (expandFragments) {