@apollo/federation-internals 2.1.2-alpha.0 → 2.1.2-alpha.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@apollo/federation-internals",
-  "version": "2.1.2-alpha.0",
+  "version": "2.1.2-alpha.2",
   "description": "Apollo Federation internal utilities",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -32,5 +32,5 @@
   "peerDependencies": {
     "graphql": "^16.5.0"
   },
-  "gitHead": "4ee2da1aaa93f08f1b9ff173b6ab9b895e3a53fc"
+  "gitHead": "c7bb87702c5913f5a0ecc5c2a28d2f7228e2988c"
 }

package/src/__tests__/subgraphValidation.test.ts

@@ -60,22 +60,6 @@ describe('fieldset-based directives', () => {
     ]);
   });
 
-  it('rejects field defined with arguments in @requires', () => {
-    const subgraph =  gql`
-      type Query {
-        t: T
-      }
-
-      type T {
-        f(x: Int): Int @external
-        g: Int @requires(fields: "f")
-      }
-    `
-    expect(buildForErrors(subgraph)).toStrictEqual([
-      ['REQUIRES_FIELDS_HAS_ARGS', '[S] On field "T.g", for @requires(fields: "f"): field T.f cannot be included because it has arguments (fields with argument are not allowed in @requires)']
-    ]);
-  });
-
   it('rejects @provides on non-external fields', () => {
     const subgraph =  gql`
       type Query {
@@ -459,6 +443,61 @@ describe('fieldset-based directives', () => {
       ['PROVIDES_FIELDS_MISSING_EXTERNAL', '[S] On field "Query.t", for @provides(fields: "f(x: 3)"): field "T.f" should not be part of a @provides since it is already provided by this subgraph (it is not marked @external)'],
     ]);
   });
+
+  it('rejects aliases in @key', () => {
+    const subgraph =  gql`
+      type Query {
+        t: T
+      }
+
+      type T @key(fields: "foo: id") {
+        id: ID!
+      }
+    `
+    expect(buildForErrors(subgraph)).toStrictEqual([
+      [ 'KEY_INVALID_FIELDS', '[S] On type "T", for @key(fields: "foo: id"): Cannot use alias "foo" in "foo: id": aliases are not currently supported in @key' ],
+    ]);
+  });
+
+  it('rejects aliases in @provides', () => {
+    const subgraph =  gql`
+      type Query {
+        t: T @provides(fields: "bar: x")
+      }
+
+      type T @key(fields: "id") {
+        id: ID!
+        x: Int @external
+      }
+    `
+    expect(buildForErrors(subgraph)).toStrictEqual([
+      [ 'PROVIDES_INVALID_FIELDS', '[S] On field "Query.t", for @provides(fields: "bar: x"): Cannot use alias "bar" in "bar: x": aliases are not currently supported in @provides' ],
+    ]);
+  });
+
+  it('rejects aliases in @requires', () => {
+    const subgraph =  gql`
+      type Query {
+        t: T
+      }
+
+      type T {
+        x: X @external
+        y: Int @external
+        g: Int @requires(fields: "foo: y")
+        h: Int @requires(fields: "x { m: a n: b }")
+      }
+
+      type X {
+        a: Int
+        b: Int
+      }
+    `
+    expect(buildForErrors(subgraph)).toStrictEqual([
+      [ 'REQUIRES_INVALID_FIELDS', '[S] On field "T.g", for @requires(fields: "foo: y"): Cannot use alias "foo" in "foo: y": aliases are not currently supported in @requires' ],
+      [ 'REQUIRES_INVALID_FIELDS', '[S] On field "T.h", for @requires(fields: "x { m: a n: b }"): Cannot use alias "m" in "m: a": aliases are not currently supported in @requires' ],
+    ]);
+  });
 });
 
 describe('root types', () => {

package/src/error.ts

@@ -223,7 +223,6 @@ const FIELDS_HAS_ARGS = makeFederationDirectiveErrorCodeCategory(
 
 const KEY_FIELDS_HAS_ARGS = FIELDS_HAS_ARGS.createCode('key');
 const PROVIDES_FIELDS_HAS_ARGS = FIELDS_HAS_ARGS.createCode('provides');
-const REQUIRES_FIELDS_HAS_ARGS = FIELDS_HAS_ARGS.createCode('requires');
 
 const DIRECTIVE_FIELDS_MISSING_EXTERNAL = makeFederationDirectiveErrorCodeCategory(
   'FIELDS_MISSING_EXTERNAL',
@@ -545,7 +544,6 @@ export const ERRORS = {
   UNKNOWN_LINK_VERSION,
   KEY_FIELDS_HAS_ARGS,
   PROVIDES_FIELDS_HAS_ARGS,
-  REQUIRES_FIELDS_HAS_ARGS,
   PROVIDES_MISSING_EXTERNAL,
   REQUIRES_MISSING_EXTERNAL,
   KEY_UNSUPPORTED_ON_INTERFACE,
@@ -644,4 +642,5 @@ export const REMOVED_ERRORS = [
   ['RESERVED_FIELD_USED', 'This error was previously not correctly enforced: the _service and _entities, if present, were overridden; this is still the case'],
 
   ['NON_REPEATABLE_DIRECTIVE_ARGUMENTS_MISMATCH', 'Since federation 2.1.0, the case this error used to cover is now a warning (with code `INCONSISTENT_NON_REPEATABLE_DIRECTIVE_ARGUMENTS`) instead of an error'],
+  ['REQUIRES_FIELDS_HAS_ARGS', 'Since federation 2.1.1, using fields with arguments in a @requires is fully supported'],
 ];

package/src/federation.ts

@@ -116,14 +116,23 @@ const FEDERATION_SPECIFIC_VALIDATION_RULES = [
 const FEDERATION_VALIDATION_RULES = specifiedSDLRules.filter(rule => !FEDERATION_OMITTED_VALIDATION_RULES.includes(rule)).concat(FEDERATION_SPECIFIC_VALIDATION_RULES);
 
 
-function validateFieldSetSelections(
+function validateFieldSetSelections({
+  directiveName,
+  selectionSet,
+  hasExternalInParents,
+  metadata,
+  onError,
+  allowOnNonExternalLeafFields,
+  allowFieldsWithArguments,
+}: {
   directiveName: string,
   selectionSet: SelectionSet,
   hasExternalInParents: boolean,
-  federationMetadata: FederationMetadata,
+  metadata: FederationMetadata,
   onError: (error: GraphQLError) => void,
   allowOnNonExternalLeafFields: boolean,
-): void {
+  allowFieldsWithArguments: boolean,
+}): void {
   for (const selection of selectionSet.selections()) {
     const appliedDirectives = selection.element().appliedDirectives;
     if (appliedDirectives.length > 0) {
@@ -134,8 +143,8 @@ function validateFieldSetSelections(
 
     if (selection.kind === 'FieldSelection') {
       const field = selection.element().definition;
-      const isExternal = federationMetadata.isFieldExternal(field);
-      if (field.hasArguments()) {
+      const isExternal = metadata.isFieldExternal(field);
+      if (!allowFieldsWithArguments && field.hasArguments()) {
         onError(ERROR_CATEGORIES.FIELDS_HAS_ARGS.get(directiveName).err(
           `field ${field.coordinate} cannot be included because it has arguments (fields with argument are not allowed in @${directiveName})`,
           { nodes: field.sourceAST },
@@ -145,7 +154,7 @@ function validateFieldSetSelections(
       const mustBeExternal = !selection.selectionSet && !allowOnNonExternalLeafFields && !hasExternalInParents;
       if (!isExternal && mustBeExternal) {
         const errorCode = ERROR_CATEGORIES.DIRECTIVE_FIELDS_MISSING_EXTERNAL.get(directiveName);
-        if (federationMetadata.isFieldFakeExternal(field)) {
+        if (metadata.isFieldFakeExternal(field)) {
           onError(errorCode.err(
             `field "${field.coordinate}" should not be part of a @${directiveName} since it is already "effectively" provided by this subgraph `
               + `(while it is marked @${externalDirectiveSpec.name}, it is a @${keyDirectiveSpec.name} field of an extension type, which are not internally considered external for historical/backward compatibility reasons)`,
@@ -167,28 +176,53 @@ function validateFieldSetSelections(
         if (!newHasExternalInParents && isInterfaceType(parentType)) {
           for (const implem of parentType.possibleRuntimeTypes()) {
             const fieldInImplem = implem.field(field.name);
-            if (fieldInImplem && federationMetadata.isFieldExternal(fieldInImplem)) {
+            if (fieldInImplem && metadata.isFieldExternal(fieldInImplem)) {
               newHasExternalInParents = true;
               break;
             }
           }
         }
-        validateFieldSetSelections(directiveName, selection.selectionSet, newHasExternalInParents, federationMetadata, onError, allowOnNonExternalLeafFields);
+        validateFieldSetSelections({
+          directiveName,
+          selectionSet: selection.selectionSet,
+          hasExternalInParents: newHasExternalInParents,
+          metadata,
+          onError,
+          allowOnNonExternalLeafFields,
+          allowFieldsWithArguments,
+        });
       }
     } else {
-      validateFieldSetSelections(directiveName, selection.selectionSet, hasExternalInParents, federationMetadata, onError, allowOnNonExternalLeafFields);
+      validateFieldSetSelections({
+        directiveName,
+        selectionSet: selection.selectionSet,
+        hasExternalInParents,
+        metadata,
+        onError,
+        allowOnNonExternalLeafFields,
+        allowFieldsWithArguments,
+      });
     }
   }
 }
 
-function validateFieldSet(
+function validateFieldSet({
+  type,
+  directive,
+  metadata,
+  errorCollector,
+  allowOnNonExternalLeafFields,
+  allowFieldsWithArguments,
+  onFields,
+}: {
   type: CompositeType,
   directive: Directive<any, {fields: any}>,
-  federationMetadata: FederationMetadata,
+  metadata: FederationMetadata,
   errorCollector: GraphQLError[],
   allowOnNonExternalLeafFields: boolean,
+  allowFieldsWithArguments: boolean,
   onFields?: (field: FieldDefinition<any>) => void,
-): void {
+}): void {
   try {
     // Note that `parseFieldSetArgument` already properly format the error, hence the separate try-catch.
     // TODO: `parseFieldSetArgument` throws on the first issue found and never accumulate multiple
@@ -206,14 +240,15 @@ function validateFieldSet(
       }
       : undefined;
     const selectionSet = parseFieldSetArgument({parentType: type, directive, fieldAccessor});
-    validateFieldSetSelections(
-      directive.name,
+    validateFieldSetSelections({
+      directiveName: directive.name,
       selectionSet,
-      false,
-      federationMetadata,
-      (error) => errorCollector.push(handleFieldSetValidationError(directive, error)),
+      hasExternalInParents: false,
+      metadata,
+      onError: (error) => errorCollector.push(handleFieldSetValidationError(directive, error)),
       allowOnNonExternalLeafFields,
-    );
+      allowFieldsWithArguments,
+    });
   } catch (e) {
     if (e instanceof GraphQLError) {
       errorCollector.push(e);
@@ -267,15 +302,25 @@ function fieldSetTargetDescription(directive: Directive<any, {fields: any}>): st
   return `${targetKind} "${directive.parent?.coordinate}"`;
 }
 
-function validateAllFieldSet<TParent extends SchemaElement<any, any>>(
+function validateAllFieldSet<TParent extends SchemaElement<any, any>>({
+  definition,
+  targetTypeExtractor,
+  errorCollector,
+  metadata,
+  isOnParentType = false,
+  allowOnNonExternalLeafFields = false,
+  allowFieldsWithArguments = false,
+  onFields,
+}: {
   definition: DirectiveDefinition<{fields: any}>,
   targetTypeExtractor: (element: TParent) => CompositeType,
   errorCollector: GraphQLError[],
-  federationMetadata: FederationMetadata,
-  isOnParentType: boolean,
-  allowOnNonExternalLeafFields: boolean,
+  metadata: FederationMetadata,
+  isOnParentType?: boolean,
+  allowOnNonExternalLeafFields?: boolean,
+  allowFieldsWithArguments?: boolean,
   onFields?: (field: FieldDefinition<any>) => void,
-): void {
+}): void {
   for (const application of definition.applications()) {
     const elt = application.parent as TParent;
     const type = targetTypeExtractor(elt);
@@ -289,14 +334,15 @@ function validateAllFieldSet<TParent extends SchemaElement<any, any>>(
         { nodes: sourceASTs(application).concat(isOnParentType ? [] : sourceASTs(type)) },
       ));
     }
-    validateFieldSet(
+    validateFieldSet({
       type,
-      application,
-      federationMetadata,
+      directive: application,
+      metadata,
       errorCollector,
       allowOnNonExternalLeafFields,
+      allowFieldsWithArguments,
       onFields,
-    );
+    });
   }
 }
 
@@ -717,7 +763,7 @@ export class FederationBlueprint extends SchemaBlueprint {
   }
 
   onValidation(schema: Schema): GraphQLError[] {
-    const errors = super.onValidation(schema);
+    const errorCollector = super.onValidation(schema);
 
     // We rename all root type to their default names (we do here rather than in `prepareValidation` because
     // that can actually fail).
@@ -730,7 +776,7 @@ export class FederationBlueprint extends SchemaBlueprint {
           // composition error.
           const existing = schema.type(defaultName);
           if (existing) {
-            errors.push(ERROR_CATEGORIES.ROOT_TYPE_USED.get(k).err(
+            errorCollector.push(ERROR_CATEGORIES.ROOT_TYPE_USED.get(k).err(
               `The schema has a type named "${defaultName}" but it is not set as the ${k} root type ("${type.name}" is instead): `
               + 'this is not supported by federation. '
               + 'If a root type does not use its default name, there should be no other type with that default name.',
@@ -748,19 +794,19 @@ export class FederationBlueprint extends SchemaBlueprint {
     // accepted, and some of those issues are fixed by `SchemaUpgrader`. So insofar as any fed 1 scheam is ultimately converted
     // to a fed 2 one before composition, then skipping some validation on fed 1 schema is fine.
     if (!metadata.isFed2Schema()) {
-      return errors;
+      return errorCollector;
     }
 
     // We validate the @key, @requires and @provides.
     const keyDirective = metadata.keyDirective();
-    validateAllFieldSet<CompositeType>(
-      keyDirective,
-      type => type,
-      errors,
+    validateAllFieldSet<CompositeType>({
+      definition: keyDirective,
+      targetTypeExtractor: type => type,
+      errorCollector,
       metadata,
-      true,
-      true,
-      field => {
+      isOnParentType: true,
+      allowOnNonExternalLeafFields: true,
+      onFields: field => {
         const type = baseType(field.type!);
         if (isUnionType(type) || isInterfaceType(type)) {
           let kind: string = type.kind;
@@ -770,7 +816,7 @@ export class FederationBlueprint extends SchemaBlueprint {
           );
         }
       }
-    );
+    });
     // Note that we currently reject @requires where a leaf field of the selection is not external,
     // because if it's provided by the current subgraph, why "requires" it? That said, it's not 100%
     // nonsensical if you wanted a local field to be part of the subgraph fetch even if it's not
@@ -778,21 +824,20 @@ export class FederationBlueprint extends SchemaBlueprint {
     // rejecting it as it also make it less likely user misunderstand what @requires actually do.
     // But we could consider lifting that limitation if users comes with a good rational for allowing
     // it.
-    validateAllFieldSet<FieldDefinition<CompositeType>>(
-      metadata.requiresDirective(),
-      field => field.parent,
-      errors,
+    validateAllFieldSet<FieldDefinition<CompositeType>>({
+      definition: metadata.requiresDirective(),
+      targetTypeExtractor: field => field.parent,
+      errorCollector,
       metadata,
-      false,
-      false,
-    );
+      allowFieldsWithArguments: true,
+    });
     // Note that like for @requires above, we error out if a leaf field of the selection is not
     // external in a @provides (we pass `false` for the `allowOnNonExternalLeafFields` parameter),
     // but contrarily to @requires, there is probably no reason to ever change this, as a @provides
     // of a field already provides is 100% nonsensical.
-    validateAllFieldSet<FieldDefinition<CompositeType>>(
-      metadata.providesDirective(),
-      field => {
+    validateAllFieldSet<FieldDefinition<CompositeType>>({
+      definition: metadata.providesDirective(),
+      targetTypeExtractor: field => {
         if (metadata.isFieldExternal(field)) {
           throw ERRORS.EXTERNAL_COLLISION_WITH_ANOTHER_DIRECTIVE.err(
             `Cannot have both @provides and @external on field "${field.coordinate}"`,
@@ -808,29 +853,27 @@ export class FederationBlueprint extends SchemaBlueprint {
         }
         return type;
       },
-      errors,
+      errorCollector,
       metadata,
-      false,
-      false,
-    );
+    });
 
-    validateNoExternalOnInterfaceFields(metadata, errors);
-    validateAllExternalFieldsUsed(metadata, errors);
+    validateNoExternalOnInterfaceFields(metadata, errorCollector);
+    validateAllExternalFieldsUsed(metadata, errorCollector);
 
     // If tag is redefined by the user, make sure the definition is compatible with what we expect
     const tagDirective = metadata.tagDirective();
     if (tagDirective) {
       const error = tagSpec.checkCompatibleDirective(tagDirective);
       if (error) {
-        errors.push(error);
+        errorCollector.push(error);
       }
     }
 
     for (const itf of schema.interfaceTypes()) {
-      validateInterfaceRuntimeImplementationFieldsTypes(itf, metadata, errors);
+      validateInterfaceRuntimeImplementationFieldsTypes(itf, metadata, errorCollector);
     }
 
-    return errors;
+    return errorCollector;
   }
 
   validationRules(): readonly SDLValidationRule[] {
@@ -1144,21 +1187,32 @@ export function parseFieldSetArgument({
   directive,
   fieldAccessor,
   validate,
+  decorateValidationErrors = true,
 }: {
   parentType: CompositeType,
-  directive: Directive<NamedType | FieldDefinition<CompositeType>, {fields: any}>,
+  directive: Directive<SchemaElement<any, any>, {fields: any}>,
   fieldAccessor?: (type: CompositeType, fieldName: string) => FieldDefinition<any> | undefined,
   validate?: boolean,
+  decorateValidationErrors?: boolean,
 }): SelectionSet {
   try {
-    return parseSelectionSet({
+    const selectionSet = parseSelectionSet({
       parentType,
       source: validateFieldSetValue(directive),
       fieldAccessor,
       validate,
     });
+    if (validate ?? true) {
+      selectionSet.forEachElement((elt) => {
+        if (elt.kind === 'Field' && elt.alias) {
+          // Note that this will be caught by the surrounding catch and "decorated".
+          throw new GraphQLError(`Cannot use alias "${elt.alias}" in "${elt}": aliases are not currently supported in @${directive.name}`);
+        }
+      });
+    }
+    return selectionSet;
   } catch (e) {
-    if (!(e instanceof GraphQLError)) {
+    if (!(e instanceof GraphQLError) || !decorateValidationErrors) {
       throw e;
     }
 
@@ -1226,7 +1280,7 @@ export function collectTargetFields({
   return fields;
 }
 
-function validateFieldSetValue(directive: Directive<NamedType | FieldDefinition<CompositeType>, {fields: any}>): string {
+function validateFieldSetValue(directive: Directive<SchemaElement<any, any>, {fields: any}>): string {
   const fields = directive.arguments().fields;
   const nodes = directive.sourceAST;
   if (typeof fields !== 'string') {
@@ -1501,6 +1555,13 @@ export class Subgraph {
 export type SubgraphASTNode = ASTNode & { subgraph: string };
 
 export function addSubgraphToASTNode(node: ASTNode, subgraph: string): SubgraphASTNode {
+  // We won't override a existing subgraph info: it's not like the subgraph an ASTNode can come
+  // from can ever change and this allow the provided to act as a "default" rather than a
+  // hard setter, which is convenient in `addSubgraphToError` below if some of the AST of
+  // the provided error already have a subgraph "origin".
+  if ('subgraph' in (node as any)) {
+    return node as SubgraphASTNode;
+  }
   return {
     ...node,
     subgraph

package/src/operations.ts

@@ -62,6 +62,8 @@ function haveSameDirectives<TElement extends OperationElement>(op1: TElement, op
 }
 
 abstract class AbstractOperationElement<T extends AbstractOperationElement<T>> extends DirectiveTargetElement<T> {
+  private attachements?: Map<string, string>;
+
   constructor(
     schema: Schema,
     private readonly variablesInElement: Variables
@@ -74,6 +76,25 @@ abstract class AbstractOperationElement<T extends AbstractOperationElement<T>> e
   }
 
   abstract updateForAddingTo(selection: SelectionSet): T;
+
+  addAttachement(key: string, value: string) {
+    if (!this.attachements) {
+      this.attachements = new Map();
+    }
+    this.attachements.set(key, value);
+  }
+
+  getAttachement(key: string): string | undefined {
+    return this.attachements?.get(key);
+  }
+
+  protected copyAttachementsTo(elt: AbstractOperationElement<any>) {
+    if (this.attachements) {
+      for (const [k, v] of this.attachements.entries()) {
+        elt.addAttachement(k, v);
+      }
+    }
+  }
 }
 
 export class Field<TArgs extends {[key: string]: any} = {[key: string]: any}> extends AbstractOperationElement<Field<TArgs>> {
@@ -86,7 +107,6 @@ export class Field<TArgs extends {[key: string]: any} = {[key: string]: any}> ex
     readonly alias?: string
   ) {
     super(definition.schema(), variablesInArguments(args));
-    this.validate();
   }
 
   get name(): string {
@@ -106,6 +126,7 @@ export class Field<TArgs extends {[key: string]: any} = {[key: string]: any}> ex
     for (const directive of this.appliedDirectives) {
       newField.applyDirective(directive.definition!, directive.arguments());
     }
+    this.copyAttachementsTo(newField);
     return newField;
   }
 
@@ -152,7 +173,7 @@ export class Field<TArgs extends {[key: string]: any} = {[key: string]: any}> ex
     return true;
   }
 
-  private validate() {
+  validate() {
     validate(this.name === this.definition.name, () => `Field name "${this.name}" cannot select field "${this.definition.coordinate}: name mismatch"`);
 
     // We need to make sure the field has valid values for every non-optional argument.
@@ -161,7 +182,7 @@ export class Field<TArgs extends {[key: string]: any} = {[key: string]: any}> ex
       if (appliedValue === undefined) {
         validate(
           argDef.defaultValue !== undefined || isNullableType(argDef.type!),
-          () => `Missing mandatory value "${argDef.name}" in field selection "${this}"`);
+          () => `Missing mandatory value for argument "${argDef.name}" of field "${this.definition.coordinate}" in selection "${this}"`);
       } else {
         validate(
           isValidValue(appliedValue, argDef, this.variableDefinitions),
@@ -276,6 +297,7 @@ export class FragmentElement extends AbstractOperationElement<FragmentElement> {
     for (const directive of this.appliedDirectives) {
       newFragment.applyDirective(directive.definition!, directive.arguments());
     }
+    this.copyAttachementsTo(newFragment);
     return newFragment;
   }
 
@@ -326,6 +348,7 @@ export class FragmentElement extends AbstractOperationElement<FragmentElement> {
     }
 
     const updated = new FragmentElement(this.sourceType, this.typeCondition);
+    this.copyAttachementsTo(updated);
     updatedDirectives.forEach((d) => updated.applyDirective(d.definition!, d.arguments()));
     return updated;
   }
@@ -386,6 +409,7 @@ export class FragmentElement extends AbstractOperationElement<FragmentElement> {
     }
 
     const updated = new FragmentElement(this.sourceType, this.typeCondition);
+    this.copyAttachementsTo(updated);
     const deferDirective = this.schema().deferDirective();
     // Re-apply all the non-defer directives
     this.appliedDirectives.filter((d) => d.name !== deferDirective.name).forEach((d) => updated.applyDirective(d.definition!, d.arguments()));
@@ -897,7 +921,7 @@ export class SelectionSet extends Freezable<SelectionSet> {
       this._cachedSelections = selections;
     }
     assert(this._cachedSelections, 'Cache should have been populated');
-    if (reversedOrder) {
+    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];
@@ -1238,8 +1262,10 @@ export class SelectionSet extends Freezable<SelectionSet> {
     // If __typename is selected however, we put it first. It's a detail but as __typename is a bit special it looks better,
     // and it happens to mimic prior behavior on the query plan side so it saves us from changing tests for no good reasons.
     const typenameSelection = this._selections.get(typenameFieldName);
+    const isNonAliasedTypenameSelection =
+      (s: Selection) => s.kind === 'FieldSelection' && !s.field.alias && s.field.name === typenameFieldName;
     if (typenameSelection) {
-      return typenameSelection.concat(this.selections().filter(s => s.kind != 'FieldSelection' || s.field.name !== typenameFieldName));
+      return typenameSelection.concat(this.selections().filter(s => !isNonAliasedTypenameSelection(s)));
     } else {
       return this.selections();
     }
@@ -1258,10 +1284,29 @@ export class SelectionSet extends Freezable<SelectionSet> {
     });
   }
 
+  /**
+   * Calls the provided callback on all the "elements" (including nested ones) of this selection set.
+   * The specific order of traversal should not be relied on.
+   */
+  forEachElement(callback: (elt: OperationElement) => void) {
+    const stack = this.selections().concat();
+    while (stack.length > 0) {
+      const selection = stack.pop()!;
+      callback(selection.element());
+      // Note: we reserve to preserver ordering (since the stack re-reverse). Not a big cost in general
+      // and make output a bit more intuitive.
+      selection.selectionSet?.selections(true).forEach((s) => stack.push(s));
+    }
+  }
+
   clone(): SelectionSet {
     const cloned = new SelectionSet(this.parentType);
     for (const selection of this.selections()) {
-      cloned.add(selection.clone());
+      const clonedSelection = selection.clone();
+      // Note: while we could used cloned.add() directly, this does some checks (in `updatedForAddingTo` in particular)
+      // which we can skip when we clone (since we know the inputs have already gone through that).
+      cloned._selections.add(clonedSelection.key(), clonedSelection);
+      ++cloned._selectionCount;
     }
     return cloned;
   }
@@ -1470,6 +1515,7 @@ export class FieldSelection extends Freezable<FieldSelection> {
   }
 
   validate() {
+    this.field.validate();
     // Note that validation is kind of redundant since `this.selectionSet.validate()` will check that it isn't empty. But doing it
     // allow to provide much better error messages.
     validate(
@@ -1520,6 +1566,10 @@ export class FieldSelection extends Freezable<FieldSelection> {
     };
   }
 
+  withUpdatedSubSelection(newSubSelection: SelectionSet | undefined): FieldSelection {
+    return new FieldSelection(this.field, newSubSelection);
+  }
+
   equals(that: Selection): boolean {
     if (this === that) {
       return true;
@@ -1602,6 +1652,8 @@ export abstract class FragmentSelection extends Freezable<FragmentSelection> {
 
   abstract updateForAddingTo(selectionSet: SelectionSet): FragmentSelection;
 
+  abstract withUpdatedSubSelection(newSubSelection: SelectionSet | undefined): FragmentSelection;
+
   protected us(): FragmentSelection {
     return this;
   }
@@ -1805,6 +1857,10 @@ class InlineFragmentSelection extends FragmentSelection {
       : new InlineFragmentSelection(newFragment, updatedSubSelections);
   }
 
+  withUpdatedSubSelection(newSubSelection: SelectionSet | undefined): InlineFragmentSelection {
+    return new InlineFragmentSelection(this.fragmentElement, newSubSelection);
+  }
+
   toString(expandFragments: boolean = true, indent?: string): string {
     return (indent ?? '') + this.fragmentElement + ' ' + this.selectionSet.toString(expandFragments, true, indent);
   }
@@ -1917,6 +1973,10 @@ class FragmentSpreadSelection extends FragmentSelection {
     return this._element.appliedDirectives.slice(this.namedFragment.appliedDirectives.length);
   }
 
+  withUpdatedSubSelection(_: SelectionSet | undefined): InlineFragmentSelection {
+    assert(false, `Unssupported`);
+  }
+
   toString(expandFragments: boolean = true, indent?: string): string {
     if (expandFragments) {
       return (indent ?? '') + this._element + ' ' + this.selectionSet.toString(true, true, indent);