@apollo/federation-internals 2.1.0-alpha.4 → 2.1.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

@@ -951,7 +951,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 +1051,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;
   }
@@ -1605,6 +1604,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,30 +1625,6 @@ 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;
@@ -1713,6 +1690,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;
   }
@@ -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);
   }

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;

package/src/supergraphs.ts

@@ -1,7 +1,6 @@
-import { ASTNode, DocumentNode } from "graphql";
-import { err } from '@apollo/core-schema';
+import { DocumentNode, GraphQLError } from "graphql";
 import { ErrCoreCheckFailed, FeatureUrl, FeatureVersion } from "./coreSpec";
-import { CoreFeature, CoreFeatures, Schema } from "./definitions";
+import { CoreFeatures, Schema, sourceASTs } from "./definitions";
 import { joinIdentity, JoinSpecDefinition, JOIN_VERSIONS } from "./joinSpec";
 import { buildSchema, buildSchemaFromAST } from "./buildSchema";
 import { extractSubgraphsNamesAndUrlsFromSupergraph } from "./extractSubgraphsFromSupergraph";
@@ -18,24 +17,6 @@ const SUPPORTED_FEATURES = new Set([
   'https://specs.apollo.dev/inaccessible/v0.2',
 ]);
 
-export function ErrUnsupportedFeature(feature: CoreFeature): Error {
-  return err('UnsupportedFeature', {
-    message: `feature ${feature.url} is for: ${feature.purpose} but is unsupported`,
-    feature,
-    nodes: feature.directive.sourceAST,
-  });
-}
-
-export function ErrForUnsupported(core: CoreFeature, ...features: readonly CoreFeature[]): Error {
-  return err('ForUnsupported', {
-    message:
-      `the \`for:\` argument is unsupported by version ${core.url.version} ` +
-      `of the core spec. Please upgrade to at least @core v0.2 (https://specs.apollo.dev/core/v0.2).`,
-    features,
-    nodes: [core.directive.sourceAST, ...features.map(f => f.directive.sourceAST)].filter(n => !!n) as ASTNode[]
-  });
-}
-
 const coreVersionZeroDotOneUrl = FeatureUrl.parse('https://specs.apollo.dev/core/v0.1');
 
 export function buildSupergraphSchema(supergraphSdl: string | DocumentNode): [Schema, {name: string, url: string}[]] {
@@ -56,18 +37,28 @@ export function buildSupergraphSchema(supergraphSdl: string | DocumentNode): [Sc
  * Throws if that is not true.
  */
 function checkFeatureSupport(coreFeatures: CoreFeatures) {
-  const errors = [];
-  if (coreFeatures.coreItself.url.equals(coreVersionZeroDotOneUrl)) {
+  const errors: GraphQLError[] = [];
+  const coreItself = coreFeatures.coreItself;
+  if (coreItself.url.equals(coreVersionZeroDotOneUrl)) {
     const purposefulFeatures = [...coreFeatures.allFeatures()].filter(f => f.purpose)
     if (purposefulFeatures.length > 0) {
-      errors.push(ErrForUnsupported(coreFeatures.coreItself, ...purposefulFeatures));
+      errors.push(ERRORS.UNSUPPORTED_LINKED_FEATURE.err(
+        `the \`for:\` argument is unsupported by version ${coreItself.url.version} ` +
+        `of the core spec. Please upgrade to at least @core v0.2 (https://specs.apollo.dev/core/v0.2).`,
+        {
+          nodes: sourceASTs(coreItself.directive, ...purposefulFeatures.map(f => f.directive))
+        }
+      ));
     }
   }
 
   for (const feature of coreFeatures.allFeatures()) {
     if (feature.url.equals(coreVersionZeroDotOneUrl) || feature.purpose === 'EXECUTION' || feature.purpose === 'SECURITY') {
       if (!SUPPORTED_FEATURES.has(feature.url.base.toString())) {
-        errors.push(ErrUnsupportedFeature(feature));
+        errors.push(ERRORS.UNSUPPORTED_LINKED_FEATURE.err(
+          `feature ${feature.url} is for: ${feature.purpose} but is unsupported`,
+          { nodes: feature.directive.sourceAST },
+        ));
       }
     }
   }

package/src/utils.ts

@@ -394,3 +394,18 @@ export type Concrete<Type> = {
 //   const x = [1,2,undefined];
 //   const y: number[] = x.filter(isDefined);
 export const isDefined = <T>(t: T | undefined): t is T => t === undefined ? false : true;
+
+/**
+ * Removes the first occurrence of the provided element in the provided array, if said array contains said elements.
+ *
+ * @return whether the element was removed.
+ */
+export function removeArrayElement<T>(element: T, array: T[]): boolean {
+  const index = array.indexOf(element);
+  if (index >= 0) {
+    array.splice(index, 1);
+    return true;
+  } else {
+    return false;
+  }
+}