@apollo/federation-internals 2.1.0-alpha.4 → 2.1.2-alpha.0

package/src/error.ts

@@ -56,6 +56,62 @@ export function extractGraphQLErrorOptions(e: GraphQLError): GraphQLErrorOptions
   };
 }
 
+class AggregateGraphQLError extends GraphQLError {
+  constructor(
+    code: String,
+    message: string,
+    readonly causes: GraphQLError[],
+    options?: GraphQLErrorOptions,
+  ) {
+    super(
+      message + '. Caused by:\n' + causes.map((c) => c.toString()).join('\n\n'),
+      {
+        ...options,
+        extensions: { code },
+      }
+    );
+  }
+
+  toString() {
+    let output = `[${this.extensions.code}] ${super.toString()}`
+    output += "\ncaused by:";
+    for (const cause of this.causes) {
+      output += "\n\n  - ";
+      output += cause.toString().split("\n").join("\n    ");
+    }
+    return output;
+  }
+}
+
+export function aggregateError(code: String, message: string, causes: GraphQLError[]): GraphQLError {
+  return new AggregateGraphQLError(code, message, causes);
+}
+
+/**
+ * Given an error, check if it is a graphQL error and potentially extract its causes if is aggregate.
+ * If the error is not a graphQL error, undefined is returned.
+ */
+export function errorCauses(e: Error): GraphQLError[] | undefined {
+  if (e instanceof AggregateGraphQLError) {
+    return e.causes;
+  }
+  if (e instanceof GraphQLError) {
+    return [e];
+  }
+  return undefined;
+}
+
+export function printGraphQLErrorsOrRethrow(e: Error): string {
+  const causes = errorCauses(e);
+  if (!causes) {
+    throw e;
+  }
+  return causes.map(e => e.toString()).join('\n\n');
+}
+
+export function printErrors(errors: GraphQLError[]): string {
+  return errors.map(e => e.toString()).join('\n\n');
+}
 /*
  * Most codes currently originate from the initial fed 2 release so we use this for convenience.
  * This can be changed later, inline versions everywhere, if that becomes irrelevant.
@@ -144,6 +200,11 @@ const TYPE_DEFINITION_INVALID = makeCodeDefinition(
   'A built-in or federation type has an invalid definition in the schema.',
 );
 
+const UNSUPPORTED_LINKED_FEATURE = makeCodeDefinition(
+  'UNSUPPORTED_LINKED_FEATURE',
+  'Indicates that a feature used in a @link is either unsupported or is used with unsupported options.',
+);
+
 const UNKNOWN_FEDERATION_LINK_VERSION = makeCodeDefinition(
   'UNKNOWN_FEDERATION_LINK_VERSION',
   'The version of federation in a @link directive on the schema is unknown.',
@@ -479,6 +540,7 @@ export const ERRORS = {
   INVALID_GRAPHQL,
   DIRECTIVE_DEFINITION_INVALID,
   TYPE_DEFINITION_INVALID,
+  UNSUPPORTED_LINKED_FEATURE,
   UNKNOWN_FEDERATION_LINK_VERSION,
   UNKNOWN_LINK_VERSION,
   KEY_FIELDS_HAS_ARGS,

package/src/extractSubgraphsFromSupergraph.ts

@@ -34,6 +34,7 @@ import { validateSupergraph } from "./supergraphs";
 import { builtTypeReference } from "./buildSchema";
 import { isSubtype } from "./types";
 import { printSchema } from "./print";
+import { parseSelectionSet } from "./operations";
 import fs from 'fs';
 import path from 'path';
 import { validateStringContainsBoolean } from "./utils";
@@ -82,6 +83,114 @@ class SubgraphExtractionError {
   }
 }
 
+function collectFieldReachableTypesForSubgraph(
+  supergraph: Schema,
+  subgraphName: string,
+  addReachableType: (t: NamedType) => void,
+  fieldInfoInSubgraph: (f: FieldDefinition<any> | InputFieldDefinition, subgraphName: string) => { isInSubgraph: boolean, typesInFederationDirectives: NamedType[] },
+  typeInfoInSubgraph: (t: NamedType, subgraphName: string) => { isEntityWithKeyInSubgraph: boolean, typesInFederationDirectives: NamedType[] },
+): void {
+  const seenTypes = new Set<string>();
+  // The types reachable at "top-level" are both the root types, plus any entity type with a key in this subgraph.
+  const stack = supergraph.schemaDefinition.roots().map((root) => root.type as NamedType)
+  for (const type of supergraph.types()) {
+    const { isEntityWithKeyInSubgraph, typesInFederationDirectives } = typeInfoInSubgraph(type, subgraphName);
+    if (isEntityWithKeyInSubgraph) {
+      stack.push(type);
+    }
+    typesInFederationDirectives.forEach((t) => stack.push(t));
+  }
+  while (stack.length > 0) {
+    const type = stack.pop()!;
+    addReachableType(type);
+    if (seenTypes.has(type.name)) {
+      continue;
+    }
+    seenTypes.add(type.name);
+    switch (type.kind) {
+      // @ts-expect-error: we fall-through to ObjectType for fields and implemented interfaces.
+      case 'InterfaceType':
+        // If an interface if reachable, then all of its implementation are too (a field returning the interface could return any of the
+        // implementation at runtime typically).
+        type.allImplementations().forEach((t) => stack.push(t));
+      case 'ObjectType':
+        type.interfaces().forEach((t) => stack.push(t));
+        for (const field of type.fields()) {
+          const { isInSubgraph, typesInFederationDirectives } = fieldInfoInSubgraph(field, subgraphName);
+          if (isInSubgraph) {
+            field.arguments().forEach((arg) => stack.push(baseType(arg.type!)));
+            stack.push(baseType(field.type!));
+            typesInFederationDirectives.forEach((t) => stack.push(t));
+          }
+        }
+        break;
+      case 'InputObjectType':
+        for (const field of type.fields()) {
+          const { isInSubgraph, typesInFederationDirectives } = fieldInfoInSubgraph(field, subgraphName);
+          if (isInSubgraph) {
+            stack.push(baseType(field.type!));
+            typesInFederationDirectives.forEach((t) => stack.push(t));
+          }
+        }
+        break;
+      case 'UnionType':
+        type.members().forEach((m) => stack.push(m.type));
+        break;
+    }
+  }
+
+  for (const directive of supergraph.directives()) {
+    // In fed1 supergraphs, which is the only place this is called, only executable directive from subgraph only ever made
+    // it to the supergraph. Skipping anything else saves us from worrying about supergraph-specific directives too.
+    if (!directive.hasExecutableLocations()) {
+      continue;
+    }
+    directive.arguments().forEach((arg) => stack.push(baseType(arg.type!)));
+  }
+}
+
+function collectFieldReachableTypesForAllSubgraphs(
+  supergraph: Schema,
+  allSubgraphs: readonly string[],
+  fieldInfoInSubgraph: (f: FieldDefinition<any> | InputFieldDefinition, subgraphName: string) => { isInSubgraph: boolean, typesInFederationDirectives: NamedType[] },
+  typeInfoInSubgraph: (t: NamedType, subgraphName: string) => { isEntityWithKeyInSubgraph: boolean, typesInFederationDirectives: NamedType[] },
+): Map<string, Set<string>> {
+  const reachableTypesBySubgraphs = new Map<string, Set<string>>();
+  for (const subgraphName of allSubgraphs) {
+    const reachableTypes = new Set<string>();
+    collectFieldReachableTypesForSubgraph(
+      supergraph,
+      subgraphName,
+      (t) => reachableTypes.add(t.name),
+      fieldInfoInSubgraph,
+      typeInfoInSubgraph,
+    );
+    reachableTypesBySubgraphs.set(subgraphName, reachableTypes);
+  }
+  return reachableTypesBySubgraphs;
+}
+
+function typesUsedInFederationDirective(fieldSet: string | undefined, parentType: CompositeType): NamedType[] {
+  if (!fieldSet) {
+    return [];
+  }
+
+  const usedTypes: NamedType[] = [];
+  parseSelectionSet({
+    parentType,
+    source: fieldSet,
+    fieldAccessor: (type, fieldName) => {
+      const field = type.field(fieldName);
+      if (field) {
+        usedTypes.push(baseType(field.type!));
+      }
+      return field;
+    },
+    validate: false,
+  });
+  return usedTypes;
+}
+
 export function extractSubgraphsFromSupergraph(supergraph: Schema): Subgraphs {
   const [coreFeatures, joinSpec] = validateSupergraph(supergraph);
   const isFed1 = joinSpec.version.equals(new FeatureVersion(0, 1));
@@ -90,6 +199,61 @@ export function extractSubgraphsFromSupergraph(supergraph: Schema): Subgraphs {
     const [subgraphs, graphEnumNameToSubgraphName] = collectEmptySubgraphs(supergraph, joinSpec);
     const typeDirective = joinSpec.typeDirective(supergraph);
     const implementsDirective = joinSpec.implementsDirective(supergraph);
+    const ownerDirective = joinSpec.ownerDirective(supergraph);
+    const fieldDirective = joinSpec.fieldDirective(supergraph);
+
+    const getSubgraph = (application: Directive<any, { graph: string }>) => graphEnumNameToSubgraphName.get(application.arguments().graph);
+
+    /*
+     * Fed2 supergraph have "provenance" information for all types and fields, so we can faithfully extract subgraph relatively easily.
+     * For fed1 supergraph however, only entity types are marked with `@join__type` and `@join__field`. Which mean that for value types,
+     * we cannot directly know in which subgraphs they were initially defined. One strategy consists in "extracting" value types into
+     * all subgraphs blindly: functionally, having some unused types in an extracted subgraph schema does not matter much. However, adding
+     * those useless types increases memory usage, and we've seen some case with lots of subgraphs and lots of value types where those
+     * unused types balloon up memory usage (from 100MB to 1GB in one example; obviously, this is made worst by the fact that javascript
+     * is pretty memory heavy in the first place). So to avoid that problem, for fed1 supergraph, we do a first pass where we collect
+     * for all the subgraphs the set of types that are actually reachable in that subgraph. As we extract do the actual type extraction,
+     * we use this to ignore non-reachable types for any given subgraph.
+     */
+    let includeTypeInSubgraph: (t: NamedType, name: string) => boolean = () => true;
+    if (isFed1) {
+      const reachableTypesBySubgraph = collectFieldReachableTypesForAllSubgraphs(
+        supergraph,
+        subgraphs.names(),
+        (f, name) => {
+          const fieldApplications: Directive<any, { graph: string, requires?: string, provides?: string }>[] = f.appliedDirectivesOf(fieldDirective);
+          if (fieldApplications.length) {
+            const application = fieldApplications.find((application) => getSubgraph(application) === name);
+            if (application) {
+              const args = application.arguments();
+              const typesInFederationDirectives =
+                typesUsedInFederationDirective(args.provides, baseType(f.type!) as CompositeType)
+                .concat(typesUsedInFederationDirective(args.requires, f.parent));
+              return { isInSubgraph: true, typesInFederationDirectives };
+            } else {
+              return { isInSubgraph: false, typesInFederationDirectives: [] };
+            }
+          } else {
+            // No field application depends on the "owner" directive on the type. If we have no owner, then the
+            // field is in all subgraph and we return true. Otherwise, the field is only in the owner subgraph.
+            // In any case, the field cannot have a requires or provides
+            const ownerApplications = ownerDirective ? f.parent.appliedDirectivesOf(ownerDirective) : [];
+            return { isInSubgraph: !ownerApplications.length || getSubgraph(ownerApplications[0]) == name, typesInFederationDirectives: [] };
+          }
+        },
+        (t, name) => {
+          const typeApplications: Directive<any, { graph: string, key?: string}>[] = t.appliedDirectivesOf(typeDirective);
+          const application = typeApplications.find((application) => (application.arguments().key && (getSubgraph(application) === name)));
+          if (application) {
+            const typesInFederationDirectives = typesUsedInFederationDirective(application.arguments().key, t as CompositeType);
+            return { isEntityWithKeyInSubgraph: true, typesInFederationDirectives };
+          } else {
+            return { isEntityWithKeyInSubgraph: false, typesInFederationDirectives: [] };
+          }
+        },
+      );
+      includeTypeInSubgraph = (t, name) => reachableTypesBySubgraph.get(name)?.has(t.name) ?? false;
+    }
 
     // Next, we iterate on all types and add it to the proper subgraphs (along with any @key).
     // Note that we first add all types empty and populate the types next. This avoids having to care about the iteration
@@ -97,13 +261,15 @@ export function extractSubgraphsFromSupergraph(supergraph: Schema): Subgraphs {
     for (const type of filteredTypes(supergraph, joinSpec, coreFeatures.coreDefinition)) {
       const typeApplications = type.appliedDirectivesOf(typeDirective);
       if (!typeApplications.length) {
-        // Imply the type is in all subgraphs (technically, some subgraphs may not have had this type, but adding it
-        // in that case is harmless because it will be unreachable anyway).
-        subgraphs.values().map(sg => sg.schema).forEach(schema => schema.addType(newNamedType(type.kind, type.name)));
+        // Imply we don't know in which subgraph the type is, so we had it in all subgraph in which the type is reachable.
+        subgraphs
+          .values()
+          .filter((sg) => includeTypeInSubgraph(type, sg.name))
+          .map(sg => sg.schema).forEach(schema => schema.addType(newNamedType(type.kind, type.name)));
       } else {
         for (const application of typeApplications) {
           const args = application.arguments();
-          const subgraphName = graphEnumNameToSubgraphName.get(args.graph)!;
+          const subgraphName = getSubgraph(application)!;
           const schema = subgraphs.get(subgraphName)!.schema;
           // We can have more than one type directive for a given subgraph
           let subgraphType = schema.type(type.name);
@@ -121,8 +287,6 @@ export function extractSubgraphsFromSupergraph(supergraph: Schema): Subgraphs {
       }
     }
 
-    const ownerDirective = joinSpec.ownerDirective(supergraph);
-    const fieldDirective = joinSpec.fieldDirective(supergraph);
     // We can now populate all those types (with relevant @provides and @requires on fields).
     for (const type of filteredTypes(supergraph, joinSpec, coreFeatures.coreDefinition)) {
       switch (type.kind) {
@@ -181,7 +345,14 @@ export function extractSubgraphsFromSupergraph(supergraph: Schema): Subgraphs {
                 const args = application.arguments();
                 const subgraph = subgraphs.get(graphEnumNameToSubgraphName.get(args.graph)!)!;
                 const subgraphField = addSubgraphField(field, subgraph, args.type);
-                assert(subgraphField, () => `Found join__field directive for graph ${subgraph.name} on field ${field.coordinate} but no corresponding join__type on ${type}`);
+                if (!subgraphField) {
+                  // It's unlikely but possible that a fed1 supergraph has a `@provides` on a field of a value type,
+                  // and that value type is actually unreachable. Because we trim unreachable types for fed1 supergraph
+                  // (see comment on `includeTypeInSubgraph` above), it would mean we get `undefined` here. It's fine
+                  // however: the type is unreachable in this subgraph, so ignoring that field application is fine too.
+                  assert(!includeTypeInSubgraph(type, subgraph.name), () => `Found join__field directive for graph ${subgraph.name} on field ${field.coordinate} but no corresponding join__type on ${type}`);
+                  continue;
+                }
                 if (args.requires) {
                   subgraphField.applyDirective(subgraph.metadata().requiresDirective(), {'fields': args.requires});
                 }

package/src/federation.ts

@@ -7,7 +7,6 @@ import {
   Directive,
   DirectiveDefinition,
   ErrGraphQLValidationFailed,
-  errorCauses,
   FieldDefinition,
   InputFieldDefinition,
   InterfaceType,
@@ -22,6 +21,7 @@ import {
   ScalarType,
   Schema,
   SchemaBlueprint,
+  SchemaConfig,
   SchemaDefinition,
   SchemaElement,
   sourceASTs,
@@ -54,6 +54,7 @@ import {
   ERRORS,
   withModifiedErrorMessage,
   extractGraphQLErrorOptions,
+  errorCauses,
 } from "./error";
 import { computeShareables } from "./precompute";
 import {
@@ -1024,8 +1025,8 @@ export function buildSubgraph(
   return subgraph.validate();
 }
 
-export function newEmptyFederation2Schema(): Schema {
-  const schema = new Schema(new FederationBlueprint(true));
+export function newEmptyFederation2Schema(config?: SchemaConfig): Schema {
+  const schema = new Schema(new FederationBlueprint(true), config);
   setSchemaAsFed2Subgraph(schema);
   return schema;
 }

package/src/operations.ts

@@ -831,10 +831,11 @@ class DeferNormalizer {
         const deferArgs = selection.element().deferDirectiveArgs();
         if (deferArgs) {
           hasDefers = true;
+          if (!deferArgs.label || deferArgs.if !== undefined) {
+            hasNonLabelledOrConditionalDefers = true;
+          }
           if (deferArgs.label) {
             this.usedLabels.add(deferArgs.label);
-          } else {
-            hasNonLabelledOrConditionalDefers = true;
           }
         }
       }
@@ -951,7 +952,6 @@ export class SelectionSet extends Freezable<SelectionSet> {
     if (names && names.length === 0) {
       return this;
     }
-
     const newFragments = updateSelectionSetFragments
       ? (names ? this.fragments?.without(names) : undefined)
       : this.fragments;
@@ -1052,7 +1052,7 @@ export class SelectionSet extends Freezable<SelectionSet> {
    * This is very similar to `mergeIn` except that it takes a direct array of selection, and the direct aliasing
    * remarks from `mergeInd` applies here too.
    */
-  addAll(selections: Selection[]): SelectionSet {
+  addAll(selections: readonly Selection[]): SelectionSet {
     selections.forEach(s => this.add(s));
     return this;
   }
@@ -1200,9 +1200,6 @@ export class SelectionSet extends Freezable<SelectionSet> {
     validate(!this.isEmpty(), () => `Invalid empty selection set`);
     for (const selection of this.selections()) {
       selection.validate();
-      const selectionFragments = selection.namedFragments();
-      // We make this an assertion because this is a programming error. But validate is a convenient place for this in practice.
-      assert(!selectionFragments || selectionFragments === this.fragments, () => `Selection fragments (${selectionFragments}) for ${selection} does not match selection set one (${this.fragments})`);
     }
   }
 
@@ -1435,17 +1432,15 @@ export class FieldSelection extends Freezable<FieldSelection> {
   }
 
   filter(predicate: (selection: Selection) => boolean): FieldSelection | undefined {
-    if (!predicate(this)) {
-      return undefined;
-    }
     if (!this.selectionSet) {
-      return this;
+      return predicate(this) ? this : undefined;
     }
 
     const updatedSelectionSet = this.selectionSet.filter(predicate);
-    return this.selectionSet === updatedSelectionSet
+    const thisWithFilteredSelectionSet = this.selectionSet === updatedSelectionSet
       ? this
       : new FieldSelection(this.field, updatedSelectionSet);
+    return predicate(thisWithFilteredSelectionSet) ? thisWithFilteredSelectionSet : undefined;
   }
 
   protected freezeInternals(): void {
@@ -1605,6 +1600,8 @@ export abstract class FragmentSelection extends Freezable<FragmentSelection> {
 
   abstract withNormalizedDefer(normalizer: DeferNormalizer): FragmentSelection | SelectionSet;
 
+  abstract updateForAddingTo(selectionSet: SelectionSet): FragmentSelection;
+
   protected us(): FragmentSelection {
     return this;
   }
@@ -1624,40 +1621,15 @@ export abstract class FragmentSelection extends Freezable<FragmentSelection> {
     return mergeVariables(this.element().variables(), this.selectionSet.usedVariables());
   }
 
-  updateForAddingTo(selectionSet: SelectionSet): FragmentSelection {
-    const updatedFragment = this.element().updateForAddingTo(selectionSet);
-    if (this.element() === updatedFragment) {
-      return this.cloneIfFrozen();
-    }
-
-    // Like for fields, we create a new selection that not only uses the updated fragment, but also ensures
-    // the underlying selection set uses the updated type as parent type.
-    const updatedCastedType = updatedFragment.castedType();
-    let updatedSelectionSet : SelectionSet | undefined;
-    if (this.selectionSet.parentType !== updatedCastedType) {
-      updatedSelectionSet = new SelectionSet(updatedCastedType);
-      // Note that re-adding every selection ensures that anything frozen will be cloned as needed, on top of handling any knock-down
-      // effect of the type change.
-      for (const selection of this.selectionSet.selections()) {
-        updatedSelectionSet.add(selection);
-      }
-    } else {
-      updatedSelectionSet = this.selectionSet?.cloneIfFrozen();
-    }
-
-    return new InlineFragmentSelection(updatedFragment, updatedSelectionSet);
-  }
-
   filter(predicate: (selection: Selection) => boolean): FragmentSelection | undefined {
-    if (!predicate(this)) {
-      return undefined;
-    }
     // Note that we essentially expand all fragments as part of this.
     const selectionSet = this.selectionSet;
     const updatedSelectionSet = selectionSet.filter(predicate);
-    return updatedSelectionSet === selectionSet
+    const thisWithFilteredSelectionSet = updatedSelectionSet === selectionSet
       ? this
       : new InlineFragmentSelection(this.element(), updatedSelectionSet);
+
+    return predicate(thisWithFilteredSelectionSet) ? thisWithFilteredSelectionSet : undefined;
   }
 
   protected freezeInternals() {
@@ -1713,6 +1685,31 @@ class InlineFragmentSelection extends FragmentSelection {
     this.selectionSet.validate();
   }
 
+  updateForAddingTo(selectionSet: SelectionSet): FragmentSelection {
+    const updatedFragment = this.element().updateForAddingTo(selectionSet);
+    if (this.element() === updatedFragment) {
+      return this.cloneIfFrozen();
+    }
+
+    // Like for fields, we create a new selection that not only uses the updated fragment, but also ensures
+    // the underlying selection set uses the updated type as parent type.
+    const updatedCastedType = updatedFragment.castedType();
+    let updatedSelectionSet : SelectionSet | undefined;
+    if (this.selectionSet.parentType !== updatedCastedType) {
+      updatedSelectionSet = new SelectionSet(updatedCastedType);
+      // Note that re-adding every selection ensures that anything frozen will be cloned as needed, on top of handling any knock-down
+      // effect of the type change.
+      for (const selection of this.selectionSet.selections()) {
+        updatedSelectionSet.add(selection);
+      }
+    } else {
+      updatedSelectionSet = this.selectionSet?.cloneIfFrozen();
+    }
+
+    return new InlineFragmentSelection(updatedFragment, updatedSelectionSet);
+  }
+
+
   get selectionSet(): SelectionSet {
     return this._selectionSet;
   }
@@ -1753,12 +1750,17 @@ class InlineFragmentSelection extends FragmentSelection {
           const spread = new FragmentSpreadSelection(this.element().parentType, fragments, candidate.name);
           // We use the fragment when the fragments condition is either the same, or a supertype of our current condition.
           // If it's the same type, then we don't really want to preserve the current condition, it is included in the
-          // spread and we can return it directive. But if the fragment condition is a superset, then we should preserve
+          // spread and we can return it directly. But if the fragment condition is a superset, then we should preserve
           // our current condition since it restricts the selection more than the fragment actual does.
           if (sameType(typeCondition, candidate.typeCondition)) {
+            // If we ignore the current condition, then we need to ensure any directive applied to it are preserved.
+            this.fragmentElement.appliedDirectives.forEach((directive) => {
+              spread.element().applyDirective(directive.definition!, directive.arguments());
+            })
             return spread;
           }
           optimizedSelection = selectionSetOf(spread.element().parentType, spread);
+          break;
         }
       }
     }
@@ -1785,7 +1787,6 @@ class InlineFragmentSelection extends FragmentSelection {
     if (updatedSubSelections === this.selectionSet && !hasDeferToRemove) {
       return this;
     }
-
     const newFragment = hasDeferToRemove ? this.fragmentElement.withoutDefer() : this.fragmentElement;
     if (!newFragment) {
       return updatedSubSelections;
@@ -1877,13 +1878,23 @@ class FragmentSpreadSelection extends FragmentSelection {
     return this;
   }
 
+  updateForAddingTo(_selectionSet: SelectionSet): FragmentSelection {
+    // This is a little bit iffy, because the fragment could link to a schema (typically the supergraph API one)
+    // that is different from the one of `_selectionSet` (say, a subgraph fetch selection in which we're trying to
+    // reuse a user fragment). But in practice, we expand all fragments when we do query planning and only re-add
+    // fragments back at the very end, so this should be fine. Importantly, we don't want this method to mistakenly
+    // expand the spread, as that would compromise the code that optimize subgraph fetches to re-use named
+    // fragments.
+    return this;
+  }
+
   expandFragments(names?: string[], updateSelectionSetFragments: boolean = true): FragmentSelection | readonly Selection[] {
     if (names && !names.includes(this.namedFragment.name)) {
       return this;
     }
 
     const expandedSubSelections = this.selectionSet.expandFragments(names, updateSelectionSetFragments);
-    return sameType(this._element.parentType, this.namedFragment.typeCondition)
+    return sameType(this._element.parentType, this.namedFragment.typeCondition) && this._element.appliedDirectives.length === 0
       ? expandedSubSelections.selections()
       : new InlineFragmentSelection(this._element, expandedSubSelections);
   }
@@ -1920,9 +1931,13 @@ class FragmentSpreadSelection extends FragmentSelection {
 export function operationFromDocument(
   schema: Schema,
   document: DocumentNode,
-  operationName?: string,
+  options?: {
+    operationName?: string,
+    validate?: boolean,
+  }
 ) : Operation {
   let operation: OperationDefinitionNode | undefined;
+  const operationName = options?.operationName;
   const fragments = new NamedFragments();
   // We do a first pass to collect the operation, and create all named fragment, but without their selection set yet.
   // This allow later to be able to access any fragment regardless of the order in which the fragments are defined.
@@ -1967,14 +1982,20 @@ export function operationFromDocument(
     }
   });
   fragments.validate();
-  return operationFromAST(schema, operation, fragments);
+  return operationFromAST({schema, operation, fragments, validateInput: options?.validate});
 }
 
-function operationFromAST(
+function operationFromAST({
+  schema,
+  operation,
+  fragments,
+  validateInput,
+}:{
   schema: Schema,
   operation: OperationDefinitionNode,
-  fragments: NamedFragments
-) : Operation {
+  fragments: NamedFragments,
+  validateInput?: boolean,
+}) : Operation {
   const rootType = schema.schemaDefinition.root(operation.operation);
   validate(rootType, () => `The schema has no "${operation.operation}" root type defined`);
   const variableDefinitions = operation.variableDefinitions ? variableDefinitionsFromAST(schema, operation.variableDefinitions) : new VariableDefinitions();
@@ -1985,14 +2006,22 @@ function operationFromAST(
       source: operation.selectionSet,
       variableDefinitions,
       fragments,
+      validate: validateInput,
     }),
     variableDefinitions,
     operation.name?.value
   );
 }
 
-export function parseOperation(schema: Schema, operation: string, operationName?: string): Operation {
-  return operationFromDocument(schema, parse(operation), operationName);
+export function parseOperation(
+  schema: Schema,
+  operation: string,
+  options?: {
+    operationName?: string,
+    validate?: boolean,
+  },
+): Operation {
+  return operationFromDocument(schema, parse(operation), options);
 }
 
 export function parseSelectionSet({

package/src/print.ts

@@ -94,7 +94,7 @@ export function printSchema(schema: Schema, options: PrintOptions = defaultPrint
   return definitions.flat().join('\n\n');
 }
 
-function definitionAndExtensions<T extends ExtendableElement>(element: {extensions(): ReadonlySet<Extension<T>>}, options: PrintOptions): (Extension<any> | null | undefined)[] {
+function definitionAndExtensions<T extends ExtendableElement>(element: {extensions(): readonly Extension<T>[]}, options: PrintOptions): (Extension<any> | null | undefined)[] {
   return options.mergeTypesAndExtensions ? [undefined] : [null, ...element.extensions()];
 }
 
@@ -102,7 +102,7 @@ function printSchemaDefinitionAndExtensions(schemaDefinition: SchemaDefinition,
   return printDefinitionAndExtensions(schemaDefinition, options, printSchemaDefinitionOrExtension);
 }
 
-function printDefinitionAndExtensions<T extends {extensions(): ReadonlySet<Extension<any>>}>(
+function printDefinitionAndExtensions<T extends {extensions(): readonly Extension<any>[]}>(
   t: T,
   options: PrintOptions,
   printer: (t: T, options: PrintOptions, extension?: Extension<any> | null) => string | undefined

package/src/schemaUpgrader.ts

@@ -4,12 +4,11 @@ import {
   Kind,
   print as printAST,
 } from "graphql";
-import { ERRORS } from "./error";
+import { errorCauses, ERRORS } from "./error";
 import {
   baseType,
   CompositeType,
   Directive,
-  errorCauses,
   Extension,
   FieldDefinition,
   isCompositeType,
@@ -432,7 +431,8 @@ class SchemaUpgrader {
 
   private fixFederationDirectivesArguments() {
     for (const directive of [this.metadata.keyDirective(), this.metadata.requiresDirective(), this.metadata.providesDirective()]) {
-      for (const application of directive.applications()) {
+      // Note that we may remove (to replace) some of the application we iterate on, so we need to copy the list we iterate on first.
+      for (const application of Array.from(directive.applications())) {
         const fields = application.arguments().fields;
         if (typeof fields !== 'string') {
           // The one case we have seen in practice is user passing an array of string, so we handle that. If it's something else,
@@ -697,7 +697,8 @@ class SchemaUpgrader {
       return;
     }
 
-    for (const application of tagDirective.applications()) {
+    // Copying the list we iterate on as we remove in the loop.
+    for (const application of Array.from(tagDirective.applications())) {
       const element = application.parent;
       if (!(element instanceof FieldDefinition)) {
         continue;