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

package/src/federation.ts

@@ -45,6 +45,7 @@ import { KnownTypeNamesInFederationRule } from "./validation/KnownTypeNamesInFed
 import { buildSchema, buildSchemaFromAST } from "./buildSchema";
 import { parseSelectionSet, selectionOfElement, SelectionSet } from './operations';
 import { TAG_VERSIONS } from "./tagSpec";
+import { INACCESSIBLE_VERSIONS } from "./inaccessibleSpec";
 import {
   errorCodeDef,
   ErrorCodeDefinition,
@@ -52,7 +53,7 @@ import {
   ERRORS,
   withModifiedErrorMessage,
 } from "./error";
-import { computeShareables } from "./sharing";
+import { computeShareables } from "./precompute";
 import {
   CoreSpecDefinition,
   FeatureVersion,
@@ -71,8 +72,7 @@ import {
   externalDirectiveSpec,
   extendsDirectiveSpec,
   shareableDirectiveSpec,
-  tagDirectiveSpec,
-  inaccessibleDirectiveSpec,
+  overrideDirectiveSpec,
   FEDERATION2_SPEC_DIRECTIVES,
   ALL_FEDERATION_DIRECTIVES_DEFAULT_NAMES,
   FEDERATION2_ONLY_SPEC_DIRECTIVES,
@@ -83,6 +83,7 @@ import { didYouMean, suggestionList } from "./suggestions";
 
 const linkSpec = LINK_VERSIONS.latest();
 const tagSpec = TAG_VERSIONS.latest();
+const inaccessibleSpec = INACCESSIBLE_VERSIONS.latest();
 const federationSpec = FEDERATION_VERSIONS.latest();
 
 // We don't let user use this as a subgraph name. That allows us to use it in `query graphs` to name the source of roots
@@ -91,6 +92,8 @@ const federationSpec = FEDERATION_VERSIONS.latest();
 // disallowing it feels like more a good thing than a real restriction).
 export const FEDERATION_RESERVED_SUBGRAPH_NAME = '_';
 
+export const FEDERATION_UNNAMED_SUBGRAPH_NAME = '<unnamed>';
+
 const FEDERATION_OMITTED_VALIDATION_RULES = [
   // We allow subgraphs to declare an extension even if the subgraph itself doesn't have a corresponding definition.
   // The implication being that the definition is in another subgraph.
@@ -263,53 +266,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
-  for (const itfType of metadata.schema.types<InterfaceType>('InterfaceType')) {
+  // Collects all fields used to satisfy an interface constraint
+  for (const itfType of metadata.schema.interfaceTypes()) {
     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 +326,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,29 +335,26 @@ 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,
+      }));
     }
   }
 }
 
 function validateNoExternalOnInterfaceFields(metadata: FederationMetadata, errorCollector: GraphQLError[]) {
-  for (const itf of metadata.schema.types<InterfaceType>('InterfaceType')) {
+  for (const itf of metadata.schema.interfaceTypes()) {
     for (const field of itf.fields()) {
       if (metadata.isFieldExternal(field)) {
         errorCollector.push(ERRORS.EXTERNAL_ON_INTERFACE.err({
@@ -371,10 +366,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 +376,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 +417,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 +427,7 @@ export class FederationMetadata {
     this._externalTester = undefined;
     this._sharingPredicate = undefined;
     this._isFed2Schema = undefined;
+    this._fieldUsedPredicate = undefined;
   }
 
   isFed2Schema(): boolean {
@@ -463,6 +456,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 +539,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,15 +564,17 @@ export class FederationMetadata {
   }
 
   tagDirective(): DirectiveDefinition<{name: string}> {
-    return this.getFederationDirective(tagDirectiveSpec.name);
+    return this.getFederationDirective(tagSpec.tagDirectiveSpec.name);
   }
 
   inaccessibleDirective(): DirectiveDefinition<{}> {
-    return this.getFederationDirective(inaccessibleDirectiveSpec.name);
+    return this.getFederationDirective(
+      inaccessibleSpec.inaccessibleDirectiveSpec.name
+    );
   }
 
   allFederationDirectives(): DirectiveDefinition[] {
-    const baseDirectives = [
+    const baseDirectives: DirectiveDefinition[] = [
       this.keyDirective(),
       this.externalDirective(),
       this.requiresDirective(),
@@ -572,7 +583,7 @@ export class FederationMetadata {
       this.extendsDirective(),
     ];
     return this.isFed2Schema()
-      ? baseDirectives.concat(this.shareableDirective(), this.inaccessibleDirective())
+      ? baseDirectives.concat(this.shareableDirective(), this.inaccessibleDirective(), this.overrideDirective())
       : baseDirectives;
   }
 
@@ -608,6 +619,10 @@ export class FederationMetadata {
 }
 
 export class FederationBlueprint extends SchemaBlueprint {
+  constructor(private readonly withRootTypeRenaming: boolean) {
+    super();
+  }
+
   onAddedCoreFeature(schema: Schema, feature: CoreFeature) {
     super.onAddedCoreFeature(schema, feature);
     if (feature.url.identity === federationIdentity) {
@@ -618,19 +633,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 +665,8 @@ export class FederationBlueprint extends SchemaBlueprint {
     }
   }
 
-  onDirectiveDefinitionAndSchemaParsed(schema: Schema) {
-    completeSubgraphSchema(schema);
+  onDirectiveDefinitionAndSchemaParsed(schema: Schema): GraphQLError[] {
+    return completeSubgraphSchema(schema);
   }
 
   onInvalidation(schema: Schema) {
@@ -664,22 +681,24 @@ export class FederationBlueprint extends SchemaBlueprint {
 
     // We rename all root type to their default names (we do here rather than in `prepareValidation` because
     // that can actually fail).
-    for (const k of allSchemaRootKinds) {
-      const type = schema.schemaDefinition.root(k)?.type;
-      const defaultName = defaultRootName(k);
-      if (type && type.name !== defaultName) {
-        // We first ensure there is no other type using the default root name. If there is, this is a
-        // composition error.
-        const existing = schema.type(defaultName);
-        if (existing) {
-          errors.push(ERROR_CATEGORIES.ROOT_TYPE_USED.get(k).err({
-            message: `The schema has a type named "${defaultName}" but it is not set as the ${k} root type ("${type.name}" is instead): `
+    if (this.withRootTypeRenaming) {
+      for (const k of allSchemaRootKinds) {
+        const type = schema.schemaDefinition.root(k)?.type;
+        const defaultName = defaultRootName(k);
+        if (type && type.name !== defaultName) {
+          // We first ensure there is no other type using the default root name. If there is, this is a
+          // composition error.
+          const existing = schema.type(defaultName);
+          if (existing) {
+            errors.push(ERROR_CATEGORIES.ROOT_TYPE_USED.get(k).err({
+              message: `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.',
-            nodes: sourceASTs(type, existing),
-          }));
+              nodes: sourceASTs(type, existing),
+            }));
+          }
+          type.rename(defaultName);
         }
-        type.rename(defaultName);
       }
     }
 
@@ -764,7 +783,7 @@ export class FederationBlueprint extends SchemaBlueprint {
       }
     }
 
-    for (const itf of schema.types<InterfaceType>('InterfaceType')) {
+    for (const itf of schema.interfaceTypes()) {
       validateInterfaceRuntimeImplementationFieldsTypes(itf, metadata, errors);
     }
 
@@ -788,7 +807,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 +822,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 +831,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.`
         );
       }
@@ -822,8 +840,6 @@ export class FederationBlueprint extends SchemaBlueprint {
   }
 }
 
-const federationBlueprint = new FederationBlueprint();
-
 function findUnusedNamedForLinkDirective(schema: Schema): string | undefined {
   if (!schema.directive(linkSpec.url.name)) {
     return undefined;
@@ -851,7 +867,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 +884,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 = {
@@ -933,10 +955,11 @@ export function isEntityType(type: NamedType): boolean {
 export function buildSubgraph(
   name: string,
   url: string,
-  source: DocumentNode | string
+  source: DocumentNode | string,
+  withRootTypeRenaming: boolean = true,
 ): Subgraph {
   const buildOptions = {
-    blueprint: federationBlueprint,
+    blueprint: new FederationBlueprint(withRootTypeRenaming),
     validate: false,
   };
   let subgraph: Subgraph;
@@ -946,7 +969,7 @@ export function buildSubgraph(
       : buildSchemaFromAST(source, buildOptions)
     subgraph = new Subgraph(name, url, schema);
   } catch (e) {
-    if (e instanceof GraphQLError) {
+    if (e instanceof GraphQLError && name !== FEDERATION_UNNAMED_SUBGRAPH_NAME) {
       throw addSubgraphToError(e, name, ERRORS.INVALID_GRAPHQL);
     } else {
       throw e;
@@ -956,27 +979,30 @@ export function buildSubgraph(
 }
 
 export function newEmptyFederation2Schema(): Schema {
-  const schema = new Schema(federationBlueprint);
+  const schema = new Schema(new FederationBlueprint(true));
   setSchemaAsFed2Subgraph(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 +1012,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 +1033,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({
@@ -1233,7 +1260,7 @@ export const serviceTypeSpec = createObjectTypeSpecification({
 export const entityTypeSpec = createUnionTypeSpecification({
   name: '_Entity',
   membersFct: (schema) => {
-    return schema.types<ObjectType>("ObjectType").filter(isEntityType).map((t) => t.name);
+    return schema.objectTypes().filter(isEntityType).map((t) => t.name);
   },
 });
 
@@ -1294,7 +1321,7 @@ export class Subgraph {
     }
 
     if (!queryType.field(serviceFieldName)) {
-      queryType.addField(serviceFieldName, metadata.serviceType());
+      queryType.addField(serviceFieldName, new NonNullType(metadata.serviceType()));
     }
   }
 

package/src/federationSpec.ts

@@ -9,12 +9,12 @@ import {
   createDirectiveSpecification,
   createScalarTypeSpecification,
 } from "./directiveAndTypeSpecification";
-import { DirectiveLocation } from "graphql";
+import { DirectiveLocation, GraphQLError } from "graphql";
 import { assert } from "./utils";
-import { tagLocations } from "./tagSpec";
+import { TAG_VERSIONS } from "./tagSpec";
 import { federationMetadata } from "./federation";
 import { registerKnownFeature } from "./knownCoreFeatures";
-import { inaccessibleLocations } from "./inaccessibleSpec";
+import { INACCESSIBLE_VERSIONS } from "./inaccessibleSpec";
 
 export const federationIdentity = 'https://specs.apollo.dev/federation';
 
@@ -24,10 +24,13 @@ export const keyDirectiveSpec = createDirectiveSpecification({
   name:'key',
   locations: [DirectiveLocation.OBJECT, DirectiveLocation.INTERFACE],
   repeatable: true,
-  argumentFct: (schema) => [
-    fieldsArgument(schema),
-    { name: 'resolvable', type: schema.booleanType(), defaultValue: true },
-  ]
+  argumentFct: (schema) => ({
+    args: [
+      fieldsArgument(schema),
+      { name: 'resolvable', type: schema.booleanType(), defaultValue: true },
+    ],
+    errors: [],
+  }),
 });
 
 export const extendsDirectiveSpec = createDirectiveSpecification({
@@ -38,22 +41,28 @@ export const extendsDirectiveSpec = createDirectiveSpecification({
 export const externalDirectiveSpec = createDirectiveSpecification({
   name:'external',
   locations: [DirectiveLocation.OBJECT, DirectiveLocation.FIELD_DEFINITION],
+  argumentFct: (schema) => ({
+    args: [{ name: 'reason', type: schema.stringType() }],
+    errors: [],
+  }),
 });
 
 export const requiresDirectiveSpec = createDirectiveSpecification({
   name:'requires',
   locations: [DirectiveLocation.FIELD_DEFINITION],
-  argumentFct: (schema) => {
-    return [fieldsArgument(schema)];
-  }
+  argumentFct: (schema) => ({
+    args: [fieldsArgument(schema)],
+    errors: [],
+  }),
 });
 
 export const providesDirectiveSpec = createDirectiveSpecification({
   name:'provides',
   locations: [DirectiveLocation.FIELD_DEFINITION],
-  argumentFct: (schema) => {
-    return [fieldsArgument(schema)];
-  }
+  argumentFct: (schema) => ({
+    args: [fieldsArgument(schema)],
+    errors: [],
+  }),
 });
 
 export const shareableDirectiveSpec = createDirectiveSpecification({
@@ -61,18 +70,13 @@ export const shareableDirectiveSpec = createDirectiveSpecification({
   locations: [DirectiveLocation.OBJECT, DirectiveLocation.FIELD_DEFINITION],
 });
 
-export const tagDirectiveSpec = createDirectiveSpecification({
-  name:'tag',
-  locations: tagLocations,
-  repeatable: true,
-  argumentFct: (schema) => {
-    return [{ name: 'name', type: new NonNullType(schema.stringType()) }];
-  }
-});
-
-export const inaccessibleDirectiveSpec = createDirectiveSpecification({
-  name:'inaccessible',
-  locations: inaccessibleLocations,
+export const overrideDirectiveSpec = createDirectiveSpecification({
+  name: 'override',
+  locations: [DirectiveLocation.FIELD_DEFINITION],
+  argumentFct: (schema) => ({
+    args: [{ name: 'from', type: new NonNullType(schema.stringType()) }],
+    errors: [],
+  }),
 });
 
 function fieldsArgument(schema: Schema): ArgumentSpecification {
@@ -87,7 +91,8 @@ function fieldSetType(schema: Schema): InputType {
 
 export const FEDERATION2_ONLY_SPEC_DIRECTIVES = [
   shareableDirectiveSpec,
-  inaccessibleDirectiveSpec,
+  INACCESSIBLE_VERSIONS.latest().inaccessibleDirectiveSpec,
+  overrideDirectiveSpec,
 ];
 
 // Note that this is only used for federation 2+ (federation 1 adds the same directive, but not through a core spec).
@@ -96,7 +101,7 @@ export const FEDERATION2_SPEC_DIRECTIVES = [
   requiresDirectiveSpec,
   providesDirectiveSpec,
   externalDirectiveSpec,
-  tagDirectiveSpec,
+  TAG_VERSIONS.latest().tagDirectiveSpec,
   extendsDirectiveSpec, // TODO: should we stop supporting that?
   ...FEDERATION2_ONLY_SPEC_DIRECTIVES,
 ];
@@ -115,15 +120,17 @@ export class FederationSpecDefinition extends FeatureDefinition {
     super(new FeatureUrl(federationIdentity, 'federation', version));
   }
 
-  addElementsToSchema(schema: Schema) {
+  addElementsToSchema(schema: Schema): GraphQLError[] {
     const feature = this.featureInSchema(schema);
     assert(feature, 'The federation specification should have been added to the schema before this is called');
 
-    fieldSetTypeSpec.checkOrAdd(schema, feature.typeNameInSchema(fieldSetTypeSpec.name));
+    let errors: GraphQLError[] = [];
+    errors = errors.concat(this.addTypeSpec(schema, fieldSetTypeSpec));
 
     for (const directive of FEDERATION2_SPEC_DIRECTIVES) {
-      directive.checkOrAdd(schema, feature.directiveNameInSchema(directive.name));
+      errors = errors.concat(this.addDirectiveSpec(schema, directive));
     }
+    return errors;
   }
 
   allElementNames(): string[] {