@apollo/federation-internals 2.4.0-alpha.1 → 2.4.1

package/dist/operations.js

@@ -1,12 +1,14 @@
 "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.allFieldDefinitionsInSelectionSet = exports.SelectionSet = exports.NamedFragments = exports.NamedFragmentDefinition = exports.selectionSetOf = 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.NamedFragments = exports.NamedFragmentDefinition = exports.Operation = exports.concatOperationPaths = exports.conditionalDirectivesInOperationPath = exports.sameOperationPaths = exports.operationPathToStringPath = exports.FragmentElement = exports.Field = void 0;
 const graphql_1 = require("graphql");
 const definitions_1 = require("./definitions");
+const federation_1 = require("./federation");
 const error_1 = require("./error");
 const types_1 = require("./types");
 const utils_1 = require("./utils");
 const values_1 = require("./values");
+const uuid_1 = require("uuid");
 function validate(condition, message, sourceAST) {
     if (!condition) {
         throw error_1.ERRORS.INVALID_GRAPHQL.err(message(), { nodes: sourceAST });
@@ -16,12 +18,12 @@ function haveSameDirectives(op1, op2) {
     return (0, definitions_1.sameDirectiveApplications)(op1.appliedDirectives, op2.appliedDirectives);
 }
 class AbstractOperationElement extends definitions_1.DirectiveTargetElement {
-    constructor(schema, variablesInElement) {
-        super(schema);
-        this.variablesInElement = variablesInElement;
+    constructor(schema, directives) {
+        super(schema, directives);
     }
-    variables() {
-        return (0, definitions_1.mergeVariables)(this.variablesInElement, this.variablesInAppliedDirectives());
+    collectVariables(collector) {
+        this.collectVariablesInElement(collector);
+        this.collectVariablesInAppliedDirectives(collector);
     }
     addAttachement(key, value) {
         if (!this.attachements) {
@@ -42,44 +44,76 @@ class AbstractOperationElement extends definitions_1.DirectiveTargetElement {
     }
 }
 class Field extends AbstractOperationElement {
-    constructor(definition, args = Object.create(null), variableDefinitions = new definitions_1.VariableDefinitions(), alias) {
-        super(definition.schema(), (0, definitions_1.variablesInArguments)(args));
+    constructor(definition, args, directives, alias) {
+        super(definition.schema(), directives);
         this.definition = definition;
         this.args = args;
-        this.variableDefinitions = variableDefinitions;
         this.alias = alias;
         this.kind = 'Field';
     }
+    collectVariablesInElement(collector) {
+        if (this.args) {
+            collector.collectInArguments(this.args);
+        }
+    }
     get name() {
         return this.definition.name;
     }
+    argumentValue(name) {
+        return this.args ? this.args[name] : undefined;
+    }
     responseName() {
         return this.alias ? this.alias : this.name;
     }
+    key() {
+        return this.responseName();
+    }
+    asPathElement() {
+        return this.responseName();
+    }
     get parentType() {
         return this.definition.parent;
     }
+    isLeafField() {
+        return (0, definitions_1.isLeafType)((0, definitions_1.baseType)(this.definition.type));
+    }
     withUpdatedDefinition(newDefinition) {
-        const newField = new Field(newDefinition, this.args, this.variableDefinitions, this.alias);
-        for (const directive of this.appliedDirectives) {
-            newField.applyDirective(directive.definition, directive.arguments());
-        }
+        const newField = new Field(newDefinition, this.args, this.appliedDirectives, this.alias);
         this.copyAttachementsTo(newField);
         return newField;
     }
     withUpdatedAlias(newAlias) {
-        const newField = new Field(this.definition, this.args, this.variableDefinitions, newAlias);
-        for (const directive of this.appliedDirectives) {
-            newField.applyDirective(directive.definition, directive.arguments());
-        }
+        const newField = new Field(this.definition, this.args, this.appliedDirectives, newAlias);
         this.copyAttachementsTo(newField);
         return newField;
     }
+    withUpdatedDirectives(newDirectives) {
+        const newField = new Field(this.definition, this.args, newDirectives, this.alias);
+        this.copyAttachementsTo(newField);
+        return newField;
+    }
+    argumentsToNodes() {
+        if (!this.args) {
+            return undefined;
+        }
+        const entries = Object.entries(this.args);
+        if (entries.length === 0) {
+            return undefined;
+        }
+        return entries.map(([n, v]) => {
+            return {
+                kind: graphql_1.Kind.ARGUMENT,
+                name: { kind: graphql_1.Kind.NAME, value: n },
+                value: (0, values_1.valueToAST)(v, this.definition.argument(n).type),
+            };
+        });
+    }
     appliesTo(type) {
         const definition = type.field(this.name);
         return !!definition && this.selects(definition);
     }
-    selects(definition, assumeValid = false) {
+    selects(definition, assumeValid = false, variableDefinitions) {
+        (0, utils_1.assert)(assumeValid || variableDefinitions, 'Must provide variable definitions if validation is needed');
         if (definition === this.definition) {
             return true;
         }
@@ -87,19 +121,19 @@ class Field extends AbstractOperationElement {
             return false;
         }
         for (const argDef of definition.arguments()) {
-            const appliedValue = this.args[argDef.name];
+            const appliedValue = this.argumentValue(argDef.name);
             if (appliedValue === undefined) {
                 if (argDef.defaultValue === undefined && !(0, definitions_1.isNullableType)(argDef.type)) {
                     return false;
                 }
             }
             else {
-                if (!assumeValid && !(0, values_1.isValidValue)(appliedValue, argDef, this.variableDefinitions)) {
+                if (!assumeValid && !(0, values_1.isValidValue)(appliedValue, argDef, variableDefinitions)) {
                     return false;
                 }
             }
         }
-        if (!assumeValid) {
+        if (!assumeValid && this.args) {
             for (const [name, value] of Object.entries(this.args)) {
                 if (value !== null && definition.argument(name) === undefined) {
                     return false;
@@ -108,39 +142,41 @@ class Field extends AbstractOperationElement {
         }
         return true;
     }
-    validate() {
+    validate(variableDefinitions) {
         validate(this.name === this.definition.name, () => `Field name "${this.name}" cannot select field "${this.definition.coordinate}: name mismatch"`);
         for (const argDef of this.definition.arguments()) {
-            const appliedValue = this.args[argDef.name];
+            const appliedValue = this.argumentValue(argDef.name);
             if (appliedValue === undefined) {
                 validate(argDef.defaultValue !== undefined || (0, definitions_1.isNullableType)(argDef.type), () => `Missing mandatory value for argument "${argDef.name}" of field "${this.definition.coordinate}" in selection "${this}"`);
             }
             else {
-                validate((0, values_1.isValidValue)(appliedValue, argDef, this.variableDefinitions), () => `Invalid value ${(0, values_1.valueToString)(appliedValue)} for argument "${argDef.coordinate}" of type ${argDef.type}`);
+                validate((0, values_1.isValidValue)(appliedValue, argDef, variableDefinitions), () => `Invalid value ${(0, values_1.valueToString)(appliedValue)} for argument "${argDef.coordinate}" of type ${argDef.type}`);
             }
         }
-        for (const [name, value] of Object.entries(this.args)) {
-            validate(value === null || this.definition.argument(name) !== undefined, () => `Unknown argument "${name}" in field application of "${this.name}"`);
+        if (this.args) {
+            for (const [name, value] of Object.entries(this.args)) {
+                validate(value === null || this.definition.argument(name) !== undefined, () => `Unknown argument "${name}" in field application of "${this.name}"`);
+            }
         }
     }
-    updateForAddingTo(selectionSet) {
-        const selectionParent = selectionSet.parentType;
+    rebaseOn(parentType) {
         const fieldParent = this.definition.parent;
-        if (selectionParent === fieldParent) {
+        if (parentType === fieldParent) {
             return this;
         }
         if (this.name === definitions_1.typenameFieldName) {
-            return this.withUpdatedDefinition(selectionParent.typenameField());
+            return this.withUpdatedDefinition(parentType.typenameField());
         }
-        validate(this.canRebaseOn(selectionParent), () => `Cannot add selection of field "${this.definition.coordinate}" to selection set of parent type "${selectionParent}"`);
-        const fieldDef = selectionParent.field(this.name);
-        validate(fieldDef, () => `Cannot add selection of field "${this.definition.coordinate}" to selection set of parent type "${selectionParent}" (that does not declare that field)`);
+        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)`);
         return this.withUpdatedDefinition(fieldDef);
     }
     canRebaseOn(parentType) {
         const fieldParentType = this.definition.parent;
         return parentType.name === fieldParentType.name
-            || ((0, definitions_1.isInterfaceType)(fieldParentType) && fieldParentType.allImplementations().some(i => i.name === parentType.name));
+            || (0, definitions_1.isInterfaceType)(fieldParentType)
+            || (0, federation_1.isInterfaceObjectType)(fieldParentType);
     }
     typeIfAddedTo(parentType) {
         var _a, _b;
@@ -171,34 +207,56 @@ class Field extends AbstractOperationElement {
         return that.kind === 'Field'
             && this.name === that.name
             && this.alias === that.alias
-            && (0, values_1.argumentsEquals)(this.args, that.args)
+            && (this.args ? that.args && (0, values_1.argumentsEquals)(this.args, that.args) : !that.args)
             && haveSameDirectives(this, that);
     }
     toString() {
         const alias = this.alias ? this.alias + ': ' : '';
-        const entries = Object.entries(this.args);
-        const args = entries.length == 0
+        const entries = this.args ? Object.entries(this.args) : [];
+        const args = entries.length === 0
             ? ''
             : '(' + entries.map(([n, v]) => { var _a; return `${n}: ${(0, values_1.valueToString)(v, (_a = this.definition.argument(n)) === null || _a === void 0 ? void 0 : _a.type)}`; }).join(', ') + ')';
         return alias + this.name + args + this.appliedDirectivesToString();
     }
 }
 exports.Field = Field;
+function keyForDirective(directive, directivesNeverEqualToThemselves = ['defer']) {
+    if (directivesNeverEqualToThemselves.includes(directive.name)) {
+        return (0, uuid_1.v1)();
+    }
+    const entries = Object.entries(directive.arguments()).filter(([_, v]) => v !== undefined);
+    entries.sort(([n1], [n2]) => n1.localeCompare(n2));
+    const args = entries.length == 0 ? '' : '(' + entries.map(([n, v]) => `${n}: ${(0, values_1.valueToString)(v, directive.argumentType(n))}`).join(', ') + ')';
+    return `@${directive.name}${args}`;
+}
 class FragmentElement extends AbstractOperationElement {
-    constructor(sourceType, typeCondition) {
-        super(sourceType.schema(), []);
+    constructor(sourceType, typeCondition, directives) {
+        super(sourceType.schema(), directives);
         this.sourceType = sourceType;
         this.kind = 'FragmentElement';
         this.typeCondition = typeCondition !== undefined && typeof typeCondition === 'string'
             ? this.schema().type(typeCondition)
             : typeCondition;
     }
+    collectVariablesInElement(_) {
+    }
     get parentType() {
         return this.sourceType;
     }
+    key() {
+        if (!this.computedKey) {
+            const keyForDirectives = this.appliedDirectives.map((d) => keyForDirective(d)).join(' ');
+            this.computedKey = '...' + (this.typeCondition ? ' on ' + this.typeCondition.name : '') + keyForDirectives;
+        }
+        return this.computedKey;
+    }
     castedType() {
         return this.typeCondition ? this.typeCondition : this.sourceType;
     }
+    asPathElement() {
+        const condition = this.typeCondition;
+        return condition ? `... on ${condition}` : undefined;
+    }
     withUpdatedSourceType(newSourceType) {
         return this.withUpdatedTypes(newSourceType, this.typeCondition);
     }
@@ -206,23 +264,24 @@ class FragmentElement extends AbstractOperationElement {
         return this.withUpdatedTypes(this.sourceType, newCondition);
     }
     withUpdatedTypes(newSourceType, newCondition) {
-        const newFragment = new FragmentElement(newSourceType, newCondition === null || newCondition === void 0 ? void 0 : newCondition.name);
-        for (const directive of this.appliedDirectives) {
-            newFragment.applyDirective(directive.definition, directive.arguments());
-        }
+        const newFragment = new FragmentElement(newSourceType, newCondition === null || newCondition === void 0 ? void 0 : newCondition.name, this.appliedDirectives);
+        this.copyAttachementsTo(newFragment);
+        return newFragment;
+    }
+    withUpdatedDirectives(newDirectives) {
+        const newFragment = new FragmentElement(this.sourceType, this.typeCondition, newDirectives);
         this.copyAttachementsTo(newFragment);
         return newFragment;
     }
-    updateForAddingTo(selectionSet) {
-        const selectionParent = selectionSet.parentType;
+    rebaseOn(parentType) {
         const fragmentParent = this.parentType;
         const typeCondition = this.typeCondition;
-        if (selectionParent === fragmentParent) {
+        if (parentType === fragmentParent) {
             return this;
         }
-        const { canRebase, rebasedCondition } = this.canRebaseOn(selectionParent);
-        validate(canRebase, () => `Cannot add fragment of condition "${typeCondition}" (runtimes: [${(0, definitions_1.possibleRuntimeTypes)(typeCondition)}]) to selection set of parent type "${selectionParent}" (runtimes: ${(0, definitions_1.possibleRuntimeTypes)(selectionParent)})`);
-        return this.withUpdatedTypes(selectionParent, rebasedCondition);
+        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)})`);
+        return this.withUpdatedTypes(parentType, rebasedCondition);
     }
     canRebaseOn(parentType) {
         if (!this.typeCondition) {
@@ -260,9 +319,8 @@ class FragmentElement extends AbstractOperationElement {
         if (updatedDirectives.length === this.appliedDirectives.length) {
             return this;
         }
-        const updated = new FragmentElement(this.sourceType, this.typeCondition);
+        const updated = new FragmentElement(this.sourceType, this.typeCondition, updatedDirectives);
         this.copyAttachementsTo(updated);
-        updatedDirectives.forEach((d) => updated.applyDirective(d.definition, d.arguments()));
         return updated;
     }
     withNormalizedDefer(normalizer) {
@@ -307,11 +365,12 @@ class FragmentElement extends AbstractOperationElement {
         if (!newDeferArgs) {
             return this;
         }
-        const updated = new FragmentElement(this.sourceType, this.typeCondition);
-        this.copyAttachementsTo(updated);
         const deferDirective = this.schema().deferDirective();
-        this.appliedDirectives.filter((d) => d.name !== deferDirective.name).forEach((d) => updated.applyDirective(d.definition, d.arguments()));
-        updated.applyDirective(this.schema().deferDirective(), newDeferArgs);
+        const updatedDirectives = this.appliedDirectives
+            .filter((d) => d.name !== deferDirective.name)
+            .concat(new definitions_1.Directive(deferDirective.name, newDeferArgs));
+        const updated = new FragmentElement(this.sourceType, this.typeCondition, updatedDirectives);
+        this.copyAttachementsTo(updated);
         return updated;
     }
     equals(that) {
@@ -389,6 +448,7 @@ class Operation {
         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;
@@ -405,16 +465,24 @@ class Operation {
             }
         }
         const toDeoptimize = (0, utils_1.mapEntries)(usages).filter(([_, count]) => count < minUsagesToOptimize).map(([name]) => name);
-        optimizedSelection = optimizedSelection.expandFragments(toDeoptimize);
+        const newFragments = (_a = optimizedSelection.fragments) === null || _a === void 0 ? void 0 : _a.without(toDeoptimize);
+        optimizedSelection = optimizedSelection.expandFragments(toDeoptimize, newFragments);
         return new Operation(this.schema, this.rootKind, optimizedSelection, this.variableDefinitions, this.name);
     }
     expandAllFragments() {
-        const expandedSelections = this.selectionSet.expandFragments();
+        const expandedSelections = this.selectionSet.expandAllFragments();
         if (expandedSelections === this.selectionSet) {
             return this;
         }
         return new Operation(this.schema, this.rootKind, expandedSelections, this.variableDefinitions, 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);
+    }
     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);
@@ -452,35 +520,23 @@ class Operation {
     }
 }
 exports.Operation = Operation;
-function addDirectiveNodesToElement(directiveNodes, element) {
-    if (!directiveNodes) {
-        return;
-    }
-    const schema = element.schema();
-    for (const node of directiveNodes) {
-        const directiveDef = schema.directive(node.name.value);
-        validate(directiveDef, () => `Unknown directive "@${node.name.value}" in selection`);
-        element.applyDirective(directiveDef, (0, values_1.argumentsFromAST)(directiveDef.coordinate, node.arguments, directiveDef));
-    }
-}
-function selectionSetOf(parentType, selection) {
-    const selectionSet = new SelectionSet(parentType);
-    selectionSet.add(selection);
-    return selectionSet;
-}
-exports.selectionSetOf = selectionSetOf;
 class NamedFragmentDefinition extends definitions_1.DirectiveTargetElement {
-    constructor(schema, name, typeCondition, selectionSet) {
-        super(schema);
+    constructor(schema, name, typeCondition, directives) {
+        super(schema, directives);
         this.name = name;
         this.typeCondition = typeCondition;
-        this.selectionSet = selectionSet;
     }
-    withUpdatedSelectionSet(newSelectionSet) {
-        return new NamedFragmentDefinition(this.schema(), this.name, this.typeCondition, newSelectionSet);
+    setSelectionSet(selectionSet) {
+        (0, utils_1.assert)(!this._selectionSet, 'Attempting to set the selection set of a fragment definition already built');
+        this._selectionSet = selectionSet;
+        return this;
     }
-    variables() {
-        return (0, definitions_1.mergeVariables)(this.variablesInAppliedDirectives(), this.selectionSet.usedVariables());
+    get selectionSet() {
+        (0, utils_1.assert)(this._selectionSet, () => `Trying to access fragment definition ${this.name} before it is fully built`);
+        return this._selectionSet;
+    }
+    withUpdatedSelectionSet(newSelectionSet) {
+        return new NamedFragmentDefinition(this.schema(), this.name, this.typeCondition).setSelectionSet(newSelectionSet);
     }
     collectUsedFragmentNames(collector) {
         this.selectionSet.collectUsedFragmentNames(collector);
@@ -503,8 +559,7 @@ class NamedFragmentDefinition extends definitions_1.DirectiveTargetElement {
         };
     }
     canApplyAtType(type) {
-        const applyAtType = (0, types_1.sameType)(this.typeCondition, type)
-            || ((0, definitions_1.isAbstractType)(this.typeCondition) && !(0, definitions_1.isUnionType)(type) && (0, types_1.isDirectSubtype)(this.typeCondition, type));
+        const applyAtType = (0, types_1.sameType)(type, this.typeCondition) || (0, definitions_1.runtimeTypesIntersects)(type, this.typeCondition);
         return applyAtType
             && this.validForSchema(type.schema());
     }
@@ -517,8 +572,7 @@ class NamedFragmentDefinition extends definitions_1.DirectiveTargetElement {
             return false;
         }
         try {
-            const rebasedSelection = new SelectionSet(typeInSchema);
-            rebasedSelection.mergeIn(this.selectionSet);
+            this.selectionSet.rebaseOn(typeInSchema);
             return true;
         }
         catch (e) {
@@ -537,13 +591,6 @@ class NamedFragments {
     isEmpty() {
         return this.fragments.size === 0;
     }
-    variables() {
-        let variables = [];
-        for (const fragment of this.fragments.values()) {
-            variables = (0, definitions_1.mergeVariables)(variables, fragment.variables());
-        }
-        return variables;
-    }
     names() {
         return this.fragments.keys();
     }
@@ -568,14 +615,14 @@ class NamedFragments {
         const newFragments = new NamedFragments();
         for (const fragment of this.fragments.values()) {
             if (!names.includes(fragment.name)) {
-                const updatedSelection = fragment.selectionSet.expandFragments(names, false);
-                const newFragment = updatedSelection === fragment.selectionSet
+                const updatedSelectionSet = fragment.selectionSet.expandFragments(names, newFragments);
+                const newFragment = updatedSelectionSet === fragment.selectionSet
                     ? fragment
-                    : new NamedFragmentDefinition(fragment.schema(), fragment.name, fragment.typeCondition, updatedSelection);
+                    : fragment.withUpdatedSelectionSet(updatedSelectionSet);
                 newFragments.add(newFragment);
             }
         }
-        return newFragments;
+        return newFragments.isEmpty() ? undefined : newFragments;
     }
     get(name) {
         return this.fragments.get(name);
@@ -586,9 +633,16 @@ class NamedFragments {
     definitions() {
         return this.fragments.values();
     }
-    validate() {
+    map(mapper) {
+        const mapped = new NamedFragments();
+        for (const def of this.fragments.values()) {
+            mapped.fragments.set(def.name, mapper(def));
+        }
+        return mapped;
+    }
+    validate(variableDefinitions) {
         for (const fragment of this.fragments.values()) {
-            fragment.selectionSet.validate();
+            fragment.selectionSet.validate(variableDefinitions);
         }
     }
     toFragmentDefinitionNodes() {
@@ -599,24 +653,6 @@ class NamedFragments {
     }
 }
 exports.NamedFragments = NamedFragments;
-class Freezable {
-    constructor() {
-        this._isFrozen = false;
-    }
-    freeze() {
-        if (!this.isFrozen()) {
-            this.freezeInternals();
-            this._isFrozen = true;
-        }
-        return this.us();
-    }
-    isFrozen() {
-        return this._isFrozen;
-    }
-    cloneIfFrozen() {
-        return this.isFrozen() ? this.clone() : this.us();
-    }
-}
 class DeferNormalizer {
     constructor() {
         this.index = 0;
@@ -631,7 +667,7 @@ class DeferNormalizer {
         while (stack.length > 0) {
             const selection = stack.pop();
             if (selection.kind === 'FragmentSelection') {
-                const deferArgs = selection.element().deferDirectiveArgs();
+                const deferArgs = selection.element.deferDirectiveArgs();
                 if (deferArgs) {
                     hasDefers = true;
                     if (!deferArgs.label || deferArgs.if !== undefined) {
@@ -663,132 +699,103 @@ class DeferNormalizer {
         this.deferConditions.add(condition.name, label);
     }
 }
-class SelectionSet extends Freezable {
-    constructor(parentType, fragments) {
-        super();
+class SelectionSet {
+    constructor(parentType, keyedSelections = new Map(), fragments) {
         this.parentType = parentType;
         this.fragments = fragments;
-        this._selections = new utils_1.MultiMap();
-        this._selectionCount = 0;
-        validate(!(0, definitions_1.isLeafType)(parentType), () => `Cannot have selection on non-leaf type ${parentType}`);
+        this._keyedSelections = keyedSelections;
+        this._selections = (0, utils_1.mapValues)(keyedSelections);
     }
-    us() {
-        return this;
-    }
-    selections(reversedOrder = false) {
-        if (!this._cachedSelections) {
-            const selections = new Array(this._selectionCount);
-            let idx = 0;
-            for (const byResponseName of this._selections.values()) {
-                for (const selection of byResponseName) {
-                    selections[idx++] = selection;
-                }
-            }
-            this._cachedSelections = selections;
+    selectionsInReverseOrder() {
+        const length = this._selections.length;
+        const reversed = new Array(length);
+        for (let i = 0; i < length; i++) {
+            reversed[i] = this._selections[length - i - 1];
         }
-        (0, utils_1.assert)(this._cachedSelections, 'Cache should have been populated');
-        if (reversedOrder && this._cachedSelections.length > 1) {
-            const reversed = new Array(this._selectionCount);
-            for (let i = 0; i < this._selectionCount; i++) {
-                reversed[i] = this._cachedSelections[this._selectionCount - i - 1];
-            }
-            return reversed;
-        }
-        return this._cachedSelections;
+        return reversed;
+    }
+    selections() {
+        return this._selections;
+    }
+    hasTopLevelTypenameField() {
+        return this._keyedSelections.has(definitions_1.typenameFieldName);
     }
     fieldsInSet() {
         const fields = new Array();
         for (const selection of this.selections()) {
             if (selection.kind === 'FieldSelection') {
-                fields.push({ path: [], field: selection, directParent: this });
+                fields.push({ path: [], field: selection });
             }
             else {
-                const condition = selection.element().typeCondition;
+                const condition = selection.element.typeCondition;
                 const header = condition ? [`... on ${condition}`] : [];
-                for (const { path, field, directParent } of selection.selectionSet.fieldsInSet()) {
-                    fields.push({ path: header.concat(path), field, directParent });
+                for (const { path, field } of selection.selectionSet.fieldsInSet()) {
+                    fields.push({ path: header.concat(path), field });
                 }
             }
         }
         return fields;
     }
     usedVariables() {
-        let variables = [];
-        for (const byResponseName of this._selections.values()) {
-            for (const selection of byResponseName) {
-                variables = (0, definitions_1.mergeVariables)(variables, selection.usedVariables());
-            }
-        }
-        if (this.fragments) {
-            variables = (0, definitions_1.mergeVariables)(variables, this.fragments.variables());
+        const collector = new definitions_1.VariableCollector();
+        this.collectVariables(collector);
+        return collector.variables();
+    }
+    collectVariables(collector) {
+        for (const selection of this.selections()) {
+            selection.collectVariables(collector);
         }
-        return variables;
     }
     collectUsedFragmentNames(collector) {
-        for (const byResponseName of this._selections.values()) {
-            for (const selection of byResponseName) {
-                selection.collectUsedFragmentNames(collector);
-            }
+        for (const selection of this.selections()) {
+            selection.collectUsedFragmentNames(collector);
         }
     }
     optimize(fragments) {
         if (!fragments || fragments.isEmpty()) {
             return this;
         }
-        if (this.fragments && this.fragments.definitions().some(def => fragments.get(def.name))) {
-            return this;
-        }
-        const optimized = new SelectionSet(this.parentType, fragments);
-        for (const selection of this.selections()) {
-            optimized.add(selection.optimize(fragments));
-        }
-        return optimized;
+        (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 });
     }
-    expandFragments(names, updateSelectionSetFragments = true) {
-        var _a;
-        if (names && names.length === 0) {
+    expandAllFragments() {
+        return this.lazyMap((selection) => selection.expandAllFragments(), { fragments: null });
+    }
+    expandFragments(names, updatedFragments) {
+        if (names.length === 0) {
             return this;
         }
-        const newFragments = updateSelectionSetFragments
-            ? (names ? (_a = this.fragments) === null || _a === void 0 ? void 0 : _a.without(names) : undefined)
-            : this.fragments;
-        const withExpanded = new SelectionSet(this.parentType, newFragments);
-        for (const selection of this.selections()) {
-            const expanded = selection.expandFragments(names, updateSelectionSetFragments);
-            if (Array.isArray(expanded)) {
-                withExpanded.addAll(expanded);
-            }
-            else {
-                withExpanded.add(expanded);
-            }
-        }
-        return withExpanded;
+        return this.lazyMap((selection) => selection.expandFragments(names, updatedFragments), { fragments: updatedFragments !== null && updatedFragments !== void 0 ? updatedFragments : null });
     }
-    lazyMap(mapper) {
-        let updatedSelections = undefined;
+    trimUnsatisfiableBranches(parentType) {
+        return this.lazyMap((selection) => selection.trimUnsatisfiableBranches(parentType), { parentType });
+    }
+    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];
             const updated = mapper(selection);
             if (updated !== selection && !updatedSelections) {
-                updatedSelections = [];
+                updatedSelections = new SelectionSetUpdates();
                 for (let j = 0; j < i; j++) {
-                    updatedSelections.push(selections[j]);
+                    updatedSelections.add(selections[j]);
                 }
             }
             if (!!updated && updatedSelections) {
-                if (updated instanceof SelectionSet) {
-                    updated.selections().forEach((s) => updatedSelections.push(s));
-                }
-                else {
-                    updatedSelections.push(updated);
-                }
+                updatedSelections.add(updated);
             }
         }
         if (!updatedSelections) {
-            return this;
+            return this.withUpdatedFragments(newFragments);
         }
-        return new SelectionSet(this.parentType, this.fragments).addAll(updatedSelections);
+        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);
     }
     withoutDefer(labelsToRemove) {
         (0, utils_1.assert)(!this.fragments, 'Not yet supported');
@@ -798,6 +805,9 @@ class SelectionSet extends Freezable {
         (0, utils_1.assert)(!this.fragments, 'Not yet supported');
         return this.lazyMap((selection) => selection.withNormalizedDefer(normalizer));
     }
+    hasDefer() {
+        return this.selections().some((s) => s.hasDefer());
+    }
     filter(predicate) {
         return this.lazyMap((selection) => selection.filter(predicate));
     }
@@ -805,169 +815,108 @@ class SelectionSet extends Freezable {
         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;
     }
-    freezeInternals() {
-        for (const selection of this.selections()) {
-            selection.freeze();
-        }
-    }
-    mergeIn(selectionSet) {
-        for (const selection of selectionSet.selections()) {
-            this.add(selection);
-        }
-    }
-    addAll(selections) {
-        selections.forEach(s => this.add(s));
-        return this;
-    }
-    add(selection) {
-        (0, utils_1.assert)(!this.isFrozen(), () => `Cannot add to frozen selection: ${this}`);
-        const toAdd = selection.updateForAddingTo(this);
-        const key = toAdd.key();
-        const existing = this._selections.get(key);
-        if (existing) {
-            for (const existingSelection of existing) {
-                if (existingSelection.kind === toAdd.kind && haveSameDirectives(existingSelection.element(), toAdd.element())) {
-                    if (toAdd.selectionSet) {
-                        existingSelection.selectionSet.mergeIn(toAdd.selectionSet);
-                    }
-                    return existingSelection;
-                }
-            }
-        }
-        this._selections.add(key, toAdd);
-        ++this._selectionCount;
-        this._cachedSelections = undefined;
-        return toAdd;
-    }
-    removeTopLevelField(responseName) {
-        (0, utils_1.assert)(!this.isFrozen(), () => `Cannot remove from frozen selection: ${this}`);
-        const wasRemoved = this._selections.delete(responseName);
-        if (wasRemoved) {
-            --this._selectionCount;
-            this._cachedSelections = undefined;
-        }
-        return wasRemoved;
-    }
-    addPath(path, onPathEnd) {
-        let previousSelections = this;
-        let currentSelections = this;
-        for (const element of path) {
-            validate(currentSelections, () => `Cannot apply selection ${element} to non-selectable parent type "${previousSelections.parentType}"`);
-            const mergedSelection = currentSelections.add(selectionOfElement(element));
-            previousSelections = currentSelections;
-            currentSelections = mergedSelection.selectionSet;
-        }
-        if (onPathEnd) {
-            onPathEnd(currentSelections);
-        }
-    }
-    addSelectionSetNode(node, variableDefinitions, fieldAccessor = (type, name) => type.field(name)) {
-        if (!node) {
-            return;
-        }
-        for (const selectionNode of node.selections) {
-            this.addSelectionNode(selectionNode, variableDefinitions, fieldAccessor);
+    rebaseOn(parentType) {
+        if (this.parentType === parentType) {
+            return this;
         }
-    }
-    addSelectionNode(node, variableDefinitions, fieldAccessor = (type, name) => type.field(name)) {
-        this.add(this.nodeToSelection(node, variableDefinitions, fieldAccessor));
-    }
-    nodeToSelection(node, variableDefinitions, fieldAccessor) {
-        var _a, _b;
-        let selection;
-        switch (node.kind) {
-            case graphql_1.Kind.FIELD:
-                const definition = fieldAccessor(this.parentType, node.name.value);
-                validate(definition, () => `Cannot query field "${node.name.value}" on type "${this.parentType}".`, this.parentType.sourceAST);
-                const type = (0, definitions_1.baseType)(definition.type);
-                selection = new FieldSelection(new Field(definition, (0, values_1.argumentsFromAST)(definition.coordinate, node.arguments, definition), variableDefinitions, (_a = node.alias) === null || _a === void 0 ? void 0 : _a.value), (0, definitions_1.isLeafType)(type) ? undefined : new SelectionSet(type, this.fragments));
-                if (node.selectionSet) {
-                    validate(selection.selectionSet, () => `Unexpected selection set on leaf field "${selection.element()}"`, selection.element().definition.sourceAST);
-                    selection.selectionSet.addSelectionSetNode(node.selectionSet, variableDefinitions, fieldAccessor);
-                }
-                break;
-            case graphql_1.Kind.INLINE_FRAGMENT:
-                const element = new FragmentElement(this.parentType, (_b = node.typeCondition) === null || _b === void 0 ? void 0 : _b.name.value);
-                selection = new InlineFragmentSelection(element, new SelectionSet(element.typeCondition ? element.typeCondition : element.parentType, this.fragments));
-                selection.selectionSet.addSelectionSetNode(node.selectionSet, variableDefinitions, fieldAccessor);
-                break;
-            case graphql_1.Kind.FRAGMENT_SPREAD:
-                const fragmentName = node.name.value;
-                validate(this.fragments, () => `Cannot find fragment name "${fragmentName}" (no fragments were provided)`);
-                selection = new FragmentSpreadSelection(this.parentType, this.fragments, fragmentName);
-                break;
+        const newSelections = new Map();
+        for (const selection of this.selections()) {
+            newSelections.set(selection.key(), selection.rebaseOn(parentType));
         }
-        addDirectiveNodesToElement(node.directives, selection.element());
-        return selection;
+        return new SelectionSet(parentType, newSelections, this.fragments);
     }
     equals(that) {
         if (this === that) {
             return true;
         }
-        if (this._selections.size !== that._selections.size) {
+        if (this._selections.length !== that._selections.length) {
             return false;
         }
-        for (const [key, thisSelections] of this._selections) {
-            const thatSelections = that._selections.get(key);
-            if (!thatSelections
-                || thisSelections.length !== thatSelections.length
-                || !thisSelections.every(thisSelection => thatSelections.some(thatSelection => thisSelection.equals(thatSelection)))) {
+        for (const [key, thisSelection] of this._keyedSelections) {
+            const thatSelection = that._keyedSelections.get(key);
+            if (!thatSelection || !thisSelection.equals(thatSelection)) {
                 return false;
             }
         }
         return true;
     }
-    contains(that) {
-        if (this._selections.size < that._selections.size) {
-            return false;
+    triviallyNestedSelectionsForKey(parentType, key) {
+        const found = [];
+        for (const selection of this.selections()) {
+            if (selection.isUnecessaryInlineFragment(parentType)) {
+                const selectionForKey = selection.selectionSet._keyedSelections.get(key);
+                if (selectionForKey) {
+                    found.push(selectionForKey);
+                }
+                for (const nestedSelection of selection.selectionSet.triviallyNestedSelectionsForKey(parentType, key)) {
+                    found.push(nestedSelection);
+                }
+            }
+        }
+        return found;
+    }
+    mergeSameKeySelections(selections) {
+        if (selections.length === 0) {
+            return undefined;
         }
-        for (const [key, thatSelections] of that._selections) {
-            const thisSelections = this._selections.get(key);
-            if (!thisSelections
-                || (thisSelections.length < thatSelections.length
-                    || !thatSelections.every(thatSelection => thisSelections.some(thisSelection => thisSelection.contains(thatSelection))))) {
+        const first = selections[0];
+        if (!first.selectionSet || (first instanceof FragmentSpreadSelection) || selections.length === 1) {
+            return first;
+        }
+        const mergedSubselections = new SelectionSetUpdates();
+        for (const selection of selections) {
+            mergedSubselections.add(selection.selectionSet);
+        }
+        return first.withUpdatedSelectionSet(mergedSubselections.toSelectionSet(first.selectionSet.parentType));
+    }
+    contains(that) {
+        for (const [key, thatSelection] of that._keyedSelections) {
+            const thisSelection = this._keyedSelections.get(key);
+            const otherSelections = this.triviallyNestedSelectionsForKey(this.parentType, key);
+            const mergedSelection = this.mergeSameKeySelections([thisSelection].concat(otherSelections).filter(utils_1.isDefined));
+            if (!(mergedSelection && mergedSelection.contains(thatSelection))
+                && !(thatSelection.isUnecessaryInlineFragment(this.parentType) && this.contains(thatSelection.selectionSet))) {
                 return false;
             }
         }
         return true;
     }
+    diffIfContains(that) {
+        if (this.contains(that)) {
+            const diff = this.minus(that);
+            return { contains: true, diff: diff.isEmpty() ? undefined : diff };
+        }
+        return { contains: false };
+    }
     minus(that) {
-        const updated = new SelectionSet(this.parentType, this.fragments);
-        for (const [key, thisSelections] of this._selections) {
-            const thatSelections = that._selections.get(key);
-            if (!thatSelections) {
-                updated._selections.set(key, thisSelections);
+        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);
             }
             else {
-                for (const thisSelection of thisSelections) {
-                    const thatSelection = thatSelections.find((s) => thisSelection.element().equals(s.element()));
-                    if (thatSelection) {
-                        if (thisSelection.selectionSet && thatSelection.selectionSet) {
-                            const updatedSubSelectionSet = thisSelection.selectionSet.minus(thatSelection.selectionSet);
-                            if (!updatedSubSelectionSet.isEmpty()) {
-                                updated._selections.add(key, thisSelection.withUpdatedSubSelection(updatedSubSelectionSet));
-                            }
-                        }
-                    }
-                    else {
-                        updated._selections.add(key, thisSelection);
-                    }
+                const selectionDiff = allSelections.reduce((prev, val) => prev === null || prev === void 0 ? void 0 : prev.minus(val), thisSelection);
+                if (selectionDiff) {
+                    updated.add(selectionDiff);
                 }
             }
         }
-        return updated;
+        return updated.toSelectionSet(this.parentType, this.fragments);
     }
     canRebaseOn(parentTypeToTest) {
         return this.selections().every((selection) => selection.canAddTo(parentTypeToTest));
     }
-    validate() {
+    validate(variableDefinitions) {
         validate(!this.isEmpty(), () => `Invalid empty selection set`);
         for (const selection of this.selections()) {
-            selection.validate();
+            selection.validate(variableDefinitions);
         }
     }
     isEmpty() {
-        return this._selections.size === 0;
+        return this._selections.length === 0;
     }
     toSelectionSetNode() {
         if (this.isEmpty()) {
@@ -988,13 +937,13 @@ class SelectionSet extends Freezable {
         };
     }
     selectionsInPrintOrder() {
-        const typenameSelection = this._selections.get(definitions_1.typenameFieldName);
-        const isNonAliasedTypenameSelection = (s) => s.kind === 'FieldSelection' && !s.field.alias && s.field.name === definitions_1.typenameFieldName;
+        const isNonAliasedTypenameSelection = (s) => s.kind === 'FieldSelection' && !s.element.alias && s.element.name === definitions_1.typenameFieldName;
+        const typenameSelection = this._selections.find((s) => isNonAliasedTypenameSelection(s));
         if (typenameSelection) {
-            return typenameSelection.concat(this.selections().filter(s => !isNonAliasedTypenameSelection(s)));
+            return [typenameSelection].concat(this.selections().filter(s => !isNonAliasedTypenameSelection(s)));
         }
         else {
-            return this.selections();
+            return this._selections;
         }
     }
     toOperationPaths() {
@@ -1002,7 +951,7 @@ class SelectionSet extends Freezable {
     }
     toOperationPathsInternal(parentPaths) {
         return this.selections().flatMap((selection) => {
-            const updatedPaths = parentPaths.map(path => path.concat(selection.element()));
+            const updatedPaths = parentPaths.map(path => path.concat(selection.element));
             return selection.selectionSet
                 ? selection.selectionSet.toOperationPathsInternal(updatedPaths)
                 : updatedPaths;
@@ -1010,21 +959,20 @@ class SelectionSet extends Freezable {
     }
     forEachElement(callback) {
         var _a;
-        const stack = this.selections().concat();
+        const stack = this.selectionsInReverseOrder().concat();
         while (stack.length > 0) {
             const selection = stack.pop();
-            callback(selection.element());
-            (_a = selection.selectionSet) === null || _a === void 0 ? void 0 : _a.selections(true).forEach((s) => stack.push(s));
+            callback(selection.element);
+            (_a = selection.selectionSet) === null || _a === void 0 ? void 0 : _a.selectionsInReverseOrder().forEach((s) => stack.push(s));
         }
     }
-    clone() {
-        const cloned = new SelectionSet(this.parentType);
+    some(predicate) {
         for (const selection of this.selections()) {
-            const clonedSelection = selection.clone();
-            cloned._selections.add(clonedSelection.key(), clonedSelection);
-            ++cloned._selectionCount;
+            if (predicate(selection.element) || (selection.selectionSet && selection.selectionSet.some(predicate))) {
+                return true;
+            }
         }
-        return cloned;
+        return false;
     }
     toOperationString(rootKind, variableDefinitions, operationName, expandFragments = false, prettyPrint = true) {
         const indent = prettyPrint ? '' : undefined;
@@ -1040,6 +988,9 @@ class SelectionSet extends Freezable {
         return fragmentsDefinitions + rootKind + nameAndVariables + " " + this.toString(expandFragments, true, indent);
     }
     toString(expandFragments = true, includeExternalBrackets = true, indent) {
+        if (this.isEmpty()) {
+            return '{}';
+        }
         if (indent === undefined) {
             const selectionsToString = this.selections().map(s => s.toString(expandFragments)).join(' ');
             return includeExternalBrackets ? '{ ' + selectionsToString + ' }' : selectionsToString;
@@ -1054,13 +1005,212 @@ class SelectionSet extends Freezable {
     }
 }
 exports.SelectionSet = SelectionSet;
+class SelectionSetUpdates {
+    constructor() {
+        this.keyedUpdates = new utils_1.MultiMap;
+    }
+    isEmpty() {
+        return this.keyedUpdates.size === 0;
+    }
+    add(selections) {
+        addToKeyedUpdates(this.keyedUpdates, selections);
+        return this;
+    }
+    addAtPath(path, selections) {
+        if (path.length === 0) {
+            if (selections) {
+                addToKeyedUpdates(this.keyedUpdates, selections);
+            }
+        }
+        else {
+            if (path.length === 1 && !selections) {
+                const element = path[0];
+                if (element.kind === 'Field' && element.isLeafField()) {
+                    const selection = selectionOfElement(element);
+                    this.keyedUpdates.add(selection.key(), selection);
+                    return this;
+                }
+            }
+            this.keyedUpdates.add(path[0].key(), { path, selections });
+        }
+        return this;
+    }
+    clone() {
+        const cloned = new SelectionSetUpdates();
+        for (const [key, values] of this.keyedUpdates.entries()) {
+            cloned.keyedUpdates.set(key, Array.from(values));
+        }
+        return cloned;
+    }
+    clear() {
+        this.keyedUpdates.clear();
+    }
+    toSelectionSet(parentType, fragments) {
+        return makeSelectionSet(parentType, this.keyedUpdates, fragments);
+    }
+}
+exports.SelectionSetUpdates = SelectionSetUpdates;
+function addToKeyedUpdates(keyedUpdates, selections) {
+    if (selections instanceof AbstractSelection) {
+        addOneToKeyedUpdates(keyedUpdates, selections);
+    }
+    else {
+        const toAdd = selections instanceof SelectionSet ? selections.selections() : selections;
+        for (const selection of toAdd) {
+            addOneToKeyedUpdates(keyedUpdates, selection);
+        }
+    }
+}
+function addOneToKeyedUpdates(keyedUpdates, selection) {
+    if (selection instanceof FragmentSpreadSelection) {
+        keyedUpdates.set(selection.key(), [selection]);
+    }
+    else {
+        keyedUpdates.add(selection.key(), selection);
+    }
+}
+function isUnecessaryFragment(parentType, fragment) {
+    return fragment.element.appliedDirectives.length === 0
+        && (!fragment.element.typeCondition || (0, types_1.sameType)(parentType, fragment.element.typeCondition));
+}
+function withUnecessaryFragmentsRemoved(parentType, selections) {
+    if (selections instanceof AbstractSelection) {
+        if (selections.kind !== 'FragmentSelection' || !isUnecessaryFragment(parentType, selections)) {
+            return selections;
+        }
+        return withUnecessaryFragmentsRemoved(parentType, selections.selectionSet);
+    }
+    const toCheck = selections instanceof SelectionSet ? selections.selections() : selections;
+    const filtered = [];
+    for (const selection of toCheck) {
+        if (selection.kind === 'FragmentSelection' && isUnecessaryFragment(parentType, selection)) {
+            const subSelections = withUnecessaryFragmentsRemoved(parentType, selection.selectionSet);
+            if (subSelections instanceof AbstractSelection) {
+                filtered.push(subSelections);
+            }
+            else {
+                for (const subSelection of subSelections) {
+                    filtered.push(subSelection);
+                }
+            }
+        }
+        else {
+            filtered.push(selection);
+        }
+    }
+    return filtered;
+}
+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);
+    }
+    const element = updateElement(first).rebaseOn(parentType);
+    const subSelectionParentType = element.kind === 'Field' ? (0, definitions_1.baseType)(element.definition.type) : element.castedType();
+    if (!(0, definitions_1.isCompositeType)(subSelectionParentType)) {
+        return selectionOfElement(element);
+    }
+    const subSelectionKeyedUpdates = new utils_1.MultiMap();
+    for (const update of updates) {
+        if (update instanceof AbstractSelection) {
+            if (update.selectionSet) {
+                addToKeyedUpdates(subSelectionKeyedUpdates, update.selectionSet);
+            }
+        }
+        else {
+            addSubpathToKeyUpdates(subSelectionKeyedUpdates, subSelectionParentType, update);
+        }
+    }
+    return selectionOfElement(element, makeSelectionSet(subSelectionParentType, subSelectionKeyedUpdates, fragments));
+}
+function updateElement(update) {
+    return update instanceof AbstractSelection ? update.element : update.path[0];
+}
+function addSubpathToKeyUpdates(keyedUpdates, subSelectionParentType, pathUpdate) {
+    if (pathUpdate.path.length === 1) {
+        if (!pathUpdate.selections) {
+            return;
+        }
+        addToKeyedUpdates(keyedUpdates, withUnecessaryFragmentsRemoved(subSelectionParentType, pathUpdate.selections));
+    }
+    else {
+        keyedUpdates.add(pathUpdate.path[1].key(), { path: pathUpdate.path.slice(1), selections: pathUpdate.selections });
+    }
+}
+function makeSelectionSet(parentType, keyedUpdates, fragments) {
+    const selections = new Map();
+    for (const [key, updates] of keyedUpdates.entries()) {
+        selections.set(key, makeSelection(parentType, updates, fragments));
+    }
+    return new SelectionSet(parentType, selections, fragments);
+}
+class MutableSelectionSet {
+    constructor(parentType, _updates, memoizer) {
+        this.parentType = parentType;
+        this._updates = _updates;
+        this.memoizer = memoizer;
+    }
+    static empty(parentType) {
+        return this.emptyWithMemoized(parentType, () => ({}));
+    }
+    static emptyWithMemoized(parentType, memoizer) {
+        return new MutableSelectionSet(parentType, new SelectionSetUpdates(), memoizer);
+    }
+    static of(selectionSet) {
+        return this.ofWithMemoized(selectionSet, () => ({}));
+    }
+    static ofWithMemoized(selectionSet, memoizer) {
+        const s = new MutableSelectionSet(selectionSet.parentType, new SelectionSetUpdates(), memoizer);
+        s._updates.add(selectionSet);
+        s.computed = selectionSet;
+        return s;
+    }
+    isEmpty() {
+        return this._updates.isEmpty();
+    }
+    get() {
+        if (!this.computed) {
+            this.computed = this._updates.toSelectionSet(this.parentType);
+            this._updates.clear();
+            this._updates.add(this.computed);
+        }
+        return this.computed;
+    }
+    updates() {
+        this.computed = undefined;
+        this._memoized = undefined;
+        return this._updates;
+    }
+    clone() {
+        const cloned = new MutableSelectionSet(this.parentType, this._updates.clone(), this.memoizer);
+        cloned.computed = this.computed;
+        cloned._memoized = this._memoized;
+        return cloned;
+    }
+    rebaseOn(parentType) {
+        const rebased = new MutableSelectionSet(parentType, new SelectionSetUpdates(), this.memoizer);
+        rebased._updates.add(this.get());
+        return rebased;
+    }
+    memoized() {
+        if (!this._memoized) {
+            this._memoized = this.memoizer(this.get());
+        }
+        return this._memoized;
+    }
+    toString() {
+        return this.get().toString();
+    }
+}
+exports.MutableSelectionSet = MutableSelectionSet;
 function allFieldDefinitionsInSelectionSet(selection) {
     const stack = Array.from(selection.selections());
     const allFields = [];
     while (stack.length > 0) {
         const selection = stack.pop();
         if (selection.kind === 'FieldSelection') {
-            allFields.push(selection.field.definition);
+            allFields.push(selection.element.definition);
         }
         if (selection.selectionSet) {
             stack.push(...selection.selectionSet.selections());
@@ -1069,59 +1219,137 @@ function allFieldDefinitionsInSelectionSet(selection) {
     return allFields;
 }
 exports.allFieldDefinitionsInSelectionSet = allFieldDefinitionsInSelectionSet;
-function selectionSetOfElement(element, subSelection) {
-    const selectionSet = new SelectionSet(element.parentType);
-    selectionSet.add(selectionOfElement(element, subSelection));
-    return selectionSet;
+function selectionSetOf(parentType, selection, fragments) {
+    const map = new Map();
+    map.set(selection.key(), selection);
+    return new SelectionSet(parentType, map, fragments);
+}
+exports.selectionSetOf = selectionSetOf;
+function selectionSetOfElement(element, subSelection, fragments) {
+    return selectionSetOf(element.parentType, selectionOfElement(element, subSelection), fragments);
 }
 exports.selectionSetOfElement = selectionSetOfElement;
 function selectionOfElement(element, subSelection) {
     return element.kind === 'Field' ? new FieldSelection(element, subSelection) : new InlineFragmentSelection(element, subSelection);
 }
 exports.selectionOfElement = selectionOfElement;
-class FieldSelection extends Freezable {
-    constructor(field, initialSelectionSet) {
-        super();
-        this.field = field;
-        this.kind = 'FieldSelection';
-        const type = (0, definitions_1.baseType)(field.definition.type);
-        this.selectionSet = (0, definitions_1.isLeafType)(type) ? undefined : (initialSelectionSet ? initialSelectionSet.cloneIfFrozen() : new SelectionSet(type));
+class AbstractSelection {
+    constructor(element) {
+        this.element = element;
     }
     get parentType() {
-        return this.field.parentType;
+        return this.element.parentType;
     }
-    us() {
-        return this;
+    collectVariables(collector) {
+        var _a;
+        this.element.collectVariables(collector);
+        (_a = this.selectionSet) === null || _a === void 0 ? void 0 : _a.collectVariables(collector);
     }
-    key() {
-        return this.element().responseName();
+    collectUsedFragmentNames(collector) {
+        var _a;
+        (_a = this.selectionSet) === null || _a === void 0 ? void 0 : _a.collectUsedFragmentNames(collector);
     }
-    element() {
-        return this.field;
+    namedFragments() {
+        var _a;
+        return (_a = this.selectionSet) === null || _a === void 0 ? void 0 : _a.fragments;
     }
-    usedVariables() {
-        var _a, _b;
-        return (0, definitions_1.mergeVariables)(this.element().variables(), (_b = (_a = this.selectionSet) === null || _a === void 0 ? void 0 : _a.usedVariables()) !== null && _b !== void 0 ? _b : []);
+    withUpdatedSelectionSet(selectionSet) {
+        return this.withUpdatedComponents(this.element, selectionSet);
     }
-    collectUsedFragmentNames(collector) {
-        if (this.selectionSet) {
-            this.selectionSet.collectUsedFragmentNames(collector);
+    withUpdatedElement(element) {
+        return this.withUpdatedComponents(element, this.selectionSet);
+    }
+    mapToSelectionSet(mapper) {
+        if (!this.selectionSet) {
+            return this.us();
+        }
+        const updatedSelectionSet = mapper(this.selectionSet);
+        return updatedSelectionSet === this.selectionSet
+            ? this.us()
+            : this.withUpdatedSelectionSet(updatedSelectionSet);
+    }
+    minus(that) {
+        if (this.selectionSet && that.selectionSet) {
+            const updatedSubSelectionSet = this.selectionSet.minus(that.selectionSet);
+            if (!updatedSubSelectionSet.isEmpty()) {
+                return this.withUpdatedSelectionSet(updatedSubSelectionSet);
+            }
+        }
+        return undefined;
+    }
+    tryOptimizeSubselectionOnce(_) {
+        (0, utils_1.assert)(false, `UNSUPPORTED`);
+    }
+    tryOptimizeSubselectionWithFragments({ parentType, subSelection, fragments, fragmentFilter, }) {
+        let candidates = fragments.maybeApplyingAtType(parentType);
+        if (fragmentFilter) {
+            candidates = candidates.filter(fragmentFilter);
         }
+        let shouldTryAgain;
+        do {
+            const { spread, optimizedSelection, hasDiff } = this.tryOptimizeSubselectionOnce({ parentType, subSelection, candidates, fragments });
+            if (optimizedSelection) {
+                subSelection = optimizedSelection;
+            }
+            else if (spread) {
+                return spread;
+            }
+            shouldTryAgain = !!spread && !!hasDiff;
+            if (shouldTryAgain) {
+                candidates = candidates.filter((c) => c !== (spread === null || spread === void 0 ? void 0 : spread.namedFragment));
+            }
+        } while (shouldTryAgain);
+        return subSelection;
+    }
+}
+class FieldSelection extends AbstractSelection {
+    constructor(field, _selectionSet) {
+        super(field);
+        this._selectionSet = _selectionSet;
+        this.kind = 'FieldSelection';
+    }
+    get selectionSet() {
+        return this._selectionSet;
+    }
+    us() {
+        return this;
+    }
+    withUpdatedComponents(field, selectionSet) {
+        return new FieldSelection(field, selectionSet);
+    }
+    key() {
+        return this.element.key();
     }
     optimize(fragments) {
-        const optimizedSelection = this.selectionSet ? this.selectionSet.optimize(fragments) : undefined;
-        const fieldBaseType = (0, definitions_1.baseType)(this.field.definition.type);
+        let optimizedSelection = this.selectionSet ? this.selectionSet.optimize(fragments) : undefined;
+        const fieldBaseType = (0, definitions_1.baseType)(this.element.definition.type);
         if ((0, definitions_1.isCompositeType)(fieldBaseType) && optimizedSelection) {
-            for (const candidate of fragments.maybeApplyingAtType(fieldBaseType)) {
-                if (optimizedSelection.equals(candidate.selectionSet)) {
-                    const fragmentSelection = new FragmentSpreadSelection(fieldBaseType, fragments, candidate.name);
-                    return new FieldSelection(this.field, selectionSetOf(fieldBaseType, fragmentSelection));
-                }
-            }
+            const optimized = this.tryOptimizeSubselectionWithFragments({
+                parentType: fieldBaseType,
+                subSelection: optimizedSelection,
+                fragments,
+                fragmentFilter: (f) => f.appliedDirectives.length === 0,
+            });
+            (0, utils_1.assert)(!(optimized instanceof FragmentSpreadSelection), 'tryOptimizeSubselectionOnce should never return only a spread');
+            optimizedSelection = optimized;
         }
         return this.selectionSet === optimizedSelection
             ? this
-            : new FieldSelection(this.field, optimizedSelection);
+            : new FieldSelection(this.element, optimizedSelection);
+    }
+    tryOptimizeSubselectionOnce({ parentType, subSelection, candidates, fragments, }) {
+        let optimizedSelection = subSelection;
+        for (const candidate of candidates) {
+            const { contains, diff } = optimizedSelection.diffIfContains(candidate.selectionSet);
+            if (contains) {
+                const spread = new FragmentSpreadSelection(parentType, fragments, candidate, []);
+                optimizedSelection = diff
+                    ? new SelectionSetUpdates().add(spread).add(diff).toSelectionSet(parentType, fragments)
+                    : selectionSetOf(parentType, spread);
+                return { spread, optimizedSelection, hasDiff: !!diff };
+            }
+        }
+        return {};
     }
     filter(predicate) {
         if (!this.selectionSet) {
@@ -1130,99 +1358,96 @@ class FieldSelection extends Freezable {
         const updatedSelectionSet = this.selectionSet.filter(predicate);
         const thisWithFilteredSelectionSet = this.selectionSet === updatedSelectionSet
             ? this
-            : new FieldSelection(this.field, updatedSelectionSet);
+            : new FieldSelection(this.element, updatedSelectionSet);
         return predicate(thisWithFilteredSelectionSet) ? thisWithFilteredSelectionSet : undefined;
     }
-    freezeInternals() {
+    validate(variableDefinitions) {
         var _a;
-        (_a = this.selectionSet) === null || _a === void 0 ? void 0 : _a.freeze();
-    }
-    expandFragments(names, updateSelectionSetFragments = true) {
-        const expandedSelection = this.selectionSet ? this.selectionSet.expandFragments(names, updateSelectionSetFragments) : undefined;
-        return this.selectionSet === expandedSelection
-            ? this
-            : new FieldSelection(this.field, expandedSelection);
+        this.element.validate(variableDefinitions);
+        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);
     }
-    fieldArgumentsToAST() {
-        const entries = Object.entries(this.field.args);
-        if (entries.length === 0) {
-            return undefined;
+    rebaseOn(parentType) {
+        if (this.element.parentType === parentType) {
+            return this;
         }
-        return entries.map(([n, v]) => {
-            return {
-                kind: graphql_1.Kind.ARGUMENT,
-                name: { kind: graphql_1.Kind.NAME, value: n },
-                value: (0, values_1.valueToAST)(v, this.field.definition.argument(n).type),
-            };
-        });
-    }
-    validate() {
-        var _a;
-        this.field.validate();
-        validate(!(this.selectionSet && this.selectionSet.isEmpty()), () => `Invalid empty selection set for field "${this.field.definition.coordinate}" of non-leaf type ${this.field.definition.type}`, this.field.definition.sourceAST);
-        (_a = this.selectionSet) === null || _a === void 0 ? void 0 : _a.validate();
-    }
-    updateForAddingTo(selectionSet) {
-        var _a;
-        const updatedField = this.field.updateForAddingTo(selectionSet);
-        if (this.field === updatedField) {
-            return this.cloneIfFrozen();
-        }
-        const updatedBaseType = (0, definitions_1.baseType)(updatedField.definition.type);
-        let updatedSelectionSet;
-        if (this.selectionSet && this.selectionSet.parentType !== updatedBaseType) {
-            (0, utils_1.assert)((0, definitions_1.isCompositeType)(updatedBaseType), `Expected ${updatedBaseType.coordinate} to be composite but ${updatedBaseType.kind}`);
-            updatedSelectionSet = new SelectionSet(updatedBaseType);
-            for (const selection of this.selectionSet.selections()) {
-                updatedSelectionSet.add(selection);
-            }
+        const rebasedElement = this.element.rebaseOn(parentType);
+        if (!this.selectionSet) {
+            return this.withUpdatedElement(rebasedElement);
         }
-        else {
-            updatedSelectionSet = (_a = this.selectionSet) === null || _a === void 0 ? void 0 : _a.cloneIfFrozen();
+        const rebasedBase = (0, definitions_1.baseType)(rebasedElement.definition.type);
+        if (rebasedBase === this.selectionSet.parentType) {
+            return this.withUpdatedElement(rebasedElement);
         }
-        return new FieldSelection(updatedField, updatedSelectionSet);
+        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));
     }
     canAddTo(parentType) {
-        if (this.field.parentType === parentType) {
+        if (this.element.parentType === parentType) {
             return true;
         }
-        const type = this.field.typeIfAddedTo(parentType);
+        const type = this.element.typeIfAddedTo(parentType);
         if (!type) {
             return false;
         }
         const base = (0, definitions_1.baseType)(type);
         if (this.selectionSet && this.selectionSet.parentType !== base) {
-            (0, utils_1.assert)((0, definitions_1.isCompositeType)(base), () => `${this.field} should have a selection set as it's type is not a composite`);
+            (0, utils_1.assert)((0, definitions_1.isCompositeType)(base), () => `${this.element} should have a selection set as it's type is not a composite`);
             return this.selectionSet.selections().every((s) => s.canAddTo(base));
         }
         return true;
     }
     toSelectionNode() {
         var _a;
-        const alias = this.field.alias ? { kind: graphql_1.Kind.NAME, value: this.field.alias, } : undefined;
+        const alias = this.element.alias ? { kind: graphql_1.Kind.NAME, value: this.element.alias, } : undefined;
         return {
             kind: graphql_1.Kind.FIELD,
             name: {
                 kind: graphql_1.Kind.NAME,
-                value: this.field.name,
+                value: this.element.name,
             },
             alias,
-            arguments: this.fieldArgumentsToAST(),
-            directives: this.element().appliedDirectivesToDirectiveNodes(),
+            arguments: this.element.argumentsToNodes(),
+            directives: this.element.appliedDirectivesToDirectiveNodes(),
             selectionSet: (_a = this.selectionSet) === null || _a === void 0 ? void 0 : _a.toSelectionSetNode()
         };
     }
-    withUpdatedSubSelection(newSubSelection) {
-        return new FieldSelection(this.field, newSubSelection);
+    withoutDefer(labelsToRemove) {
+        return this.mapToSelectionSet((s) => s.withoutDefer(labelsToRemove));
+    }
+    withNormalizedDefer(normalizer) {
+        return this.mapToSelectionSet((s) => s.withNormalizedDefer(normalizer));
+    }
+    hasDefer() {
+        var _a;
+        return !!((_a = this.selectionSet) === null || _a === void 0 ? void 0 : _a.hasDefer());
+    }
+    expandAllFragments() {
+        return this.mapToSelectionSet((s) => s.expandAllFragments());
+    }
+    trimUnsatisfiableBranches(_) {
+        var _a;
+        if (!this.selectionSet) {
+            return this;
+        }
+        const base = (0, definitions_1.baseType)(this.element.definition.type);
+        (0, utils_1.assert)((0, definitions_1.isCompositeType)(base), () => `Field ${this.element} should not have a sub-selection`);
+        const trimmed = this.mapToSelectionSet((s) => s.trimUnsatisfiableBranches(base));
+        if ((_a = trimmed.selectionSet) === null || _a === void 0 ? void 0 : _a.isEmpty()) {
+            return trimmed.withUpdatedSelectionSet(selectionSetOfElement(new Field(base.typenameField(), undefined, [new definitions_1.Directive('include', { 'if': false })])));
+        }
+        else {
+            return trimmed;
+        }
     }
-    withUpdatedField(newField) {
-        return new FieldSelection(newField, this.selectionSet);
+    expandFragments(names, updatedFragments) {
+        return this.mapToSelectionSet((s) => s.expandFragments(names, updatedFragments));
     }
     equals(that) {
         if (this === that) {
             return true;
         }
-        if (!(that instanceof FieldSelection) || !this.field.equals(that.field)) {
+        if (!(that instanceof FieldSelection) || !this.element.equals(that.element)) {
             return false;
         }
         if (!this.selectionSet) {
@@ -1231,7 +1456,7 @@ class FieldSelection extends Freezable {
         return !!that.selectionSet && this.selectionSet.equals(that.selectionSet);
     }
     contains(that) {
-        if (!(that instanceof FieldSelection) || !this.field.equals(that.field)) {
+        if (!(that instanceof FieldSelection) || !this.element.equals(that.element)) {
             return false;
         }
         if (!that.selectionSet) {
@@ -1239,126 +1464,83 @@ class FieldSelection extends Freezable {
         }
         return !!this.selectionSet && this.selectionSet.contains(that.selectionSet);
     }
-    namedFragments() {
-        var _a;
-        return (_a = this.selectionSet) === null || _a === void 0 ? void 0 : _a.fragments;
-    }
-    withoutDefer(labelsToRemove) {
-        var _a;
-        const updatedSubSelections = (_a = this.selectionSet) === null || _a === void 0 ? void 0 : _a.withoutDefer(labelsToRemove);
-        return updatedSubSelections === this.selectionSet
-            ? this
-            : new FieldSelection(this.field, updatedSubSelections);
-    }
-    withNormalizedDefer(normalizer) {
-        var _a;
-        const updatedSubSelections = (_a = this.selectionSet) === null || _a === void 0 ? void 0 : _a.withNormalizedDefer(normalizer);
-        return updatedSubSelections === this.selectionSet
-            ? this
-            : new FieldSelection(this.field, updatedSubSelections);
-    }
-    clone() {
-        if (!this.selectionSet) {
-            return this;
-        }
-        return new FieldSelection(this.field, this.selectionSet.clone());
+    isUnecessaryInlineFragment(_) {
+        return false;
     }
     toString(expandFragments = true, indent) {
-        return (indent !== null && indent !== void 0 ? indent : '') + this.field + (this.selectionSet ? ' ' + this.selectionSet.toString(expandFragments, true, indent) : '');
+        return (indent !== null && indent !== void 0 ? indent : '') + this.element + (this.selectionSet ? ' ' + this.selectionSet.toString(expandFragments, true, indent) : '');
     }
 }
 exports.FieldSelection = FieldSelection;
-class FragmentSelection extends Freezable {
+class FragmentSelection extends AbstractSelection {
     constructor() {
         super(...arguments);
         this.kind = 'FragmentSelection';
     }
-    get parentType() {
-        return this.element().parentType;
-    }
     us() {
         return this;
     }
     validateDeferAndStream() {
-        if (this.element().hasDefer() || this.element().hasStream()) {
-            const schemaDef = this.element().schema().schemaDefinition;
-            const parentType = this.element().parentType;
+        if (this.element.hasDefer() || this.element.hasStream()) {
+            const schemaDef = this.element.schema().schemaDefinition;
+            const parentType = this.parentType;
             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}"`; });
         }
     }
-    usedVariables() {
-        return (0, definitions_1.mergeVariables)(this.element().variables(), this.selectionSet.usedVariables());
-    }
     filter(predicate) {
         const selectionSet = this.selectionSet;
         const updatedSelectionSet = selectionSet.filter(predicate);
         const thisWithFilteredSelectionSet = updatedSelectionSet === selectionSet
             ? this
-            : new InlineFragmentSelection(this.element(), updatedSelectionSet);
+            : new InlineFragmentSelection(this.element, updatedSelectionSet);
         return predicate(thisWithFilteredSelectionSet) ? thisWithFilteredSelectionSet : undefined;
     }
-    freezeInternals() {
-        this.selectionSet.freeze();
-    }
-    equals(that) {
-        if (this === that) {
-            return true;
-        }
-        return (that instanceof FragmentSelection)
-            && this.element().equals(that.element())
-            && this.selectionSet.equals(that.selectionSet);
-    }
-    contains(that) {
-        return (that instanceof FragmentSelection)
-            && this.element().equals(that.element())
-            && this.selectionSet.contains(that.selectionSet);
+    hasDefer() {
+        return this.element.hasDefer() || this.selectionSet.hasDefer();
     }
-    clone() {
-        return new InlineFragmentSelection(this.element(), this.selectionSet.clone());
+    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 {
-    constructor(fragmentElement, initialSelectionSet) {
-        super();
-        this.fragmentElement = fragmentElement;
-        this._selectionSet = initialSelectionSet
-            ? initialSelectionSet.cloneIfFrozen()
-            : new SelectionSet(fragmentElement.typeCondition ? fragmentElement.typeCondition : fragmentElement.parentType);
+    constructor(fragment, _selectionSet) {
+        super(fragment);
+        this._selectionSet = _selectionSet;
+    }
+    get selectionSet() {
+        return this._selectionSet;
     }
     key() {
-        var _a, _b;
-        return (_b = (_a = this.element().typeCondition) === null || _a === void 0 ? void 0 : _a.name) !== null && _b !== void 0 ? _b : '';
+        return this.element.key();
     }
-    validate() {
+    withUpdatedComponents(fragment, selectionSet) {
+        return new InlineFragmentSelection(fragment, selectionSet);
+    }
+    validate(variableDefinitions) {
         this.validateDeferAndStream();
-        validate(!this.selectionSet.isEmpty(), () => `Invalid empty selection set for fragment "${this.element()}"`);
-        this.selectionSet.validate();
+        validate(!this.selectionSet.isEmpty(), () => `Invalid empty selection set for fragment "${this.element}"`);
+        this.selectionSet.validate(variableDefinitions);
     }
-    updateForAddingTo(selectionSet) {
-        var _a;
-        const updatedFragment = this.element().updateForAddingTo(selectionSet);
-        if (this.element() === updatedFragment) {
-            return this.cloneIfFrozen();
-        }
-        const updatedCastedType = updatedFragment.castedType();
-        let updatedSelectionSet;
-        if (this.selectionSet.parentType !== updatedCastedType) {
-            updatedSelectionSet = new SelectionSet(updatedCastedType);
-            for (const selection of this.selectionSet.selections()) {
-                updatedSelectionSet.add(selection);
-            }
+    rebaseOn(parentType) {
+        if (this.parentType === parentType) {
+            return this;
         }
-        else {
-            updatedSelectionSet = (_a = this.selectionSet) === null || _a === void 0 ? void 0 : _a.cloneIfFrozen();
+        const rebasedFragment = this.element.rebaseOn(parentType);
+        const rebasedCastedType = rebasedFragment.castedType();
+        if (rebasedCastedType === this.selectionSet.parentType) {
+            return this.withUpdatedElement(rebasedFragment);
         }
-        return new InlineFragmentSelection(updatedFragment, updatedSelectionSet);
+        return this.withUpdatedComponents(rebasedFragment, this.selectionSet.rebaseOn(rebasedCastedType));
     }
     canAddTo(parentType) {
-        if (this.element().parentType === parentType) {
+        if (this.element.parentType === parentType) {
             return true;
         }
-        const type = this.element().castedTypeIfAddedTo(parentType);
+        const type = this.element.castedTypeIfAddedTo(parentType);
         if (!type) {
             return false;
         }
@@ -1367,17 +1549,8 @@ class InlineFragmentSelection extends FragmentSelection {
         }
         return true;
     }
-    get selectionSet() {
-        return this._selectionSet;
-    }
-    namedFragments() {
-        return this.selectionSet.fragments;
-    }
-    element() {
-        return this.fragmentElement;
-    }
     toSelectionNode() {
-        const typeCondition = this.element().typeCondition;
+        const typeCondition = this.element.typeCondition;
         return {
             kind: graphql_1.Kind.INLINE_FRAGMENT,
             typeCondition: typeCondition
@@ -1389,103 +1562,195 @@ class InlineFragmentSelection extends FragmentSelection {
                     },
                 }
                 : undefined,
-            directives: this.element().appliedDirectivesToDirectiveNodes(),
+            directives: this.element.appliedDirectivesToDirectiveNodes(),
             selectionSet: this.selectionSet.toSelectionSetNode()
         };
     }
     optimize(fragments) {
         let optimizedSelection = this.selectionSet.optimize(fragments);
-        const typeCondition = this.element().typeCondition;
+        const typeCondition = this.element.typeCondition;
         if (typeCondition) {
-            for (const candidate of fragments.maybeApplyingAtType(typeCondition)) {
-                if (optimizedSelection.equals(candidate.selectionSet)) {
-                    const spread = new FragmentSpreadSelection(this.element().parentType, fragments, candidate.name);
-                    if ((0, types_1.sameType)(typeCondition, candidate.typeCondition)) {
-                        this.fragmentElement.appliedDirectives.forEach((directive) => {
-                            spread.element().applyDirective(directive.definition, directive.arguments());
-                        });
-                        return spread;
-                    }
-                    optimizedSelection = selectionSetOf(spread.element().parentType, spread);
-                    break;
-                }
+            const optimized = this.tryOptimizeSubselectionWithFragments({
+                parentType: typeCondition,
+                subSelection: optimizedSelection,
+                fragments,
+            });
+            if (optimized instanceof FragmentSpreadSelection) {
+                return optimized;
             }
+            optimizedSelection = optimized;
         }
         return this.selectionSet === optimizedSelection
             ? this
-            : new InlineFragmentSelection(this.fragmentElement, optimizedSelection);
-    }
-    expandFragments(names, updateSelectionSetFragments = true) {
-        const expandedSelection = this.selectionSet.expandFragments(names, updateSelectionSetFragments);
-        return this.selectionSet === expandedSelection
-            ? this
-            : new InlineFragmentSelection(this.element(), expandedSelection);
-    }
-    collectUsedFragmentNames(collector) {
-        this.selectionSet.collectUsedFragmentNames(collector);
+            : new InlineFragmentSelection(this.element, optimizedSelection);
+    }
+    tryOptimizeSubselectionOnce({ parentType, subSelection, candidates, fragments, }) {
+        let optimizedSelection = subSelection;
+        for (const candidate of candidates) {
+            const { contains, diff } = optimizedSelection.diffIfContains(candidate.selectionSet);
+            if (contains) {
+                if (!diff && (0, types_1.sameType)(this.element.typeCondition, candidate.typeCondition)) {
+                    let spreadDirectives = this.element.appliedDirectives;
+                    if (candidate.appliedDirectives.length > 0) {
+                        const { isSubset, difference } = diffDirectives(this.element.appliedDirectives, candidate.appliedDirectives);
+                        if (!isSubset) {
+                            continue;
+                        }
+                        spreadDirectives = difference;
+                    }
+                    return {
+                        spread: new FragmentSpreadSelection(this.parentType, fragments, candidate, spreadDirectives),
+                    };
+                }
+                if (candidate.appliedDirectives.length > 0) {
+                    continue;
+                }
+                const spread = new FragmentSpreadSelection(parentType, fragments, candidate, []);
+                optimizedSelection = diff
+                    ? new SelectionSetUpdates().add(spread).add(diff).toSelectionSet(parentType, fragments)
+                    : selectionSetOf(parentType, spread);
+                return { spread, optimizedSelection, hasDiff: !!diff };
+            }
+        }
+        return {};
     }
     withoutDefer(labelsToRemove) {
-        const updatedSubSelections = this.selectionSet.withoutDefer(labelsToRemove);
-        const deferArgs = this.fragmentElement.deferDirectiveArgs();
+        const newSelection = this.selectionSet.withoutDefer(labelsToRemove);
+        const deferArgs = this.element.deferDirectiveArgs();
         const hasDeferToRemove = deferArgs && (!labelsToRemove || (deferArgs.label && labelsToRemove.has(deferArgs.label)));
-        if (updatedSubSelections === this.selectionSet && !hasDeferToRemove) {
+        if (newSelection === this.selectionSet && !hasDeferToRemove) {
             return this;
         }
-        const newFragment = hasDeferToRemove ? this.fragmentElement.withoutDefer() : this.fragmentElement;
-        if (!newFragment) {
-            return updatedSubSelections;
+        const newElement = hasDeferToRemove ? this.element.withoutDefer() : this.element;
+        if (!newElement) {
+            return newSelection;
         }
-        return new InlineFragmentSelection(newFragment, updatedSubSelections);
+        return this.withUpdatedComponents(newElement, newSelection);
     }
     withNormalizedDefer(normalizer) {
-        const newFragment = this.fragmentElement.withNormalizedDefer(normalizer);
-        const updatedSubSelections = this.selectionSet.withNormalizedDefer(normalizer);
-        if (!newFragment) {
-            return updatedSubSelections;
+        const newElement = this.element.withNormalizedDefer(normalizer);
+        const newSelection = this.selectionSet.withNormalizedDefer(normalizer);
+        if (!newElement) {
+            return newSelection;
         }
-        return newFragment === this.fragmentElement && updatedSubSelections === this.selectionSet
+        return newElement === this.element && newSelection === this.selectionSet
             ? this
-            : new InlineFragmentSelection(newFragment, updatedSubSelections);
+            : this.withUpdatedComponents(newElement, newSelection);
+    }
+    trimUnsatisfiableBranches(currentType) {
+        var _a, _b;
+        const thisCondition = this.element.typeCondition;
+        if (this.element.appliedDirectives.length === 0) {
+            if (!thisCondition || currentType === this.element.typeCondition) {
+                const trimmed = this.selectionSet.trimUnsatisfiableBranches(currentType);
+                return trimmed.isEmpty() ? undefined : trimmed;
+            }
+            if ((0, definitions_1.isObjectType)(currentType)) {
+                if ((0, definitions_1.isObjectType)(thisCondition) || !(0, definitions_1.possibleRuntimeTypes)(thisCondition).includes(currentType)) {
+                    return undefined;
+                }
+                else {
+                    const trimmed = this.selectionSet.trimUnsatisfiableBranches(currentType);
+                    return trimmed.isEmpty() ? undefined : trimmed;
+                }
+            }
+        }
+        const trimmedSelectionSet = this.selectionSet.trimUnsatisfiableBranches((_a = this.element.typeCondition) !== null && _a !== void 0 ? _a : this.parentType);
+        if (trimmedSelectionSet.isEmpty()) {
+            if (this.element.appliedDirectives.length === 0) {
+                return undefined;
+            }
+            else {
+                return this.withUpdatedSelectionSet(selectionSetOfElement(new Field(((_b = this.element.typeCondition) !== null && _b !== void 0 ? _b : this.parentType).typenameField(), undefined, [new definitions_1.Directive('include', { 'if': false })])));
+            }
+        }
+        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);
+            const liftableSelections = [];
+            for (const selection of trimmedSelectionSet.selections()) {
+                if (selection.kind === 'FragmentSelection'
+                    && selection.element.typeCondition
+                    && (0, definitions_1.isObjectType)(selection.element.typeCondition)
+                    && currentRuntimes.includes(selection.element.typeCondition)) {
+                    liftableSelections.push(selection);
+                }
+            }
+            if (liftableSelections.length === trimmedSelectionSet.selections().length) {
+                return trimmedSelectionSet;
+            }
+            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);
+            }
+        }
+        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));
+    }
+    equals(that) {
+        if (this === that) {
+            return true;
+        }
+        return (that instanceof FragmentSelection)
+            && this.element.equals(that.element)
+            && this.selectionSet.equals(that.selectionSet);
     }
-    withUpdatedSubSelection(newSubSelection) {
-        return new InlineFragmentSelection(this.fragmentElement, newSubSelection);
+    contains(that) {
+        return (that instanceof FragmentSelection)
+            && this.element.equals(that.element)
+            && this.selectionSet.contains(that.selectionSet);
     }
     toString(expandFragments = true, indent) {
-        return (indent !== null && indent !== void 0 ? indent : '') + this.fragmentElement + ' ' + this.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, fragmentName) {
-        super();
+    constructor(sourceType, fragments, namedFragment, spreadDirectives) {
+        super(new FragmentElement(sourceType, namedFragment.typeCondition, namedFragment.appliedDirectives.concat(spreadDirectives)));
         this.fragments = fragments;
-        const fragmentDefinition = fragments.get(fragmentName);
-        validate(fragmentDefinition, () => `Unknown fragment "...${fragmentName}"`);
-        this.namedFragment = fragmentDefinition;
-        this._element = new FragmentElement(sourceType, fragmentDefinition.typeCondition);
-        for (const directive of fragmentDefinition.appliedDirectives) {
-            this._element.applyDirective(directive.definition, directive.arguments());
-        }
+        this.namedFragment = namedFragment;
+        this.spreadDirectives = spreadDirectives;
+    }
+    get selectionSet() {
+        return this.namedFragment.selectionSet;
     }
     key() {
-        return '...' + this.namedFragment.name;
+        if (!this.computedKey) {
+            this.computedKey = '...' + this.namedFragment.name + (this.spreadDirectives.length === 0 ? '' : ' ' + this.spreadDirectives.join(' '));
+        }
+        return this.computedKey;
     }
-    element() {
-        return this._element;
+    withUpdatedComponents(_fragment, _selectionSet) {
+        (0, utils_1.assert)(false, `Unsupported`);
+    }
+    trimUnsatisfiableBranches(_) {
+        return this;
     }
     namedFragments() {
         return this.fragments;
     }
-    get selectionSet() {
-        return this.namedFragment.selectionSet;
-    }
     validate() {
         this.validateDeferAndStream();
     }
     toSelectionNode() {
-        const spreadDirectives = this.spreadDirectives();
-        const directiveNodes = spreadDirectives.length === 0
+        const directiveNodes = this.spreadDirectives.length === 0
             ? undefined
-            : spreadDirectives.map(directive => {
+            : this.spreadDirectives.map(directive => {
                 return {
                     kind: graphql_1.Kind.DIRECTIVE,
                     name: {
@@ -1504,20 +1769,26 @@ class FragmentSpreadSelection extends FragmentSelection {
     optimize(_) {
         return this;
     }
-    updateForAddingTo(_selectionSet) {
+    rebaseOn(_parentType) {
         return this;
     }
     canAddTo(_) {
         return true;
     }
-    expandFragments(names, updateSelectionSetFragments = true) {
-        if (names && !names.includes(this.namedFragment.name)) {
+    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)) {
             return this;
         }
-        const expandedSubSelections = this.selectionSet.expandFragments(names, updateSelectionSetFragments);
-        return (0, types_1.sameType)(this._element.parentType, this.namedFragment.typeCondition) && this._element.appliedDirectives.length === 0
+        const expandedSubSelections = this.selectionSet.expandFragments(names, updatedFragments);
+        return (0, types_1.sameType)(this.parentType, this.namedFragment.typeCondition) && this.element.appliedDirectives.length === 0
             ? expandedSubSelections.selections()
-            : new InlineFragmentSelection(this._element, expandedSubSelections);
+            : new InlineFragmentSelection(this.element, expandedSubSelections);
     }
     collectUsedFragmentNames(collector) {
         this.selectionSet.collectUsedFragmentNames(collector);
@@ -1525,28 +1796,89 @@ class FragmentSpreadSelection extends FragmentSelection {
         collector.set(this.namedFragment.name, usageCount === undefined ? 1 : usageCount + 1);
     }
     withoutDefer(_labelsToRemove) {
-        (0, utils_1.assert)(false, 'Unsupported, see `Operation.withoutDefer`');
+        (0, utils_1.assert)(false, 'Unsupported, see `Operation.withAllDeferLabelled`');
     }
-    withNormalizedDefer(_normalizezr) {
+    withNormalizedDefer(_normalizer) {
         (0, utils_1.assert)(false, 'Unsupported, see `Operation.withAllDeferLabelled`');
     }
-    spreadDirectives() {
-        return this._element.appliedDirectives.slice(this.namedFragment.appliedDirectives.length);
+    minus(that) {
+        (0, utils_1.assert)(this.equals(that), () => `Invalid operation for ${this.toString(false)} and ${that.toString(false)}`);
+        return undefined;
+    }
+    equals(that) {
+        if (this === that) {
+            return true;
+        }
+        return (that instanceof FragmentSpreadSelection)
+            && this.namedFragment.name === that.namedFragment.name
+            && (0, definitions_1.sameDirectiveApplications)(this.spreadDirectives, that.spreadDirectives);
     }
-    withUpdatedSubSelection(_) {
-        (0, utils_1.assert)(false, `Unssupported`);
+    contains(that) {
+        if (this.equals(that)) {
+            return true;
+        }
+        return (that instanceof FragmentSelection)
+            && this.element.equals(that.element)
+            && this.selectionSet.contains(that.selectionSet);
     }
     toString(expandFragments = true, indent) {
         if (expandFragments) {
-            return (indent !== null && indent !== void 0 ? indent : '') + this._element + ' ' + this.selectionSet.toString(true, true, indent);
+            return (indent !== null && indent !== void 0 ? indent : '') + this.element + ' ' + this.selectionSet.toString(true, true, indent);
         }
         else {
-            const directives = this.spreadDirectives();
+            const directives = this.spreadDirectives;
             const directiveString = directives.length == 0 ? '' : ' ' + directives.join(' ');
             return (indent !== null && indent !== void 0 ? indent : '') + '...' + this.namedFragment.name + directiveString;
         }
     }
 }
+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);
+    }
+    const selections = new SelectionSetUpdates();
+    for (const selectionNode of node.selections) {
+        selections.add(selectionOfNode(parentType, selectionNode, variableDefinitions, fragments, fieldAccessor));
+    }
+    return selections.toSelectionSet(parentType, fragments);
+}
+function directiveOfNode(schema, node) {
+    const directiveDef = schema.directive(node.name.value);
+    validate(directiveDef, () => `Unknown directive "@${node.name.value}"`);
+    return new definitions_1.Directive(directiveDef.name, (0, values_1.argumentsFromAST)(directiveDef.coordinate, node.arguments, directiveDef));
+}
+function directivesOfNodes(schema, nodes) {
+    var _a;
+    return (_a = nodes === null || nodes === void 0 ? void 0 : nodes.map((n) => directiveOfNode(schema, n))) !== null && _a !== void 0 ? _a : [];
+}
+function selectionOfNode(parentType, node, variableDefinitions, fragments, fieldAccessor = (type, name) => type.field(name)) {
+    var _a, _b;
+    let selection;
+    const directives = directivesOfNodes(parentType.schema(), node.directives);
+    switch (node.kind) {
+        case graphql_1.Kind.FIELD:
+            const definition = fieldAccessor(parentType, node.name.value);
+            validate(definition, () => `Cannot query field "${node.name.value}" on type "${parentType}".`, parentType.sourceAST);
+            const type = (0, definitions_1.baseType)(definition.type);
+            const selectionSet = node.selectionSet
+                ? selectionSetOfNode(type, node.selectionSet, variableDefinitions, fragments, fieldAccessor)
+                : undefined;
+            selection = new FieldSelection(new Field(definition, (0, values_1.argumentsFromAST)(definition.coordinate, node.arguments, definition), directives, (_a = node.alias) === null || _a === void 0 ? void 0 : _a.value), selectionSet);
+            break;
+        case graphql_1.Kind.INLINE_FRAGMENT:
+            const element = new FragmentElement(parentType, (_b = node.typeCondition) === null || _b === void 0 ? void 0 : _b.name.value, directives);
+            selection = new InlineFragmentSelection(element, selectionSetOfNode(element.typeCondition ? element.typeCondition : element.parentType, node.selectionSet, variableDefinitions, fragments, fieldAccessor));
+            break;
+        case graphql_1.Kind.FRAGMENT_SPREAD:
+            const fragmentName = node.name.value;
+            validate(fragments, () => `Cannot find fragment name "${fragmentName}" (no fragments were provided)`);
+            const fragment = fragments.get(fragmentName);
+            validate(fragment, () => `Cannot find fragment name "${fragmentName}" (provided fragments are: [${fragments.names().join(', ')}])`);
+            selection = new FragmentSpreadSelection(parentType, fragments, fragment, directives);
+            break;
+    }
+    return selection;
+}
 function operationFromDocument(schema, document, options) {
     let operation;
     const operationName = options === null || options === void 0 ? void 0 : options.operationName;
@@ -1569,9 +1901,7 @@ function operationFromDocument(schema, document, options) {
                 if (!(0, definitions_1.isCompositeType)(typeCondition)) {
                     throw error_1.ERRORS.INVALID_GRAPHQL.err(`Invalid fragment "${name}" on non-composite type "${typeName}"`, { nodes: definition });
                 }
-                const fragment = new NamedFragmentDefinition(schema, name, typeCondition, new SelectionSet(typeCondition, fragments));
-                addDirectiveNodesToElement(definition.directives, fragment);
-                fragments.add(fragment);
+                fragments.add(new NamedFragmentDefinition(schema, name, typeCondition, directivesOfNodes(schema, definition.directives)));
                 break;
         }
     });
@@ -1583,11 +1913,11 @@ function operationFromDocument(schema, document, options) {
         switch (definition.kind) {
             case graphql_1.Kind.FRAGMENT_DEFINITION:
                 const fragment = fragments.get(definition.name.value);
-                fragment.selectionSet.addSelectionSetNode(definition.selectionSet, variableDefinitions);
+                fragment.setSelectionSet(selectionSetOfNode(fragment.typeCondition, definition.selectionSet, variableDefinitions, fragments));
                 break;
         }
     });
-    fragments.validate();
+    fragments.validate(variableDefinitions);
     return operationFromAST({ schema, operation, variableDefinitions, fragments, validateInput: options === null || options === void 0 ? void 0 : options.validate });
 }
 exports.operationFromDocument = operationFromDocument;
@@ -1599,7 +1929,7 @@ function operationFromAST({ schema, operation, variableDefinitions, fragments, v
         parentType: rootType.type,
         source: operation.selectionSet,
         variableDefinitions,
-        fragments,
+        fragments: fragments.isEmpty() ? undefined : fragments,
         validate: validateInput,
     }), variableDefinitions, (_a = operation.name) === null || _a === void 0 ? void 0 : _a.value);
 }
@@ -1607,14 +1937,13 @@ function parseOperation(schema, operation, options) {
     return operationFromDocument(schema, (0, graphql_1.parse)(operation), options);
 }
 exports.parseOperation = parseOperation;
-function parseSelectionSet({ parentType, source, variableDefinitions, fragments, fieldAccessor, validate = true, }) {
+function parseSelectionSet({ parentType, source, variableDefinitions = new definitions_1.VariableDefinitions(), fragments, fieldAccessor, validate = true, }) {
     const node = typeof source === 'string'
         ? parseOperationAST(source.trim().startsWith('{') ? source : `{${source}}`).selectionSet
         : source;
-    const selectionSet = new SelectionSet(parentType, fragments);
-    selectionSet.addSelectionSetNode(node, variableDefinitions !== null && variableDefinitions !== void 0 ? variableDefinitions : new definitions_1.VariableDefinitions(), fieldAccessor);
+    const selectionSet = selectionSetOfNode(parentType, node, variableDefinitions !== null && variableDefinitions !== void 0 ? variableDefinitions : new definitions_1.VariableDefinitions(), fragments, fieldAccessor);
     if (validate)
-        selectionSet.validate();
+        selectionSet.validate(variableDefinitions);
     return selectionSet;
 }
 exports.parseSelectionSet = parseSelectionSet;