@apollo/federation-internals 2.0.0-alpha.6 → 2.0.0-preview.2

package/src/directiveAndTypeSpecification.ts

@@ -0,0 +1,276 @@
+import { DirectiveLocation, GraphQLError } from "graphql";
+import {
+  ArgumentDefinition,
+  DirectiveDefinition,
+  InputType,
+  isNonNullType,
+  isObjectType,
+  isUnionType,
+  NamedType,
+  ObjectType,
+  OutputType,
+  ScalarType,
+  Schema,
+  UnionType,
+} from "./definitions";
+import { ERRORS } from "./error";
+import { valueEquals, valueToString } from "./values";
+import { sameType } from "./types";
+import { arrayEquals, assert } from "./utils";
+
+export type DirectiveSpecification = {
+  name: string,
+  checkOrAdd: (schema: Schema, nameInSchema?: string, asBuiltIn?: boolean) => GraphQLError[],
+}
+
+export type TypeSpecification = {
+  name: string,
+  checkOrAdd: (schema: Schema, nameInSchema?: string, asBuiltIn?: boolean) => GraphQLError[],
+}
+
+export type ArgumentSpecification = {
+  name: string,
+  type: InputType,
+  defaultValue?: any,
+}
+
+export type FieldSpecification = {
+  name: string,
+  type: OutputType,
+  args?: ArgumentSpecification[],
+};
+
+export function createDirectiveSpecification({
+  name,
+  locations,
+  repeatable = false,
+  argumentFct = undefined,
+}: {
+  name: string,
+  locations: DirectiveLocation[],
+  repeatable?: boolean,
+  argumentFct?: (schema: Schema) => ArgumentSpecification[],
+}): DirectiveSpecification {
+  return {
+    name,
+    checkOrAdd: (schema: Schema, nameInSchema?: string, asBuiltIn?: boolean) => {
+      const args = argumentFct ? argumentFct(schema) : [];
+      const actualName = nameInSchema ?? name;
+      const existing = schema.directive(actualName);
+      if (existing) {
+        return ensureSameDirectiveStructure({name: actualName, locations, repeatable, args}, existing);
+      } else {
+        const directive = schema.addDirectiveDefinition(new DirectiveDefinition(actualName, asBuiltIn));
+        directive.repeatable = repeatable;
+        directive.addLocations(...locations);
+        for (const { name, type, defaultValue } of args) {
+          directive.addArgument(name, type, defaultValue);
+        }
+        return [];
+      }
+    },
+  }
+}
+
+export function createScalarTypeSpecification({ name }: { name: string }): TypeSpecification {
+  return {
+    name,
+    checkOrAdd: (schema: Schema, nameInSchema?: string, asBuiltIn?: boolean) => {
+      const actualName = nameInSchema ?? name;
+      const existing = schema.type(actualName);
+      if (existing) {
+        return ensureSameTypeKind('ScalarType', existing);
+      } else {
+        schema.addType(new ScalarType(actualName, asBuiltIn));
+        return [];
+      }
+    },
+  }
+}
+
+export function createObjectTypeSpecification({ 
+  name,
+  fieldsFct,
+}: {
+  name: string,
+  fieldsFct: (schema: Schema) => FieldSpecification[],
+}): TypeSpecification {
+  return {
+    name,
+    checkOrAdd: (schema: Schema, nameInSchema?: string, asBuiltIn?: boolean) => {
+      const actualName = nameInSchema ?? name;
+      const expectedFields = fieldsFct(schema);
+      const existing = schema.type(actualName);
+      if (existing) {
+        let errors = ensureSameTypeKind('ObjectType', existing);
+        if (errors.length > 0) {
+          return errors;
+        }
+        assert(isObjectType(existing), 'Should be an object type');
+        for (const { name, type, args } of expectedFields) {
+          const existingField = existing.field(name);
+          if (!existingField) {
+            errors = errors.concat(ERRORS.TYPE_DEFINITION_INVALID.err({
+              message: `Invalid definition of type ${name}: missing field ${name}`,
+              nodes: existing.sourceAST
+            }));
+            continue;
+          }
+          // We allow adding non-nullability because we've seen redefinition of the federation _Service type with type String! for the `sdl` field
+          // and we don't want to break backward compatibility as this doesn't feel too harmful.
+          let existingType = existingField.type!;
+          if (!isNonNullType(type) && isNonNullType(existingType)) {
+            existingType = existingType.ofType;
+          }
+          if (!sameType(type, existingType)) {
+            errors = errors.concat(ERRORS.TYPE_DEFINITION_INVALID.err({
+              message: `Invalid definition for field ${name} of type ${name}: should have type ${type} but found type ${existingField.type}`,
+              nodes: existingField.sourceAST
+            }));
+          }
+          errors = errors.concat(ensureSameArguments(
+            { name, args },
+            existingField,
+            `field ${existingField.coordinate}`,
+          ));
+        }
+        return errors;
+      } else {
+        const createdType = schema.addType(new ObjectType(actualName, asBuiltIn));
+        for (const { name, type, args } of expectedFields) {
+          const field = createdType.addField(name, type);
+          for (const { name: argName, type: argType, defaultValue } of args ?? []) {
+            field.addArgument(argName, argType, defaultValue);
+          }
+        }
+        return [];
+      }
+    },
+  }
+}
+
+export function createUnionTypeSpecification({ 
+  name,
+  membersFct,
+}: {
+  name: string,
+  membersFct: (schema: Schema) => string[],
+}): TypeSpecification {
+  return {
+    name,
+    checkOrAdd: (schema: Schema, nameInSchema?: string, asBuiltIn?: boolean) => {
+      const actualName = nameInSchema ?? name;
+      const existing = schema.type(actualName);
+      const expectedMembers = membersFct(schema).sort((n1, n2) => n1.localeCompare(n2));
+      if (expectedMembers.length === 0) {
+        if (existing) {
+          return [ERRORS.TYPE_DEFINITION_INVALID.err({
+            message: `Invalid definition of type ${name}: expected the union type to not exist/have no members but it is defined.`,
+            nodes: existing.sourceAST
+          })];
+        }
+        return [];
+      }
+      if (existing) {
+        let errors = ensureSameTypeKind('UnionType', existing);
+        if (errors.length > 0) {
+          return errors;
+        }
+        assert(isUnionType(existing), 'Should be an union type');
+        const actualMembers = existing.members().map(m => m.type.name).sort((n1, n2) => n1.localeCompare(n2));
+        // This is kind of fragile in a core schema world where members may have been renamed, but we currently
+        // only use this one for the _Entity type where that shouldn't be an issue.
+        if (!arrayEquals(expectedMembers, actualMembers)) {
+          errors = errors.concat(ERRORS.TYPE_DEFINITION_INVALID.err({
+            message: `Invalid definition of type ${name}: expected members [${expectedMembers}] but found [${actualMembers}].`,
+            nodes: existing.sourceAST
+          }));
+        }
+        return errors;
+      } else {
+        const type = schema.addType(new UnionType(actualName, asBuiltIn));
+        for (const member of expectedMembers) {
+          type.addType(member);
+        }
+        return [];
+      }
+    },
+  }
+}
+
+function ensureSameTypeKind(expected: NamedType['kind'], actual: NamedType): GraphQLError[] {
+  return expected === actual.kind
+    ? []
+    : [ERRORS.TYPE_DEFINITION_INVALID.err({
+      message: `Invalid definition for type ${actual.name}: ${actual.name} should be a ${expected} but is defined as a ${actual.kind}`,
+      nodes: actual.sourceAST
+    })];
+}
+
+function ensureSameDirectiveStructure(
+  expected: {
+    name: string,
+    locations: DirectiveLocation[],
+    repeatable: boolean,
+    args: ArgumentSpecification[]
+  },
+  actual: DirectiveDefinition<any>,
+): GraphQLError[] {
+  let errors = ensureSameArguments(expected, actual, `directive ${expected}`);
+  // 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`,
+      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(', ')}`,
+      nodes: actual.sourceAST
+    }));
+  }
+  return errors;
+}
+
+function ensureSameArguments(
+  expected: {
+    name: string,
+    args?: ArgumentSpecification[]
+  },
+  actual: { argument(name: string): ArgumentDefinition<any> | undefined, arguments(): readonly ArgumentDefinition<any>[] },
+  what: string,
+): 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[] = [];
+  for (const { name, type, defaultValue } of expectedArguments) {
+    const actualArgument = actual.argument(name)!;
+    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
+      // redefine @deprecated as `directive @deprecated(reason: String!)...` to get validation. In other words, you are allowed to always pass an argument that
+      // is optional if you so wish.
+      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!}`,
+        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)}`,
+        nodes: actualArgument.sourceAST
+      }));
+    }
+  }
+  return errors;
+}
+

package/src/error.ts

@@ -110,10 +110,20 @@ const INVALID_GRAPHQL = makeCodeDefinition(
   'A schema is invalid GraphQL: it violates one of the rule of the specification.'
 );
 
-const TAG_DEFINITION_INVALID = makeCodeDefinition(
-  'TAG_DIRECTIVE_DEFINITION_INVALID',
-  'The @tag directive has an invalid defintion in the schema.',
-  { addedIn: FED1_CODE },
+const DIRECTIVE_DEFINITION_INVALID = makeCodeDefinition(
+  'DIRECTIVE_DEFINITION_INVALID',
+  'A built-in or federation directive has an invalid definition in the schema.',
+  { ...DEFAULT_METADATA, replaces: ['TAG_DEFINITION_INVALID'] },
+);
+
+const TYPE_DEFINITION_INVALID = makeCodeDefinition(
+  'TYPE_DEFINITION_INVALID',
+  'A built-in or federation type has an invalid definition in the schema.',
+);
+
+const UNKNOWN_FEDERATION_LINK_VERSION = makeCodeDefinition(
+  'UNKNOWN_FEDERATION_LINK_VERSION',
+  'The version of federation in a @link directive on the schema is unknown.',
 );
 
 const FIELDS_HAS_ARGS = makeFederationDirectiveErrorCodeCategory(
@@ -149,6 +159,13 @@ const EXTERNAL_UNUSED = makeCodeDefinition(
   { addedIn: FED1_CODE },
 );
 
+const TYPE_WITH_ONLY_UNUSED_EXTERNAL = makeCodeDefinition(
+  'TYPE_WITH_ONLY_UNUSED_EXTERNAL',
+  'A federation 1 schema has a composite type comprised only of unused external fields.'
+  + ` Note that this error can _only_ be raised for federation 1 schema as federation 2 schema do not allow unused external fields (and errors with code ${EXTERNAL_UNUSED.code} will be raised in that case).`
+  + ' But when federation 1 schema are automatically migrated to federation 2 ones, unused external fields are automaticaly removed, and in rare case this can leave a type empty. If that happens, an error with this code will be raised',
+);
+
 const PROVIDES_ON_NON_OBJECT_FIELD = makeCodeDefinition(
   'PROVIDES_ON_NON_OBJECT_FIELD',
   'A `@provides` directive is used to mark a field whose base type is not an object type.'
@@ -230,6 +247,11 @@ const EXTERNAL_ARGUMENT_DEFAULT_MISMATCH = makeCodeDefinition(
   'An `@external` field declares an argument with a default that is incompatible with the corresponding argument in the declaration(s) of that field in other subgtaphs.',
 );
 
+const EXTERNAL_ON_INTERFACE = makeCodeDefinition(
+  'EXTERNAL_ON_INTERFACE',
+  'The field of an interface type is marked with `@external`: as external is about marking field not resolved by the subgraph and as interface field are not resolved (only implementations of those fields are), an "external" interface field is nonsensical',
+);
+
 const FIELD_TYPE_MISMATCH = makeCodeDefinition(
   'FIELD_TYPE_MISMATCH',
   'A field has a type that is incompatible with other declarations of that field in other subgraphs.',
@@ -252,6 +274,11 @@ const ARGUMENT_DEFAULT_MISMATCH = makeCodeDefinition(
   'An argument (of a field/directive) has a default value that is incompatible with that of other declarations of that same argument in other subgraphs.',
 );
 
+const NON_REPEATABLE_DIRECTIVE_ARGUMENTS_MISMATCH = makeCodeDefinition(
+  'NON_REPEATABLE_DIRECTIVE_ARGUMENTS_MISMATCH',
+  'A non-repeatable directive is applied to a schema element in different subgraphs but with arguments that are different.',
+);
+
 const EXTENSION_WITH_NO_BASE = makeCodeDefinition(
   'EXTENSION_WITH_NO_BASE',
   'A subgraph is attempting to `extend` a type that is not originally defined in any known subgraph.',
@@ -269,6 +296,21 @@ const INTERFACE_FIELD_IMPLEM_TYPE_MISMATCH = makeCodeDefinition(
   'For an interface field, some of its concrete implementations have @external or @requires and there is difference in those implementations return type (which is currently not supported; see https://github.com/apollographql/federation/issues/1257)'
 );
 
+const INVALID_FIELD_SHARING = makeCodeDefinition(
+  'INVALID_FIELD_SHARING',
+  'A field that is non-shareable in at least one subgraph is resolved by multiple subgraphs.'
+);
+
+const INVALID_LINK_DIRECTIVE_USAGE = makeCodeDefinition(
+  'INVALID_LINK_DIRECTIVE_USAGE',
+  'An application of the @link directive is invalid/does not respect the specification.'
+);
+
+const REQUIRED_ARGUMENT_MISSING_IN_SOME_SUBGRAPH = makeCodeDefinition(
+  'REQUIRED_ARGUMENT_MISSING_IN_SOME_SUBGRAPH',
+  'An argument of a field or directive definition is mandatory in some subgraphs, but the argument is not defined in all subgraphs that define the field or directive definition.'
+);
+
 const SATISFIABILITY_ERROR = makeCodeDefinition(
   'SATISFIABILITY_ERROR',
   'Subgraphs can be merged, but the resulting supergraph API would have queries that cannot be satisfied by those subgraphs.',
@@ -285,7 +327,9 @@ export const ERROR_CATEGORIES = {
 
 export const ERRORS = {
   INVALID_GRAPHQL,
-  TAG_DEFINITION_INVALID,
+  DIRECTIVE_DEFINITION_INVALID,
+  TYPE_DEFINITION_INVALID,
+  UNKNOWN_FEDERATION_LINK_VERSION,
   KEY_FIELDS_HAS_ARGS,
   PROVIDES_FIELDS_HAS_ARGS,
   REQUIRES_FIELDS_HAS_ARGS,
@@ -295,6 +339,7 @@ export const ERRORS = {
   PROVIDES_UNSUPPORTED_ON_INTERFACE,
   REQUIRES_UNSUPPORTED_ON_INTERFACE,
   EXTERNAL_UNUSED,
+  TYPE_WITH_ONLY_UNUSED_EXTERNAL,
   PROVIDES_ON_NON_OBJECT_FIELD,
   KEY_INVALID_FIELDS_TYPE,
   PROVIDES_INVALID_FIELDS_TYPE,
@@ -314,13 +359,18 @@ export const ERRORS = {
   EXTERNAL_ARGUMENT_MISSING,
   EXTERNAL_ARGUMENT_TYPE_MISMATCH,
   EXTERNAL_ARGUMENT_DEFAULT_MISMATCH,
+  EXTERNAL_ON_INTERFACE,
   FIELD_TYPE_MISMATCH,
   ARGUMENT_TYPE_MISMATCH,
   INPUT_FIELD_DEFAULT_MISMATCH,
   ARGUMENT_DEFAULT_MISMATCH,
+  NON_REPEATABLE_DIRECTIVE_ARGUMENTS_MISMATCH,
   EXTENSION_WITH_NO_BASE,
   EXTERNAL_MISSING_ON_BASE,
   INTERFACE_FIELD_IMPLEM_TYPE_MISMATCH,
+  INVALID_FIELD_SHARING,
+  INVALID_LINK_DIRECTIVE_USAGE,
+  REQUIRED_ARGUMENT_MISSING_IN_SOME_SUBGRAPH,
   SATISFIABILITY_ERROR,
 };
 

package/src/extractSubgraphsFromSupergraph.ts

@@ -19,20 +19,23 @@ import {
   Schema,
   Type,
 } from "./definitions";
-import { addSubgraphToError, externalDirectiveName, federationBuiltIns, parseFieldSetArgument } from "./federation";
+import {
+  newEmptyFederation2Schema,
+  parseFieldSetArgument,
+  removeInactiveProvidesAndRequires,
+} from "./federation";
 import { CoreSpecDefinition, FeatureVersion } from "./coreSpec";
 import { JoinSpecDefinition } from "./joinSpec";
-import { Subgraph, Subgraphs } from "./federation";
+import { FederationMetadata, Subgraph, Subgraphs } from "./federation";
 import { assert } from "./utils";
 import { validateSupergraph } from "./supergraphs";
 import { builtTypeReference } from "./buildSchema";
-import { GraphQLError } from "graphql";
-import { selectionOfElement, SelectionSet } from "./operations";
 import { isSubtype } from "./types";
 import { printSchema } from "./print";
 import fs from 'fs';
 import path from 'path';
 import { validateStringContainsBoolean } from "./utils";
+import { errorCauses, printErrors } from ".";
 
 function filteredTypes(
   supergraph: Schema,
@@ -62,7 +65,7 @@ function collectEmptySubgraphs(supergraph: Schema, joinSpec: JoinSpecDefinition)
       throw new Error(`Value ${value} of join__Graph enum has no @join__graph directive`);
     }
     const info = graphApplications[0].arguments();
-    const subgraph = new Subgraph(info.name, info.url, new Schema(federationBuiltIns), false);
+    const subgraph = new Subgraph(info.name, info.url, newEmptyFederation2Schema());
     subgraphs.add(subgraph);
     graphEnumNameToSubgraphName.set(value.name, info.name);
   }
@@ -98,7 +101,8 @@ export function extractSubgraphsFromSupergraph(supergraph: Schema): Subgraphs {
           subgraphType = schema.addType(newNamedType(type.kind, type.name));
         }
         if (args.key) {
-          const directive = subgraphType.applyDirective('key', {'fields': args.key});
+          const { resolvable } = args;
+          const directive = subgraphType.applyDirective('key', {'fields': args.key, resolvable});
           if (args.extension) {
             directive.setOfExtension(subgraphType.newExtension());
           }
@@ -169,13 +173,13 @@ export function extractSubgraphsFromSupergraph(supergraph: Schema): Subgraphs {
               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 (args.requires) {
-                subgraphField.applyDirective('requires', {'fields': args.requires});
+                subgraphField.applyDirective(subgraph.metadata().requiresDirective(), {'fields': args.requires});
               }
               if (args.provides) {
-                subgraphField.applyDirective('provides', {'fields': args.provides});
+                subgraphField.applyDirective(subgraph.metadata().providesDirective(), {'fields': args.provides});
               }
               if (args.external) {
-                subgraphField.applyDirective('external');
+                subgraphField.applyDirective(subgraph.metadata().externalDirective());
               }
             }
           }
@@ -222,7 +226,7 @@ export function extractSubgraphsFromSupergraph(supergraph: Schema): Subgraphs {
       // errors later.
       addExternalFields(subgraph, supergraph, isFed1);
     }
-    removeNeedlessProvides(subgraph);
+    removeInactiveProvidesAndRequires(subgraph.schema);
 
     // We now do an additional path on all types because we sometimes added types to subgraphs without
     // being sure that the subgraph had the type in the first place (especially with the 0.1 join spec), and because
@@ -278,7 +282,7 @@ export function extractSubgraphsFromSupergraph(supergraph: Schema): Subgraphs {
   // all entities in all subgraphs are reachable from a query and so are properly included in the "query graph" later).
   for (const subgraph of subgraphs) {
     try {
-      subgraph.schema.validate();
+      subgraph.validate();
     } catch (e) {
       // There is 2 reasons this could happen:
       // 1. if the subgraph is a Fed1 one, because fed2 has stricter validation than fed1, this could be due to the supergraph having been generated by fed1 and
@@ -290,11 +294,11 @@ export function extractSubgraphsFromSupergraph(supergraph: Schema): Subgraphs {
         // it'll solve the issue and that's good, or we'll hit the other message anyway.
         const msg = `Error extracting subgraph ${subgraph.name} from the supergraph: this might due to errors in subgraphs that were mistakenly ignored by federation 0.x versions but are rejected by federation 2.\n`
           + 'Please try composing your subgraphs with federation 2: this should help precisely pinpoint the errors and generate a correct federation 2 supergraph.';
-        throw new Error(`${msg}.\n\nDetails:\n${errorToString(e, subgraph.name)}`);
+        throw new Error(`${msg}.\n\nDetails:\n${errorToString(e)}`);
       } else {
         const msg = `Unexpected error extracting subgraph ${subgraph.name} from the supergraph: this is either a bug, or the supergraph has been corrupted.`;
         const dumpMsg = maybeDumpSubgraphSchema(subgraph);
-        throw new Error(`${msg}.\n\nDetails:\n${errorToString(e, subgraph.name)}\n\n${dumpMsg}`);
+        throw new Error(`${msg}.\n\nDetails:\n${errorToString(e)}\n\n${dumpMsg}`);
       }
     }
   }
@@ -320,12 +324,13 @@ function maybeDumpSubgraphSchema(subgraph: Subgraph): string {
     return `The (invalid) extracted subgraph has been written in: ${file}.`;
   }
   catch (e2) {
-    return `Was not able to print generated subgraph because: ${errorToString(e2, subgraph.name)}`;
+    return `Was not able to print generated subgraph for "${subgraph.name}" because: ${errorToString(e2)}`;
   }
 }
 
-function errorToString(e: any, subgraphName: string): string {
-  return e instanceof GraphQLError ? addSubgraphToError(e, subgraphName).toString() : String(e);
+function errorToString(e: any,): string {
+  const causes = errorCauses(e);
+  return causes ? printErrors(causes) : String(e);
 }
 
 type AnyField = FieldDefinition<ObjectType | InterfaceType> | InputFieldDefinition;
@@ -396,13 +401,14 @@ function copyType(type: Type, subgraph: Schema, subgraphName: string): Type {
 }
 
 function addExternalFields(subgraph: Subgraph, supergraph: Schema, isFed1: boolean) {
+  const metadata = subgraph.metadata();
   for (const type of subgraph.schema.types()) {
     if (!isObjectType(type) && !isInterfaceType(type)) {
       continue;
     }
 
     // First, handle @key
-    for (const keyApplication of type.appliedDirectivesOf(federationBuiltIns.keyDirective(subgraph.schema))) {
+    for (const keyApplication of type.appliedDirectivesOf(metadata.keyDirective())) {
       // Historically, the federation code for keys, when applied _to a type extension_:
       //  1) required @external on any field of the key
       //  2) but required the subgraph to resolve any field of that key
@@ -428,18 +434,18 @@ function addExternalFields(subgraph: Subgraph, supergraph: Schema, isFed1: boole
     }
     // Then any @requires or @provides on fields
     for (const field of type.fields()) {
-      for (const requiresApplication of field.appliedDirectivesOf(federationBuiltIns.requiresDirective(subgraph.schema))) {
+      for (const requiresApplication of field.appliedDirectivesOf(metadata.requiresDirective())) {
         addExternalFieldsFromDirectiveFieldSet(subgraph, type, requiresApplication, supergraph);
       }
       const fieldBaseType = baseType(field.type!);
-      for (const providesApplication of field.appliedDirectivesOf(federationBuiltIns.providesDirective(subgraph.schema))) {
+      for (const providesApplication of field.appliedDirectivesOf(metadata.providesDirective())) {
         assert(isObjectType(fieldBaseType) || isInterfaceType(fieldBaseType), () => `Found @provides on field ${field.coordinate} whose type ${field.type!} (${fieldBaseType.kind}) is not an object or interface `);
         addExternalFieldsFromDirectiveFieldSet(subgraph, fieldBaseType, providesApplication, supergraph);
       }
     }
 
     // And then any constraint due to implemented interfaces.
-    addExternalFieldsFromInterface(type);
+    addExternalFieldsFromInterface(metadata, type);
   }
 }
 
@@ -450,9 +456,9 @@ function addExternalFieldsFromDirectiveFieldSet(
   supergraph: Schema,
   forceNonExternal: boolean = false,
 ) {
-  const external = federationBuiltIns.externalDirective(subgraph.schema);
+  const external = subgraph.metadata().externalDirective();
 
-  const accessor = function (type: CompositeType, fieldName: string): FieldDefinition<any> {
+  const fieldAccessor = function (type: CompositeType, fieldName: string): FieldDefinition<any> {
     const field = type.field(fieldName);
     if (field) {
       if (forceNonExternal && field.hasAppliedDirective(external)) {
@@ -473,16 +479,16 @@ function addExternalFieldsFromDirectiveFieldSet(
     }
     return created;
   };
-  parseFieldSetArgument(parentType, directive, accessor);
+  parseFieldSetArgument({parentType, directive, fieldAccessor});
 }
 
-function addExternalFieldsFromInterface(type: ObjectType | InterfaceType) {
+function addExternalFieldsFromInterface(metadata: FederationMetadata, type: ObjectType | InterfaceType) {
   for (const itf of type.interfaces()) {
     for (const field of itf.fields()) {
       const typeField = type.field(field.name);
       if (!typeField) {
-        copyFieldAsExternal(field, type);
-      } else if (typeField.hasAppliedDirective(externalDirectiveName)) {
+        copyFieldAsExternal(metadata, field, type);
+      } else if (typeField.hasAppliedDirective(metadata.externalDirective())) {
         // A subtlety here is that a type may implements multiple interfaces providing a given field, and the field may
         // not have the exact same definition in all interface. So if we may have added the field in a previous loop
         // iteration, we need to check if we shouldn't update the field type.
@@ -492,12 +498,12 @@ function addExternalFieldsFromInterface(type: ObjectType | InterfaceType) {
   }
 }
 
-function copyFieldAsExternal(field: FieldDefinition<InterfaceType>, type: ObjectType | InterfaceType) {
+function copyFieldAsExternal(metadata: FederationMetadata, field: FieldDefinition<InterfaceType>, type: ObjectType | InterfaceType) {
   const newField = type.addField(field.name, field.type);
   for (const arg of field.arguments()) {
     newField.addArgument(arg.name, arg.type, arg.defaultValue);
   }
-  newField.applyDirective(externalDirectiveName);
+  newField.applyDirective(metadata.externalDirective());
 }
 
 function maybeUpdateFieldForInterface(toModify: FieldDefinition<ObjectType | InterfaceType>, itfField: FieldDefinition<InterfaceType>) {
@@ -508,93 +514,3 @@ function maybeUpdateFieldForInterface(toModify: FieldDefinition<ObjectType | Int
     toModify.type = itfField.type!;
   }
 }
-
-/*
- *
- * It makes no sense to have a @provides on a non-external leaf field, and we usually reject it during schema
- * validation but we may still have some when:
- * 1. we get a fed 1 supergraph, where such validation hadn't been run.
- * 2. in the special case of key fields of type extensions that are marked @external without being so (see details in
- *    `addExternalFields`). In that case, the validation will not have rejected it.
- *
- * This method checks for those cases and removes such fields (and often the whole @provides). The reason we do
- * it is that such provides have a negative impact on later query planning, because it sometimes make us to
- * try type-exploding some interfaces unnecessarily.
- */
-function removeNeedlessProvides(subgraph: Subgraph) {
-  for (const type of subgraph.schema.types()) {
-    if (!isObjectType(type) && !isInterfaceType(type)) {
-      continue;
-    }
-
-    const providesDirective = federationBuiltIns.providesDirective(subgraph.schema);
-    for (const field of type.fields()) {
-      const fieldBaseType = baseType(field.type!);
-      for (const providesApplication of field.appliedDirectivesOf(providesDirective)) {
-        const selection = parseFieldSetArgument(fieldBaseType as CompositeType, providesApplication);
-        if (selectsNonExternalLeafField(selection)) {
-          providesApplication.remove();
-          const updated = withoutNonExternalLeafFields(selection);
-          if (!updated.isEmpty()) {
-            field.applyDirective(providesDirective, { fields: updated.toString(true, false) });
-          }
-        }
-      }
-    }
-  }
-}
-
-function isExternalOrHasExternalImplementations(field: FieldDefinition<CompositeType>): boolean {
-  if (field.hasAppliedDirective(externalDirectiveName)) {
-    return true;
-  }
-  const parentType = field.parent;
-  if (isInterfaceType(parentType)) {
-    for (const implem of parentType.possibleRuntimeTypes()) {
-      const fieldInImplem = implem.field(field.name);
-      if (fieldInImplem && fieldInImplem.hasAppliedDirective(externalDirectiveName)) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-
-function selectsNonExternalLeafField(selection: SelectionSet): boolean {
-  return selection.selections().some(s => {
-    if (s.kind === 'FieldSelection') {
-      // If it's external, we're good and don't need to recurse.
-      if (isExternalOrHasExternalImplementations(s.field.definition)) {
-        return false;
-      }
-      // Otherwise, we select a non-external if it's a leaf, or the sub-selection does.
-      return !s.selectionSet || selectsNonExternalLeafField(s.selectionSet);
-    } else {
-      return selectsNonExternalLeafField(s.selectionSet);
-    }
-  });
-}
-
-function withoutNonExternalLeafFields(selectionSet: SelectionSet): SelectionSet {
-  const newSelectionSet = new SelectionSet(selectionSet.parentType);
-  for (const selection of selectionSet.selections()) {
-    if (selection.kind === 'FieldSelection') {
-      if (isExternalOrHasExternalImplementations(selection.field.definition)) {
-        // That field is external, so we can add the selection back entirely.
-        newSelectionSet.add(selection);
-        continue;
-      }
-    }
-    // Note that for fragments will always be true (and we just recurse), while
-    // for fields, we'll only get here if the field is not external, and so
-    // we want to add the selection only if it's not a leaf and even then, only
-    // the part where we've recursed.
-    if (selection.selectionSet) {
-      const updated = withoutNonExternalLeafFields(selection.selectionSet);
-      if (!updated.isEmpty()) {
-        newSelectionSet.add(selectionOfElement(selection.element(), updated));
-      }
-    }
-  }
-  return newSelectionSet;
-}