@apollo/federation-internals 2.1.4 → 2.2.1

package/src/federation.ts

@@ -7,6 +7,7 @@ import {
   Directive,
   DirectiveDefinition,
   ErrGraphQLValidationFailed,
+  Extension,
   FieldDefinition,
   InputFieldDefinition,
   InterfaceType,
@@ -27,7 +28,7 @@ import {
   sourceASTs,
   UnionType,
 } from "./definitions";
-import { assert, joinStrings, MultiMap, printHumanReadableList, OrderedMap } from "./utils";
+import { assert, joinStrings, MultiMap, printHumanReadableList, OrderedMap, mapValues } from "./utils";
 import { SDLValidationRule } from "graphql/validation/ValidationContext";
 import { specifiedSDLRules } from "graphql/validation/specifiedRules";
 import {
@@ -46,7 +47,6 @@ 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,
@@ -69,18 +69,10 @@ import {
 import {
   FEDERATION_VERSIONS,
   federationIdentity,
-  fieldSetTypeSpec,
-  keyDirectiveSpec,
-  requiresDirectiveSpec,
-  providesDirectiveSpec,
-  externalDirectiveSpec,
-  extendsDirectiveSpec,
-  shareableDirectiveSpec,
-  overrideDirectiveSpec,
-  composeDirectiveSpec,
-  FEDERATION2_SPEC_DIRECTIVES,
-  ALL_FEDERATION_DIRECTIVES_DEFAULT_NAMES,
-  FEDERATION2_ONLY_SPEC_DIRECTIVES,
+  FederationDirectiveName,
+  FederationTypeName,
+  FEDERATION1_TYPES,
+  FEDERATION1_DIRECTIVES,
 } from "./federationSpec";
 import { defaultPrintOptions, PrintOptions as PrintOptions, printSchema } from "./print";
 import { createObjectTypeSpecification, createScalarTypeSpecification, createUnionTypeSpecification } from "./directiveAndTypeSpecification";
@@ -88,7 +80,6 @@ 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
@@ -115,6 +106,7 @@ const FEDERATION_SPECIFIC_VALIDATION_RULES = [
 
 const FEDERATION_VALIDATION_RULES = specifiedSDLRules.filter(rule => !FEDERATION_OMITTED_VALIDATION_RULES.includes(rule)).concat(FEDERATION_SPECIFIC_VALIDATION_RULES);
 
+const ALL_DEFAULT_FEDERATION_DIRECTIVE_NAMES: string[] = Object.values(FederationDirectiveName);
 
 function validateFieldSetSelections({
   directiveName,
@@ -157,12 +149,12 @@ function validateFieldSetSelections({
         if (metadata.isFieldFakeExternal(field)) {
           onError(errorCode.err(
             `field "${field.coordinate}" should not be part of a @${directiveName} since it is already "effectively" provided by this subgraph `
-              + `(while it is marked @${externalDirectiveSpec.name}, it is a @${keyDirectiveSpec.name} field of an extension type, which are not internally considered external for historical/backward compatibility reasons)`,
+              + `(while it is marked @${FederationDirectiveName.EXTERNAL}, it is a @${FederationDirectiveName.KEY} field of an extension type, which are not internally considered external for historical/backward compatibility reasons)`,
             { nodes: field.sourceAST }
           ));
         } else {
           onError(errorCode.err(
-            `field "${field.coordinate}" should not be part of a @${directiveName} since it is already provided by this subgraph (it is not marked @${externalDirectiveSpec.name})`,
+            `field "${field.coordinate}" should not be part of a @${directiveName} since it is already provided by this subgraph (it is not marked @${FederationDirectiveName.EXTERNAL})`,
             { nodes: field.sourceAST }
           ));
         }
@@ -488,6 +480,48 @@ function validateInterfaceRuntimeImplementationFieldsTypes(
   }
 }
 
+function validateShareableNotRepeatedOnSameDeclaration(
+  element: ObjectType | FieldDefinition<ObjectType>,
+  metadata: FederationMetadata,
+  errorCollector: GraphQLError[],
+) {
+  const shareableApplications: Directive[] = element.appliedDirectivesOf(metadata.shareableDirective());
+  if (shareableApplications.length <= 1) {
+    return;
+  }
+
+  type ByExtensions = {
+    without: Directive<any, {}>[],
+    with: MultiMap<Extension<any>, Directive<any, {}>>,
+  };
+  const byExtensions = shareableApplications.reduce<ByExtensions>(
+    (acc, v) => {
+      const ext = v.ofExtension();
+      if (ext) {
+        acc.with.add(ext, v);
+      } else {
+        acc.without.push(v);
+      }
+      return acc;
+    },
+    { without: [], with: new MultiMap() }
+  );
+  const groups = [ byExtensions.without ].concat(mapValues(byExtensions.with));
+  for (const group of groups) {
+    if (group.length > 1) {
+      const eltStr = element.kind === 'ObjectType'
+        ? `the same type declaration of "${element.coordinate}"`
+        : `field "${element.coordinate}"`;
+      errorCollector.push(ERRORS.INVALID_SHAREABLE_USAGE.err(
+        `Invalid duplicate application of @shareable on ${eltStr}: `
+        + '@shareable is only repeatable on types so it can be used simultaneously on a type definition and its extensions, but it should not be duplicated on the same definition/extension declaration',
+        { nodes: sourceASTs(...group) },
+      ));
+    }
+  }
+}
+
+
 const printFieldCoordinate = (f: FieldDefinition<CompositeType>): string => `"${f.coordinate}"`;
 
 function formatFieldsToReturnType([type, implems]: [string, FieldDefinition<ObjectType>[]]) {
@@ -607,54 +641,66 @@ export class FederationMetadata {
     }
   }
 
-  private getFederationDirective<TApplicationArgs extends {[key: string]: any}>(
-    name: string
+  // Should only be be called for "legacy" directives, those that existed in 2.0. This
+  // allow to avoiding have to double-check the directive exists every time when we
+  // know it will always exists (note that even though we accept fed1 schema as inputs,
+  // those are almost immediately converted to fed2 ones by the `SchemaUpgrader`, so
+  // we include @shareable or @override in those "legacy" directives).
+  private getLegacyFederationDirective<TApplicationArgs extends {[key: string]: any}>(
+    name: FederationDirectiveName
   ): DirectiveDefinition<TApplicationArgs> {
-    const directive = this.schema.directive(this.federationDirectiveNameInSchema(name));
+    const directive = this.getFederationDirective<TApplicationArgs>(name);
     assert(directive, `The provided schema does not have federation directive @${name}`);
-    return directive as DirectiveDefinition<TApplicationArgs>;
+    return directive;
+  }
+
+  private getFederationDirective<TApplicationArgs extends {[key: string]: any}>(
+    name: FederationDirectiveName
+  ): DirectiveDefinition<TApplicationArgs> | undefined {
+    return this.schema.directive(this.federationDirectiveNameInSchema(name)) as DirectiveDefinition<TApplicationArgs> | undefined;
   }
 
   keyDirective(): DirectiveDefinition<{fields: any, resolvable?: boolean}> {
-    return this.getFederationDirective(keyDirectiveSpec.name);
+    return this.getLegacyFederationDirective(FederationDirectiveName.KEY);
   }
 
   overrideDirective(): DirectiveDefinition<{from: string}> {
-    return this.getFederationDirective(overrideDirectiveSpec.name);
+    return this.getLegacyFederationDirective(FederationDirectiveName.OVERRIDE);
   }
 
   extendsDirective(): DirectiveDefinition<Record<string, never>> {
-    return this.getFederationDirective(extendsDirectiveSpec.name);
+    return this.getLegacyFederationDirective(FederationDirectiveName.EXTENDS);
   }
 
   externalDirective(): DirectiveDefinition<{reason: string}> {
-    return this.getFederationDirective(externalDirectiveSpec.name);
+    return this.getLegacyFederationDirective(FederationDirectiveName.EXTERNAL);
   }
 
   requiresDirective(): DirectiveDefinition<{fields: any}> {
-    return this.getFederationDirective(requiresDirectiveSpec.name);
+    return this.getLegacyFederationDirective(FederationDirectiveName.REQUIRES);
   }
 
   providesDirective(): DirectiveDefinition<{fields: any}> {
-    return this.getFederationDirective(providesDirectiveSpec.name);
+    return this.getLegacyFederationDirective(FederationDirectiveName.PROVIDES);
   }
 
   shareableDirective(): DirectiveDefinition<{}> {
-    return this.getFederationDirective(shareableDirectiveSpec.name);
+    return this.getLegacyFederationDirective(FederationDirectiveName.SHAREABLE);
   }
 
   tagDirective(): DirectiveDefinition<{name: string}> {
-    return this.getFederationDirective(tagSpec.tagDirectiveSpec.name);
+    return this.getLegacyFederationDirective(FederationDirectiveName.TAG);
   }
 
-  composeDirective(): DirectiveDefinition<{name: string}> {
-    return this.getFederationDirective(composeDirectiveSpec.name);
+  composeDirective(): DirectiveDefinition<{name: string}> | FederationDirectiveNotDefinedInSchema<{name: string}> {
+    return this.getFederationDirective<{name: string}>(FederationDirectiveName.COMPOSE_DIRECTIVE) ?? {
+      name: FederationDirectiveName.COMPOSE_DIRECTIVE,
+      applications: () => new Array<Directive<any, {name: string}>>(),
+    };
   }
 
   inaccessibleDirective(): DirectiveDefinition<{}> {
-    return this.getFederationDirective(
-      inaccessibleSpec.inaccessibleDirectiveSpec.name
-    );
+    return this.getLegacyFederationDirective(FederationDirectiveName.INACCESSIBLE);
   }
 
   allFederationDirectives(): DirectiveDefinition[] {
@@ -666,9 +712,18 @@ export class FederationMetadata {
       this.tagDirective(),
       this.extendsDirective(),
     ];
-    return this.isFed2Schema()
-      ? baseDirectives.concat(this.shareableDirective(), this.inaccessibleDirective(), this.overrideDirective(), this.composeDirective())
-      : baseDirectives;
+    if (!this.isFed2Schema()) {
+      return baseDirectives;
+    }
+
+    baseDirectives.push(this.shareableDirective());
+    baseDirectives.push(this.inaccessibleDirective());
+    baseDirectives.push(this.overrideDirective());
+    const composeDirective = this.composeDirective();
+    if (isFederationDirectiveDefinedInSchema(composeDirective)) {
+      baseDirectives.push(composeDirective);
+    }
+    return baseDirectives;
   }
 
   // Note that a subgraph may have no "entities" and so no _EntityType.
@@ -685,7 +740,7 @@ export class FederationMetadata {
   }
 
   fieldSetType(): ScalarType {
-    return this.schema.type(this.federationTypeNameInSchema(fieldSetTypeSpec.name)) as ScalarType;
+    return this.schema.type(this.federationTypeNameInSchema(FederationTypeName.FIELD_SET)) as ScalarType;
   }
 
   allFederationTypes(): NamedType[] {
@@ -702,6 +757,17 @@ export class FederationMetadata {
   }
 }
 
+export type FederationDirectiveNotDefinedInSchema<TApplicationArgs extends {[key: string]: any}> = {
+  name: string,
+  applications: () => readonly Directive<any, TApplicationArgs>[],
+}
+
+export function isFederationDirectiveDefinedInSchema<TApplicationArgs extends {[key: string]: any}>(
+  definition: DirectiveDefinition<TApplicationArgs> | FederationDirectiveNotDefinedInSchema<TApplicationArgs>
+): definition is DirectiveDefinition<TApplicationArgs> {
+  return definition instanceof DirectiveDefinition;
+}
+
 export class FederationBlueprint extends SchemaBlueprint {
   constructor(private readonly withRootTypeRenaming: boolean) {
     super();
@@ -873,6 +939,28 @@ export class FederationBlueprint extends SchemaBlueprint {
       validateInterfaceRuntimeImplementationFieldsTypes(itf, metadata, errorCollector);
     }
 
+    // While @shareable is "repeatable", this is only so one can use it on both a main
+    // type definition _and_ possible other type extensions. But putting 2 @shareable
+    // on the same type definition or field is both useless, and suggest some miscomprehension,
+    // so we reject it with an (hopefully helpful) error message.
+    for (const objectType of schema.objectTypes()) {
+      validateShareableNotRepeatedOnSameDeclaration(objectType, metadata, errorCollector);
+      for (const field of objectType.fields()) {
+        validateShareableNotRepeatedOnSameDeclaration(field, metadata, errorCollector);
+      }
+    }
+    // Additionally, reject using @shareable on an interface field, as that does not actually
+    // make sense.
+    for (const shareableApplication of metadata.shareableDirective().applications()) {
+      const element = shareableApplication.parent;
+      if (element instanceof FieldDefinition && !isObjectType(element.parent)) {
+        errorCollector.push(ERRORS.INVALID_SHAREABLE_USAGE.err(
+          `Invalid use of @shareable on field "${element.coordinate}": only object type fields can be marked with @shareable`,
+          { nodes: sourceASTs(shareableApplication, element.parent) },
+        ));
+      }
+    }
+
     return errorCollector;
   }
 
@@ -883,7 +971,7 @@ export class FederationBlueprint extends SchemaBlueprint {
   onUnknownDirectiveValidationError(schema: Schema, unknownDirectiveName: string, error: GraphQLError): GraphQLError {
     const metadata = federationMetadata(schema);
     assert(metadata, `This method should only have been called on a subgraph schema`)
-    if (ALL_FEDERATION_DIRECTIVES_DEFAULT_NAMES.includes(unknownDirectiveName)) {
+    if (ALL_DEFAULT_FEDERATION_DIRECTIVE_NAMES.includes(unknownDirectiveName)) {
       // The directive name is "unknown" but it is a default federation directive name. So it means one of a few things
       // happened:
       //  1. it's a fed1 schema but the directive is a fed2 only one (only possible case for fed1 schema).
@@ -914,7 +1002,7 @@ export class FederationBlueprint extends SchemaBlueprint {
       }
     } else if (!metadata.isFed2Schema()) {
       // We could get here in the case where a fed1 schema has tried to use a fed2 directive but mispelled it.
-      const suggestions = suggestionList(unknownDirectiveName, FEDERATION2_ONLY_SPEC_DIRECTIVES.map((spec) => spec.name));
+      const suggestions = suggestionList(unknownDirectiveName, ALL_DEFAULT_FEDERATION_DIRECTIVE_NAMES);
       if (suggestions.length > 0) {
         return withModifiedErrorMessage(
           error,
@@ -971,7 +1059,7 @@ export function setSchemaAsFed2Subgraph(schema: Schema) {
     core.coreItself.nameInSchema,
     {
       url: federationSpec.url.toString(),
-      import: FEDERATION2_SPEC_DIRECTIVES.map((spec) => `@${spec.name}`),
+      import: federationSpec.directiveSpecs().map((spec) => `@${spec.name}`),
     }
   );
   const errors = completeSubgraphSchema(schema);
@@ -982,7 +1070,7 @@ export function setSchemaAsFed2Subgraph(schema: Schema) {
 
 // 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.1", import: ["@key", "@requires", "@provides", "@external", "@tag", "@extends", "@shareable", "@inaccessible", "@override", "@composeDirective"])';
+export const FEDERATION2_LINK_WITH_FULL_IMPORTS = '@link(url: "https://specs.apollo.dev/federation/v2.2", import: ["@key", "@requires", "@provides", "@external", "@tag", "@extends", "@shareable", "@inaccessible", "@override", "@composeDirective"])';
 
 export function asFed2SubgraphDocument(document: DocumentNode): DocumentNode {
   const fed2LinkExtension: SchemaExtensionNode = {
@@ -998,7 +1086,7 @@ export function asFed2SubgraphDocument(document: DocumentNode): DocumentNode {
       {
         kind: Kind.ARGUMENT,
         name: { kind: Kind.NAME, value: 'import' },
-        value: { kind: Kind.LIST, values: FEDERATION2_SPEC_DIRECTIVES.map((spec) => ({ kind: Kind.STRING, value: `@${spec.name}` })) }
+        value: { kind: Kind.LIST, values: federationSpec.directiveSpecs().map((spec) => ({ kind: Kind.STRING, value: `@${spec.name}` })) }
       }]
     }]
   };
@@ -1111,8 +1199,8 @@ function completeFed1SubgraphSchema(schema: Schema): GraphQLError[] {
   // Note that, in a perfect world, we'd do this within the `SchemaUpgrader`. But the way the code
   // is organised, this method is called before we reach the `SchemaUpgrader`, and it doesn't seem
   // worth refactoring things drastically for that minor convenience.
-  for (const spec of [keyDirectiveSpec, providesDirectiveSpec, requiresDirectiveSpec]) {
-    const directive = schema.directive(spec.name);
+  for (const name of [FederationDirectiveName.KEY, FederationDirectiveName.PROVIDES, FederationDirectiveName.REQUIRES]) {
+    const directive = schema.directive(name);
     if (!directive) {
       continue;
     }
@@ -1153,15 +1241,9 @@ 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();
+  return FEDERATION1_TYPES.map((spec) => spec.checkOrAdd(schema, '_' + spec.name))
+    .concat(FEDERATION1_DIRECTIVES.map((spec) => spec.checkOrAdd(schema)))
+    .flat();
 }
 
 function completeFed2SubgraphSchema(schema: Schema) {
@@ -1224,7 +1306,7 @@ export function parseFieldSetArgument({
           if (msg.endsWith('.')) {
             msg = msg.slice(0, msg.length - 1);
           }
-          if (directive.name === keyDirectiveSpec.name) {
+          if (directive.name === FederationDirectiveName.KEY) {
             msg = msg + ' (the field should either be added to this subgraph or, if it should not be resolved by this subgraph, you need to add it to this subgraph with @external).';
           } else {
             msg = msg + ' (if the field is defined in another subgraph, you need to add it to this subgraph with @external).';
@@ -1594,11 +1676,13 @@ class ExternalTester {
   private readonly fakeExternalFields = new Set<string>();
   private readonly providedFields = new Set<string>();
   private readonly externalDirective: DirectiveDefinition<{}>;
+  private readonly externalFieldsOnType = new Set<string>();
 
   constructor(readonly schema: Schema) {
     this.externalDirective = this.metadata().externalDirective();
     this.collectFakeExternals();
     this.collectProvidedFields();
+    this.collectExternalsOnType();
   }
 
   private metadata(): FederationMetadata {
@@ -1637,8 +1721,18 @@ class ExternalTester {
     }
   }
 
+  private collectExternalsOnType() {
+    for (const type of this.schema.objectTypes()) {
+      if (type.hasAppliedDirective(this.externalDirective)) {
+        for (const field of type.fields()) {
+          this.externalFieldsOnType.add(field.coordinate);
+        }
+      }
+    }
+  }
+
   isExternal(field: FieldDefinition<any> | InputFieldDefinition) {
-    return field.hasAppliedDirective(this.externalDirective) && !this.isFakeExternal(field);
+    return (field.hasAppliedDirective(this.externalDirective) || this.externalFieldsOnType.has(field.coordinate)) && !this.isFakeExternal(field);
   }
 
   isFakeExternal(field: FieldDefinition<any> | InputFieldDefinition) {

package/src/federationSpec.ts

@@ -9,9 +9,10 @@ import {
   createDirectiveSpecification,
   createScalarTypeSpecification,
   DirectiveSpecification,
+  TypeSpecification,
 } from "./directiveAndTypeSpecification";
 import { DirectiveLocation, GraphQLError } from "graphql";
-import { assert } from "./utils";
+import { assert, MapWithCachedArrays } from "./utils";
 import { TAG_VERSIONS } from "./tagSpec";
 import { federationMetadata } from "./federation";
 import { registerKnownFeature } from "./knownCoreFeatures";
@@ -19,10 +20,27 @@ import { INACCESSIBLE_VERSIONS } from "./inaccessibleSpec";
 
 export const federationIdentity = 'https://specs.apollo.dev/federation';
 
-export const fieldSetTypeSpec = createScalarTypeSpecification({ name: 'FieldSet' });
+export enum FederationTypeName {
+  FIELD_SET = 'FieldSet',
+}
+
+export enum FederationDirectiveName {
+  KEY = 'key',
+  EXTERNAL = 'external',
+  REQUIRES = 'requires',
+  PROVIDES = 'provides',
+  EXTENDS = 'extends',
+  SHAREABLE = 'shareable',
+  OVERRIDE = 'override',
+  TAG = 'tag',
+  INACCESSIBLE = 'inaccessible',
+  COMPOSE_DIRECTIVE = 'composeDirective',
+}
 
-export const keyDirectiveSpec = createDirectiveSpecification({
-  name:'key',
+const fieldSetTypeSpec = createScalarTypeSpecification({ name: FederationTypeName.FIELD_SET });
+
+const keyDirectiveSpec = createDirectiveSpecification({
+  name: FederationDirectiveName.KEY,
   locations: [DirectiveLocation.OBJECT, DirectiveLocation.INTERFACE],
   repeatable: true,
   argumentFct: (schema) => ({
@@ -34,13 +52,13 @@ export const keyDirectiveSpec = createDirectiveSpecification({
   }),
 });
 
-export const extendsDirectiveSpec = createDirectiveSpecification({
-  name:'extends',
+const extendsDirectiveSpec = createDirectiveSpecification({
+  name: FederationDirectiveName.EXTENDS,
   locations: [DirectiveLocation.OBJECT, DirectiveLocation.INTERFACE],
 });
 
-export const externalDirectiveSpec = createDirectiveSpecification({
-  name:'external',
+const externalDirectiveSpec = createDirectiveSpecification({
+  name: FederationDirectiveName.EXTERNAL,
   locations: [DirectiveLocation.OBJECT, DirectiveLocation.FIELD_DEFINITION],
   argumentFct: (schema) => ({
     args: [{ name: 'reason', type: schema.stringType() }],
@@ -48,8 +66,8 @@ export const externalDirectiveSpec = createDirectiveSpecification({
   }),
 });
 
-export const requiresDirectiveSpec = createDirectiveSpecification({
-  name:'requires',
+const requiresDirectiveSpec = createDirectiveSpecification({
+  name: FederationDirectiveName.REQUIRES,
   locations: [DirectiveLocation.FIELD_DEFINITION],
   argumentFct: (schema) => ({
     args: [fieldsArgument(schema)],
@@ -57,8 +75,8 @@ export const requiresDirectiveSpec = createDirectiveSpecification({
   }),
 });
 
-export const providesDirectiveSpec = createDirectiveSpecification({
-  name:'provides',
+const providesDirectiveSpec = createDirectiveSpecification({
+  name: FederationDirectiveName.PROVIDES,
   locations: [DirectiveLocation.FIELD_DEFINITION],
   argumentFct: (schema) => ({
     args: [fieldsArgument(schema)],
@@ -66,29 +84,21 @@ export const providesDirectiveSpec = createDirectiveSpecification({
   }),
 });
 
-export const shareableDirectiveSpec = createDirectiveSpecification({
-  name: 'shareable',
-  locations: [DirectiveLocation.OBJECT, DirectiveLocation.FIELD_DEFINITION],
-});
+const legacyFederationTypes = [
+  fieldSetTypeSpec,
+];
 
-export const overrideDirectiveSpec = createDirectiveSpecification({
-  name: 'override',
-  locations: [DirectiveLocation.FIELD_DEFINITION],
-  argumentFct: (schema) => ({
-    args: [{ name: 'from', type: new NonNullType(schema.stringType()) }],
-    errors: [],
-  }),
-});
+const legacyFederationDirectives = [
+  keyDirectiveSpec,
+  requiresDirectiveSpec,
+  providesDirectiveSpec,
+  externalDirectiveSpec,
+  TAG_VERSIONS.latest().tagDirectiveSpec,
+  extendsDirectiveSpec,
+];
 
-export const composeDirectiveSpec = createDirectiveSpecification({
-  name: 'composeDirective',
-  locations: [DirectiveLocation.SCHEMA],
-  repeatable: true,
-  argumentFct: (schema) => ({
-    args: [{ name: 'name', type: schema.stringType() }],
-    errors: [],
-  }),
-})
+export const FEDERATION1_TYPES = legacyFederationTypes;
+export const FEDERATION1_DIRECTIVES = legacyFederationDirectives;
 
 function fieldsArgument(schema: Schema): ArgumentSpecification {
   return { name: 'fields', type: fieldSetType(schema) };
@@ -100,50 +110,65 @@ function fieldSetType(schema: Schema): InputType {
   return new NonNullType(metadata.fieldSetType());
 }
 
-export const FEDERATION2_ONLY_SPEC_DIRECTIVES = [
-  shareableDirectiveSpec,
-  INACCESSIBLE_VERSIONS.latest().inaccessibleDirectiveSpec,
-  overrideDirectiveSpec,
-];
+export class FederationSpecDefinition extends FeatureDefinition {
+  private readonly _directiveSpecs = new MapWithCachedArrays<string, DirectiveSpecification>();
+  private readonly _typeSpecs = new MapWithCachedArrays<string, TypeSpecification>();
 
-export const FEDERATION2_1_ONLY_SPEC_DIRECTIVES = [
-  composeDirectiveSpec,
-];
+  constructor(version: FeatureVersion) {
+    super(new FeatureUrl(federationIdentity, 'federation', version));
 
-const PRE_FEDERATION2_SPEC_DIRECTIVES = [
-  keyDirectiveSpec,
-  requiresDirectiveSpec,
-  providesDirectiveSpec,
-  externalDirectiveSpec,
-  TAG_VERSIONS.latest().tagDirectiveSpec,
-  extendsDirectiveSpec, // TODO: should we stop supporting that?
-];
+    for (const type of legacyFederationTypes) {
+      this.registerType(type);
+    }
 
-// Note that this is only used for federation 2+ (federation 1 adds the same directive, but not through a core spec).
-export const FEDERATION2_SPEC_DIRECTIVES = [
-  ...PRE_FEDERATION2_SPEC_DIRECTIVES,
-  ...FEDERATION2_ONLY_SPEC_DIRECTIVES,
-  ...FEDERATION2_1_ONLY_SPEC_DIRECTIVES,
-];
+    for (const directive of legacyFederationDirectives) {
+      this.registerDirective(directive);
+    }
 
-// Note that this is meant to contain _all_ federation directive names ever supported, regardless of which version.
-// But currently, fed2 directives are a superset of fed1's so ... (but this may change if we stop supporting `@extends`
-// in fed2).
-export const ALL_FEDERATION_DIRECTIVES_DEFAULT_NAMES = FEDERATION2_SPEC_DIRECTIVES.map((spec) => spec.name);
+    this.registerDirective(createDirectiveSpecification({
+      name: FederationDirectiveName.SHAREABLE,
+      locations: [DirectiveLocation.OBJECT, DirectiveLocation.FIELD_DEFINITION],
+      repeatable: version >= (new FeatureVersion(2, 2)),
+    }));
+
+    this.registerDirective(INACCESSIBLE_VERSIONS.latest().inaccessibleDirectiveSpec);
+
+    this.registerDirective(createDirectiveSpecification({
+      name: FederationDirectiveName.OVERRIDE,
+      locations: [DirectiveLocation.FIELD_DEFINITION],
+      argumentFct: (schema) => ({
+        args: [{ name: 'from', type: new NonNullType(schema.stringType()) }],
+        errors: [],
+      }),
+    }));
+
+    if (version >= (new FeatureVersion(2, 1))) {
+      this.registerDirective(createDirectiveSpecification({
+        name: FederationDirectiveName.COMPOSE_DIRECTIVE,
+        locations: [DirectiveLocation.SCHEMA],
+        repeatable: true,
+        argumentFct: (schema) => ({
+          args: [{ name: 'name', type: schema.stringType() }],
+          errors: [],
+        }),
+      }));
+    }
+  }
 
-export const FEDERATION_SPEC_TYPES = [
-  fieldSetTypeSpec,
-]
+  private registerDirective(spec: DirectiveSpecification) {
+    this._directiveSpecs.set(spec.name, spec);
+  }
 
-export class FederationSpecDefinition extends FeatureDefinition {
-  constructor(version: FeatureVersion) {
-    super(new FeatureUrl(federationIdentity, 'federation', version));
+  private registerType(spec: TypeSpecification) {
+    this._typeSpecs.set(spec.name, spec);
   }
 
-  private allFedDirectives(): DirectiveSpecification[] {
-    return PRE_FEDERATION2_SPEC_DIRECTIVES
-      .concat(FEDERATION2_ONLY_SPEC_DIRECTIVES)
-      .concat(this.url.version >= (new FeatureVersion(2, 1)) ? FEDERATION2_1_ONLY_SPEC_DIRECTIVES : []);
+  directiveSpecs(): readonly DirectiveSpecification[] {
+    return this._directiveSpecs.values();
+  }
+
+  typeSpecs(): readonly TypeSpecification[] {
+    return this._typeSpecs.values();
   }
 
   addElementsToSchema(schema: Schema): GraphQLError[] {
@@ -151,23 +176,25 @@ export class FederationSpecDefinition extends FeatureDefinition {
     assert(feature, 'The federation specification should have been added to the schema before this is called');
 
     let errors: GraphQLError[] = [];
-    errors = errors.concat(this.addTypeSpec(schema, fieldSetTypeSpec));
+    for (const type of this.typeSpecs()) {
+      errors = errors.concat(this.addTypeSpec(schema, type));
+    }
 
-    for (const directive of this.allFedDirectives()) {
+    for (const directive of this.directiveSpecs()) {
       errors = errors.concat(this.addDirectiveSpec(schema, directive));
     }
     return errors;
   }
 
   allElementNames(): string[] {
-    return this.allFedDirectives().map((spec) => `@${spec.name}`).concat([
-      fieldSetTypeSpec.name,
-    ])
+    return this.directiveSpecs().map((spec) => `@${spec.name}`)
+      .concat(this.typeSpecs().map((spec) => spec.name));
   }
 }
 
 export const FEDERATION_VERSIONS = new FeatureDefinitions<FederationSpecDefinition>(federationIdentity)
   .add(new FederationSpecDefinition(new FeatureVersion(2, 0)))
-  .add(new FederationSpecDefinition(new FeatureVersion(2, 1)));
+  .add(new FederationSpecDefinition(new FeatureVersion(2, 1)))
+  .add(new FederationSpecDefinition(new FeatureVersion(2, 2)));
 
 registerKnownFeature(FEDERATION_VERSIONS);