@apollo/federation-internals 2.0.0-preview.8 → 2.0.0-preview.9

package/src/directiveAndTypeSpecification.ts

@@ -1,8 +1,10 @@
-import { DirectiveLocation, GraphQLError } from "graphql";
+import { ASTNode, DirectiveLocation, GraphQLError } from "graphql";
 import {
   ArgumentDefinition,
   DirectiveDefinition,
+  EnumType,
   InputType,
+  isEnumType,
   isNonNullType,
   isObjectType,
   isUnionType,
@@ -49,13 +51,16 @@ export function createDirectiveSpecification({
   name: string,
   locations: DirectiveLocation[],
   repeatable?: boolean,
-  argumentFct?: (schema: Schema) => ArgumentSpecification[],
+  argumentFct?: (schema: Schema, nameInSchema?: string) => { args: ArgumentSpecification[], errors: GraphQLError[] },
 }): DirectiveSpecification {
   return {
     name,
     checkOrAdd: (schema: Schema, nameInSchema?: string, asBuiltIn?: boolean) => {
-      const args = argumentFct ? argumentFct(schema) : [];
       const actualName = nameInSchema ?? name;
+      const {args, errors} = argumentFct ? argumentFct(schema, actualName) : { args: [], errors: []};
+      if (errors.length > 0) {
+        return errors;
+      }
       const existing = schema.directive(actualName);
       if (existing) {
         return ensureSameDirectiveStructure({name: actualName, locations, repeatable, args}, existing);
@@ -131,7 +136,7 @@ export function createObjectTypeSpecification({
           errors = errors.concat(ensureSameArguments(
             { name, args },
             existingField,
-            `field ${existingField.coordinate}`,
+            `field "${existingField.coordinate}"`,
           ));
         }
         return errors;
@@ -198,6 +203,44 @@ export function createUnionTypeSpecification({
   }
 }
 
+export function createEnumTypeSpecification({
+  name,
+  values,
+}: {
+  name: string,
+  values: { name: string, description?: string}[],
+}): TypeSpecification {
+  return {
+    name,
+    checkOrAdd: (schema: Schema, nameInSchema?: string, asBuiltIn?: boolean) => {
+      const actualName = nameInSchema ?? name;
+      const existing = schema.type(actualName);
+      const expectedValueNames = values.map((v) => v.name).sort((n1, n2) => n1.localeCompare(n2));
+      if (existing) {
+        let errors = ensureSameTypeKind('EnumType', existing);
+        if (errors.length > 0) {
+          return errors;
+        }
+        assert(isEnumType(existing), 'Should be an enum type');
+        const actualValueNames = existing.values.map(v => v.name).sort((n1, n2) => n1.localeCompare(n2));
+        if (!arrayEquals(expectedValueNames, actualValueNames)) {
+          errors = errors.concat(ERRORS.TYPE_DEFINITION_INVALID.err({
+            message: `Invalid definition of type ${name}: expected values [${expectedValueNames}] but found [${actualValueNames}].`,
+            nodes: existing.sourceAST
+          }));
+        }
+        return errors;
+      } else {
+        const type = schema.addType(new EnumType(actualName, asBuiltIn));
+        for (const {name, description} of values) {
+          type.addValue(name).description = description;
+        }
+        return [];
+      }
+    },
+  }
+}
+
 function ensureSameTypeKind(expected: NamedType['kind'], actual: NamedType): GraphQLError[] {
   return expected === actual.kind
     ? []
@@ -216,18 +259,19 @@ function ensureSameDirectiveStructure(
   },
   actual: DirectiveDefinition<any>,
 ): GraphQLError[] {
-  let errors = ensureSameArguments(expected, actual, `directive ${expected}`);
+  const directiveName = `"@${expected.name}"`
+  let errors = ensureSameArguments(expected, actual, `directive ${directiveName}`);
   // It's ok to say you'll never repeat a repeatable directive. It's not ok to repeat one that isn't.
   if (!expected.repeatable && actual.repeatable) {
     errors = errors.concat(ERRORS.DIRECTIVE_DEFINITION_INVALID.err({
-      message: `Invalid definition for directive ${expected}: ${expected} should${expected.repeatable ? "" : " not"} be repeatable`,
+      message: `Invalid definition for directive ${directiveName}: ${directiveName} should${expected.repeatable ? "" : " not"} be repeatable`,
       nodes: actual.sourceAST
     }));
   }
   // Similarly, it's ok to say that you will never use a directive in some locations, but not that you will use it in places not allowed by what is expected.
   if (!actual.locations.every(loc => expected.locations.includes(loc))) {
     errors = errors.concat(ERRORS.DIRECTIVE_DEFINITION_INVALID.err({
-      message: `Invalid efinition for directive ${expected}: ${expected} should have locations ${expected.locations.join(', ')}, but found (non-subset) ${actual.locations.join(', ')}`,
+      message: `Invalid definition for directive ${directiveName}: ${directiveName} should have locations ${expected.locations.join(', ')}, but found (non-subset) ${actual.locations.join(', ')}`,
       nodes: actual.sourceAST
     }));
   }
@@ -241,17 +285,24 @@ function ensureSameArguments(
   },
   actual: { argument(name: string): ArgumentDefinition<any> | undefined, arguments(): readonly ArgumentDefinition<any>[] },
   what: string,
+  containerSourceAST?: ASTNode,
 ): GraphQLError[] {
   const expectedArguments = expected.args ?? [];
-  const foundArguments = actual.arguments();
-  if (expectedArguments.length !== foundArguments.length) {
-    return [ERRORS.DIRECTIVE_DEFINITION_INVALID.err({
-      message: `Invalid definition for ${what}: should have ${expectedArguments.length} arguments but ${foundArguments.length} found`,
-    })];
-  }
-  let errors: GraphQLError[] = [];
+  const errors: GraphQLError[] = [];
   for (const { name, type, defaultValue } of expectedArguments) {
-    const actualArgument = actual.argument(name)!;
+    const actualArgument = actual.argument(name);
+    if (!actualArgument) {
+      // Not declaring an optional argument is ok: that means you won't be able to pass a non-default value in your schema, but we allow you that.
+      // But missing a required argument it not ok.
+      if (isNonNullType(type) && defaultValue === undefined) {
+        errors.push(ERRORS.DIRECTIVE_DEFINITION_INVALID.err({
+          message: `Invalid definition for ${what}: missing required argument "${name}"`,
+          nodes: containerSourceAST
+        }));
+      }
+      continue;
+    }
+
     let actualType = actualArgument.type!;
     if (isNonNullType(actualType) && !isNonNullType(type)) {
       // It's ok to redefine an optional argument as mandatory. For instance, if you want to force people on your team to provide a "deprecation reason", you can
@@ -260,13 +311,22 @@ function ensureSameArguments(
       actualType = actualType.ofType;
     }
     if (!sameType(type, actualType)) {
-      errors = errors.concat(ERRORS.DIRECTIVE_DEFINITION_INVALID.err({
-        message: `Invalid definition of ${what}: ${name} should have type ${type} but found type ${actualArgument.type!}`,
+      errors.push(ERRORS.DIRECTIVE_DEFINITION_INVALID.err({
+        message: `Invalid definition for ${what}: argument "${name}" should have type "${type}" but found type "${actualArgument.type!}"`,
         nodes: actualArgument.sourceAST
       }));
-    } else if (!isNonNullType(actualType) && !valueEquals(defaultValue, actualArgument.defaultValue)) {
-      errors = errors.concat(ERRORS.DIRECTIVE_DEFINITION_INVALID.err({
-        message: `Invalid definition of ${what}: ${name} should have default value ${valueToString(defaultValue)} but found default value ${valueToString(actualArgument.defaultValue)}`,
+    } else if (!isNonNullType(actualArgument.type!) && !valueEquals(defaultValue, actualArgument.defaultValue)) {
+      errors.push(ERRORS.DIRECTIVE_DEFINITION_INVALID.err({
+        message: `Invalid definition for ${what}: argument "${name}" should have default value ${valueToString(defaultValue)} but found default value ${valueToString(actualArgument.defaultValue)}`,
+        nodes: actualArgument.sourceAST
+      }));
+    }
+  }
+  for (const actualArgument of actual.arguments()) {
+    // If it's an expect argument, we already validated it. But we still need to reject unkown argument.
+    if (!expectedArguments.some((arg) => arg.name === actualArgument.name)) {
+      errors.push(ERRORS.DIRECTIVE_DEFINITION_INVALID.err({
+        message: `Invalid definition for ${what}: unknown/unsupported argument "${actualArgument.name}"`,
         nodes: actualArgument.sourceAST
       }));
     }

package/src/error.ts

@@ -359,6 +359,21 @@ const SATISFIABILITY_ERROR = makeCodeDefinition(
   'Subgraphs can be merged, but the resulting supergraph API would have queries that cannot be satisfied by those subgraphs.',
 );
 
+const OVERRIDE_FROM_SELF_ERROR = makeCodeDefinition(
+  'OVERRIDE_FROM_SELF_ERROR',
+  'Field with `@override` directive has "from" location that references its own subgraph.',
+);
+
+const OVERRIDE_SOURCE_HAS_OVERRIDE = makeCodeDefinition(
+  'OVERRIDE_SOURCE_HAS_OVERRIDE',
+  'Field which is overridden to another subgraph is also marked @override.',
+);
+
+const OVERRIDE_COLLISION_WITH_ANOTHER_DIRECTIVE = makeCodeDefinition(
+  'OVERRIDE_COLLISION_WITH_ANOTHER_DIRECTIVE',
+  'The @override directive cannot be used on external fields, nor to override fields with either @external, @provides, or @requires.',
+);
+
 export const ERROR_CATEGORIES = {
   DIRECTIVE_FIELDS_MISSING_EXTERNAL,
   DIRECTIVE_UNSUPPORTED_ON_INTERFACE,
@@ -418,6 +433,9 @@ export const ERRORS = {
   REFERENCED_INACCESSIBLE,
   REQUIRED_ARGUMENT_MISSING_IN_SOME_SUBGRAPH,
   SATISFIABILITY_ERROR,
+  OVERRIDE_COLLISION_WITH_ANOTHER_DIRECTIVE,
+  OVERRIDE_FROM_SELF_ERROR,
+  OVERRIDE_SOURCE_HAS_OVERRIDE,
 };
 
 const codeDefByCode = Object.values(ERRORS).reduce((obj: {[code: string]: ErrorCodeDefinition}, codeDef: ErrorCodeDefinition) => { obj[codeDef.code] = codeDef; return obj; }, {});

package/src/extractSubgraphsFromSupergraph.ts

@@ -181,6 +181,12 @@ export function extractSubgraphsFromSupergraph(supergraph: Schema): Subgraphs {
               if (args.external) {
                 subgraphField.applyDirective(subgraph.metadata().externalDirective());
               }
+              if (args.usedOverridden) {
+                subgraphField.applyDirective(subgraph.metadata().externalDirective(), {'reason': '[overridden]'});
+              }
+              if (args.override) {
+                subgraphField.applyDirective(subgraph.metadata().overrideDirective(), {'from': args.override});
+              }
             }
           }
         }

package/src/federation.ts

@@ -52,7 +52,7 @@ import {
   ERRORS,
   withModifiedErrorMessage,
 } from "./error";
-import { computeShareables } from "./sharing";
+import { computeShareables } from "./precompute";
 import {
   CoreSpecDefinition,
   FeatureVersion,
@@ -71,8 +71,7 @@ import {
   externalDirectiveSpec,
   extendsDirectiveSpec,
   shareableDirectiveSpec,
-  tagDirectiveSpec,
-  inaccessibleDirectiveSpec,
+  overrideDirectiveSpec,
   FEDERATION2_SPEC_DIRECTIVES,
   ALL_FEDERATION_DIRECTIVES_DEFAULT_NAMES,
   FEDERATION2_ONLY_SPEC_DIRECTIVES,
@@ -80,6 +79,7 @@ import {
 import { defaultPrintOptions, PrintOptions as PrintOptions, printSchema } from "./print";
 import { createObjectTypeSpecification, createScalarTypeSpecification, createUnionTypeSpecification } from "./directiveAndTypeSpecification";
 import { didYouMean, suggestionList } from "./suggestions";
+import { inaccessibleDirectiveSpec } from "./inaccessibleSpec";
 
 const linkSpec = LINK_VERSIONS.latest();
 const tagSpec = TAG_VERSIONS.latest();
@@ -263,53 +263,49 @@ function validateAllFieldSet<TParent extends SchemaElement<any, any>>(
   }
 }
 
-export function collectUsedExternalFieldsCoordinates(metadata: FederationMetadata): Set<string> {
-  const usedExternalCoordinates = new Set<string>();
+export function collectUsedFields(metadata: FederationMetadata): Set<FieldDefinition<CompositeType>> {
+  const usedFields = new Set<FieldDefinition<CompositeType>>();
 
   // Collects all external fields used by a key, requires or provides
-  collectUsedExternaFieldsForDirective<CompositeType>(
-    metadata,
+  collectUsedFieldsForDirective<CompositeType>(
     metadata.keyDirective(),
     type => type,
-    usedExternalCoordinates,
+    usedFields,
   );
-  collectUsedExternaFieldsForDirective<FieldDefinition<CompositeType>>(
-    metadata,
+  collectUsedFieldsForDirective<FieldDefinition<CompositeType>>(
     metadata.requiresDirective(),
     field => field.parent!,
-    usedExternalCoordinates,
+    usedFields,
   );
-  collectUsedExternaFieldsForDirective<FieldDefinition<CompositeType>>(
-    metadata,
+  collectUsedFieldsForDirective<FieldDefinition<CompositeType>>(
     metadata.providesDirective(),
     field => {
       const type = baseType(field.type!);
       return isCompositeType(type) ? type : undefined;
     },
-    usedExternalCoordinates,
+    usedFields,
   );
 
-  // Collects all external fields used to satisfy an interface constraint
+  // Collects all fields used to satisfy an interface constraint
   for (const itfType of metadata.schema.types<InterfaceType>('InterfaceType')) {
     const runtimeTypes = itfType.possibleRuntimeTypes();
     for (const field of itfType.fields()) {
       for (const runtimeType of runtimeTypes) {
         const implemField = runtimeType.field(field.name);
-        if (implemField && metadata.isFieldExternal(implemField)) {
-          usedExternalCoordinates.add(implemField.coordinate);
+        if (implemField) {
+          usedFields.add(implemField);
         }
       }
     }
   }
 
-  return usedExternalCoordinates;
+  return usedFields;
 }
 
-function collectUsedExternaFieldsForDirective<TParent extends SchemaElement<any, any>>(
-  metadata: FederationMetadata,
+function collectUsedFieldsForDirective<TParent extends SchemaElement<any, any>>(
   definition: DirectiveDefinition<{fields: any}>,
   targetTypeExtractor: (element: TParent) => CompositeType | undefined,
-  usedExternalCoordinates: Set<string>
+  usedFieldDefs: Set<FieldDefinition<CompositeType>>
 ) {
   for (const application of definition.applications()) {
     const type = targetTypeExtractor(application.parent! as TParent);
@@ -327,8 +323,7 @@ function collectUsedExternaFieldsForDirective<TParent extends SchemaElement<any,
       directive: application as Directive<any, {fields: any}>,
       includeInterfaceFieldsImplementations: true,
       validate: false,
-    }).filter((field) => metadata.isFieldExternal(field))
-      .forEach((field) => usedExternalCoordinates.add(field.coordinate));
+    }).forEach((field) => usedFieldDefs.add(field));
   }
 }
 
@@ -337,23 +332,20 @@ function collectUsedExternaFieldsForDirective<TParent extends SchemaElement<any,
  * interface implementation. Otherwise, the field declaration is somewhat useless.
  */
 function validateAllExternalFieldsUsed(metadata: FederationMetadata, errorCollector: GraphQLError[]): void {
-  const allUsedExternals = collectUsedExternalFieldsCoordinates(metadata);
   for (const type of metadata.schema.types()) {
     if (!isObjectType(type) && !isInterfaceType(type)) {
       continue;
     }
     for (const field of type.fields()) {
-      if (!metadata.isFieldExternal(field) || allUsedExternals.has(field.coordinate)) {
+      if (!metadata.isFieldExternal(field) || metadata.isFieldUsed(field)) {
         continue;
       }
 
-      if (!isFieldSatisfyingInterface(field)) {
-        errorCollector.push(ERRORS.EXTERNAL_UNUSED.err({
-          message: `Field "${field.coordinate}" is marked @external but is not used in any federation directive (@key, @provides, @requires) or to satisfy an interface;`
-          + ' the field declaration has no use and should be removed (or the field should not be @external).',
-          nodes: field.sourceAST,
-        }));
-      }
+      errorCollector.push(ERRORS.EXTERNAL_UNUSED.err({
+        message: `Field "${field.coordinate}" is marked @external but is not used in any federation directive (@key, @provides, @requires) or to satisfy an interface;`
+        + ' the field declaration has no use and should be removed (or the field should not be @external).',
+        nodes: field.sourceAST,
+      }));
     }
   }
 }
@@ -371,10 +363,6 @@ function validateNoExternalOnInterfaceFields(metadata: FederationMetadata, error
   }
 }
 
-function isFieldSatisfyingInterface(field: FieldDefinition<ObjectType | InterfaceType>): boolean {
-  return field.parent.interfaces().some(itf => itf.field(field.name));
-}
-
 /**
  * Register errors when, for an interface field, some of the implementations of that field are @external
  * _and_ not all of those field implementation have the same type (which otherwise allowed because field
@@ -385,7 +373,7 @@ function isFieldSatisfyingInterface(field: FieldDefinition<ObjectType | Interfac
  */
 function validateInterfaceRuntimeImplementationFieldsTypes(
   itf: InterfaceType,
-  metadata: FederationMetadata, 
+  metadata: FederationMetadata,
   errorCollector: GraphQLError[],
 ): void {
   const requiresDirective = federationMetadata(itf.schema())?.requiresDirective();
@@ -426,6 +414,7 @@ function formatFieldsToReturnType([type, implems]: [string, FieldDefinition<Obje
 export class FederationMetadata {
   private _externalTester?: ExternalTester;
   private _sharingPredicate?: (field: FieldDefinition<CompositeType>) => boolean;
+  private _fieldUsedPredicate?: (field: FieldDefinition<CompositeType>) => boolean;
   private _isFed2Schema?: boolean;
 
   constructor(readonly schema: Schema) {
@@ -435,6 +424,7 @@ export class FederationMetadata {
     this._externalTester = undefined;
     this._sharingPredicate = undefined;
     this._isFed2Schema = undefined;
+    this._fieldUsedPredicate = undefined;
   }
 
   isFed2Schema(): boolean {
@@ -463,6 +453,18 @@ export class FederationMetadata {
     return this._sharingPredicate;
   }
 
+  private fieldUsedPredicate(): (field: FieldDefinition<CompositeType>) => boolean {
+    if (!this._fieldUsedPredicate) {
+      const usedFields = collectUsedFields(this);
+      this._fieldUsedPredicate = (field: FieldDefinition<CompositeType>) => !!usedFields.has(field);
+    }
+    return this._fieldUsedPredicate;
+  }
+
+  isFieldUsed(field: FieldDefinition<CompositeType>): boolean {
+    return this.fieldUsedPredicate()(field);
+  }
+
   isFieldExternal(field: FieldDefinition<any> | InputFieldDefinition) {
     return this.externalTester().isExternal(field);
   }
@@ -534,11 +536,15 @@ export class FederationMetadata {
     return this.getFederationDirective(keyDirectiveSpec.name);
   }
 
+  overrideDirective(): DirectiveDefinition<{from: string}> {
+    return this.getFederationDirective(overrideDirectiveSpec.name);
+  }
+
   extendsDirective(): DirectiveDefinition<Record<string, never>> {
     return this.getFederationDirective(extendsDirectiveSpec.name);
   }
 
-  externalDirective(): DirectiveDefinition<Record<string, never>> {
+  externalDirective(): DirectiveDefinition<{reason: string}> {
     return this.getFederationDirective(externalDirectiveSpec.name);
   }
 
@@ -555,7 +561,7 @@ export class FederationMetadata {
   }
 
   tagDirective(): DirectiveDefinition<{name: string}> {
-    return this.getFederationDirective(tagDirectiveSpec.name);
+    return this.getFederationDirective(tagSpec.tagDirectiveSpec.name);
   }
 
   inaccessibleDirective(): DirectiveDefinition<{}> {
@@ -563,7 +569,7 @@ export class FederationMetadata {
   }
 
   allFederationDirectives(): DirectiveDefinition[] {
-    const baseDirectives = [
+    const baseDirectives: DirectiveDefinition[] = [
       this.keyDirective(),
       this.externalDirective(),
       this.requiresDirective(),
@@ -572,7 +578,7 @@ export class FederationMetadata {
       this.extendsDirective(),
     ];
     return this.isFed2Schema()
-      ? baseDirectives.concat(this.shareableDirective(), this.inaccessibleDirective())
+      ? baseDirectives.concat(this.shareableDirective(), this.inaccessibleDirective(), this.overrideDirective())
       : baseDirectives;
   }
 
@@ -618,19 +624,21 @@ export class FederationBlueprint extends SchemaBlueprint {
     }
   }
 
-  onMissingDirectiveDefinition(schema: Schema, name: string): DirectiveDefinition | undefined {
+  onMissingDirectiveDefinition(schema: Schema, name: string, args?: {[key: string]: any}): DirectiveDefinition | GraphQLError[] | undefined {
     if (name === linkDirectiveDefaultName) {
-      linkSpec.addToSchema(schema);
-      return schema.directive(name);
+      const url = args && (args['url'] as string | undefined);
+      const as = url && url.startsWith(linkSpec.identity) ? (args['as'] as string | undefined) : undefined;
+      const errors = linkSpec.addDefinitionsToSchema(schema, as);
+      return errors.length > 0 ? errors : schema.directive(name);
     }
-    return super.onMissingDirectiveDefinition(schema, name);
+    return super.onMissingDirectiveDefinition(schema, name, args);
   }
 
   ignoreParsedField(type: NamedType, fieldName: string): boolean {
     // Historically, federation 1 has accepted invalid schema, including some where the Query type included
     // the definition of `_entities` (so `_entities(representations: [_Any!]!): [_Entity]!`) but _without_
     // defining the `_Any` or `_Entity` type. So while we want to be stricter for fed2 (so this kind of
-    // really weird case can be fixed), we want fed2 to accept as much fed1 schema as possible. 
+    // really weird case can be fixed), we want fed2 to accept as much fed1 schema as possible.
     //
     // So, to avoid this problem, we ignore the _entities and _service fields if we parse them from
     // a fed1 input schema. Those will be added back anyway (along with the proper types) post-parsing.
@@ -648,8 +656,8 @@ export class FederationBlueprint extends SchemaBlueprint {
     }
   }
 
-  onDirectiveDefinitionAndSchemaParsed(schema: Schema) {
-    completeSubgraphSchema(schema);
+  onDirectiveDefinitionAndSchemaParsed(schema: Schema): GraphQLError[] {
+    return completeSubgraphSchema(schema);
   }
 
   onInvalidation(schema: Schema) {
@@ -788,7 +796,6 @@ export class FederationBlueprint extends SchemaBlueprint {
         const federationFeature = metadata.federationFeature();
         assert(federationFeature, 'Fed2 subgraph _must_ link to the federation feature')
         const directiveNameInSchema = federationFeature.directiveNameInSchema(unknownDirectiveName);
-        console.log(`For ${unknownDirectiveName}, name in schema = ${directiveNameInSchema}`);
         if (directiveNameInSchema.startsWith(federationFeature.nameInSchema + '__')) {
           // There is no import for that directive
           return withModifiedErrorMessage(
@@ -804,7 +811,7 @@ export class FederationBlueprint extends SchemaBlueprint {
         }
       } else {
         return withModifiedErrorMessage(
-          error, 
+          error,
           `${error.message} If you meant the "@${unknownDirectiveName}" federation 2 directive, note that this schema is a federation 1 schema. To be a federation 2 schema, it needs to @link to the federation specifcation v2.`
         );
       }
@@ -813,7 +820,7 @@ export class FederationBlueprint extends SchemaBlueprint {
       const suggestions = suggestionList(unknownDirectiveName, FEDERATION2_ONLY_SPEC_DIRECTIVES.map((spec) => spec.name));
       if (suggestions.length > 0) {
         return withModifiedErrorMessage(
-          error, 
+          error,
           `${error.message}${didYouMean(suggestions.map((s) => '@' + s))} If so, note that ${suggestions.length === 1 ? 'it is a federation 2 directive' : 'they are federation 2 directives'} but this schema is a federation 1 one. To be a federation 2 schema, it needs to @link to the federation specifcation v2.`
         );
       }
@@ -851,7 +858,10 @@ export function setSchemaAsFed2Subgraph(schema: Schema) {
     assert(spec.url.version.satisfies(linkSpec.version), `Fed2 schema must use @link with version >= 1.0, but schema uses ${spec.url}`);
   } else {
     const alias = findUnusedNamedForLinkDirective(schema);
-    linkSpec.addToSchema(schema, alias);
+    const errors = linkSpec.addToSchema(schema, alias);
+    if (errors.length > 0) {
+      throw ErrGraphQLValidationFailed(errors);
+    }
     spec = linkSpec;
     core = schema.coreFeatures;
     assert(core, 'Schema should now be a core schema');
@@ -865,12 +875,15 @@ export function setSchemaAsFed2Subgraph(schema: Schema) {
       import: FEDERATION2_SPEC_DIRECTIVES.map((spec) => `@${spec.name}`),
     }
   );
-  completeSubgraphSchema(schema);
+  const errors = completeSubgraphSchema(schema);
+  if (errors.length > 0) {
+    throw ErrGraphQLValidationFailed(errors);
+  }
 }
 
 // This is the full @link declaration as added by `asFed2SubgraphDocument`. It's here primarily for uses by tests that print and match
 // subgraph schema to avoid having to update 20+ tests every time we use a new directive or the order of import changes ...
-export const FEDERATION2_LINK_WTH_FULL_IMPORTS = '@link(url: "https://specs.apollo.dev/federation/v2.0", import: ["@key", "@requires", "@provides", "@external", "@tag", "@extends", "@shareable", "@inaccessible"])';
+export const FEDERATION2_LINK_WTH_FULL_IMPORTS = '@link(url: "https://specs.apollo.dev/federation/v2.0", import: ["@key", "@requires", "@provides", "@external", "@tag", "@extends", "@shareable", "@inaccessible", "@override"])';
 
 export function asFed2SubgraphDocument(document: DocumentNode): DocumentNode {
   const fed2LinkExtension: SchemaExtensionNode = {
@@ -961,22 +974,25 @@ export function newEmptyFederation2Schema(): Schema {
   return schema;
 }
 
-function completeSubgraphSchema(schema: Schema) {
+function completeSubgraphSchema(schema: Schema): GraphQLError[] {
   const coreFeatures = schema.coreFeatures;
   if (coreFeatures) {
     const fedFeature = coreFeatures.getByIdentity(federationIdentity);
     if (fedFeature) {
-      completeFed2SubgraphSchema(schema);
+      return completeFed2SubgraphSchema(schema);
     } else {
-      completeFed1SubgraphSchema(schema);
+      return completeFed1SubgraphSchema(schema);
     }
   } else {
     const fedLink = schema.schemaDefinition.appliedDirectivesOf(linkDirectiveDefaultName).find(isFedSpecLinkDirective);
     if (fedLink) {
-      linkSpec.addToSchema(schema);
-      completeFed2SubgraphSchema(schema);
+      const errors = linkSpec.addToSchema(schema);
+      if (errors.length > 0) {
+        return errors;
+      }
+      return completeFed2SubgraphSchema(schema);
     } else {
-      completeFed1SubgraphSchema(schema);
+      return completeFed1SubgraphSchema(schema);
     }
   }
 }
@@ -986,15 +1002,16 @@ function isFedSpecLinkDirective(directive: Directive<SchemaDefinition>): directi
   return directive.name === linkDirectiveDefaultName && args['url'] && (args['url'] as string).startsWith(federationIdentity);
 }
 
-function completeFed1SubgraphSchema(schema: Schema) {
-  fieldSetTypeSpec.checkOrAdd(schema, '_' + fieldSetTypeSpec.name);
-
-  keyDirectiveSpec.checkOrAdd(schema);
-  requiresDirectiveSpec.checkOrAdd(schema);
-  providesDirectiveSpec.checkOrAdd(schema);
-  extendsDirectiveSpec.checkOrAdd(schema);
-  externalDirectiveSpec.checkOrAdd(schema);
-  tagDirectiveSpec.checkOrAdd(schema);
+function completeFed1SubgraphSchema(schema: Schema): GraphQLError[] {
+  return [
+    fieldSetTypeSpec.checkOrAdd(schema, '_' + fieldSetTypeSpec.name),
+    keyDirectiveSpec.checkOrAdd(schema),
+    requiresDirectiveSpec.checkOrAdd(schema),
+    providesDirectiveSpec.checkOrAdd(schema),
+    extendsDirectiveSpec.checkOrAdd(schema),
+    externalDirectiveSpec.checkOrAdd(schema),
+    tagSpec.tagDirectiveSpec.checkOrAdd(schema),
+  ].flat();
 }
 
 function completeFed2SubgraphSchema(schema: Schema) {
@@ -1006,13 +1023,13 @@ function completeFed2SubgraphSchema(schema: Schema) {
 
   const spec = FEDERATION_VERSIONS.find(fedFeature.url.version);
   if (!spec) {
-    throw ERRORS.UNKNOWN_FEDERATION_LINK_VERSION.err({
+    return [ERRORS.UNKNOWN_FEDERATION_LINK_VERSION.err({
       message: `Invalid version ${fedFeature.url.version} for the federation feature in @link direction on schema`,
       nodes: fedFeature.directive.sourceAST
-    });
+    })];
   }
 
-  spec.addElementsToSchema(schema);
+  return spec.addElementsToSchema(schema);
 }
 
 export function parseFieldSetArgument({