@apollo/federation-internals 2.0.0 → 2.0.2-alpha.1

package/src/error.ts

@@ -183,7 +183,7 @@ const REQUIRES_UNSUPPORTED_ON_INTERFACE = DIRECTIVE_UNSUPPORTED_ON_INTERFACE.cre
 
 const EXTERNAL_UNUSED = makeCodeDefinition(
   'EXTERNAL_UNUSED',
-  'An `@external` field is not being used by any instance of `@key`, `@requires`, `@provides` or to satisfy an interface implememtation.',
+  'An `@external` field is not being used by any instance of `@key`, `@requires`, `@provides` or to satisfy an interface implementation.',
   { addedIn: FED1_CODE },
 );
 
@@ -191,7 +191,7 @@ 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',
+  + ' But when federation 1 schema are automatically migrated to federation 2 ones, unused external fields are automatically 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(
@@ -245,7 +245,7 @@ const NO_QUERIES = makeCodeDefinition(
 
 const INTERFACE_FIELD_NO_IMPLEM = makeCodeDefinition(
   'INTERFACE_FIELD_NO_IMPLEM',
-  'After subgraph merging, an implemenation is missing a field of one of the interface it implements (which can happen for valid subgraphs).'
+  'After subgraph merging, an implementation is missing a field of one of the interface it implements (which can happen for valid subgraphs).'
 );
 
 const TYPE_KIND_MISMATCH = makeCodeDefinition(
@@ -267,12 +267,12 @@ const EXTERNAL_ARGUMENT_MISSING = makeCodeDefinition(
 
 const EXTERNAL_ARGUMENT_TYPE_MISMATCH = makeCodeDefinition(
   'EXTERNAL_ARGUMENT_TYPE_MISMATCH',
-  'An `@external` field declares an argument with a type that is incompatible with the corresponding argument in the declaration(s) of that field in other subgtaphs.',
+  'An `@external` field declares an argument with a type that is incompatible with the corresponding argument in the declaration(s) of that field in other subgraphs.',
 );
 
 const EXTERNAL_ARGUMENT_DEFAULT_MISMATCH = makeCodeDefinition(
   'EXTERNAL_ARGUMENT_DEFAULT_MISMATCH',
-  '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.',
+  '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 subgraphs.',
 );
 
 const EXTERNAL_ON_INTERFACE = makeCodeDefinition(
@@ -510,7 +510,7 @@ const codeDefByCode = Object.values(ERRORS).reduce((obj: {[code: string]: ErrorC
  */
 export const REMOVED_ERRORS = [
   ['KEY_FIELDS_MISSING_ON_BASE', 'Keys can now use any field from any other subgraph.'],
-  ['KEY_FIELDS_MISSING_EXTERNAL', 'Using `@external` for key fields is now decouraged, unless the field is truly meant to be external.'],
+  ['KEY_FIELDS_MISSING_EXTERNAL', 'Using `@external` for key fields is now discouraged, unless the field is truly meant to be external.'],
   ['KEY_MISSING_ON_BASE', 'Each subgraph is now free to declare a key only if it needs it.'],
   ['MULTIPLE_KEYS_ON_EXTENSION', 'Every subgraph can have multiple keys, as necessary.'],
   ['KEY_NOT_SPECIFIED', 'Each subgraph can declare key independently of any other subgraph.'],
@@ -528,5 +528,5 @@ export const REMOVED_ERRORS = [
   ['VALUE_TYPE_NO_ENTITY', 'There is no strong different between entity and value types in the model (they are just usage pattern) and a type can have keys in one subgraph but not another.'],
   ['VALUE_TYPE_UNION_TYPES_MISMATCH', 'Subgraph definitions for an union are now merged by composition'],
   ['PROVIDES_FIELDS_SELECT_INVALID_TYPE', '@provides can now be used on field of interface, union and list types'],
-  ['RESERVED_FIELD_USED', 'This error was previously not correctly enforced: the _service and _entities, if present, were overriden; this is still the case'],
+  ['RESERVED_FIELD_USED', 'This error was previously not correctly enforced: the _service and _entities, if present, were overridden; this is still the case'],
 ];

package/src/extractSubgraphsFromSupergraph.ts

@@ -72,244 +72,269 @@ function collectEmptySubgraphs(supergraph: Schema, joinSpec: JoinSpecDefinition)
   return [subgraphs, graphEnumNameToSubgraphName];
 }
 
+class SubgraphExtractionError {
+  constructor(
+    readonly originalError: any,
+    readonly subgraph: Subgraph,
+  ) {
+  }
+}
+
 export function extractSubgraphsFromSupergraph(supergraph: Schema): Subgraphs {
   const [coreFeatures, joinSpec] = validateSupergraph(supergraph);
   const isFed1 = joinSpec.version.equals(new FeatureVersion(0, 1));
+  try {
+    // We first collect the subgraphs (creating an empty schema that we'll populate next for each).
+    const [subgraphs, graphEnumNameToSubgraphName] = collectEmptySubgraphs(supergraph, joinSpec);
+    const typeDirective = joinSpec.typeDirective(supergraph);
+    const implementsDirective = joinSpec.implementsDirective(supergraph);
 
-  // We first collect the subgraphs (creating an empty schema that we'll populate next for each).
-  const [subgraphs, graphEnumNameToSubgraphName] = collectEmptySubgraphs(supergraph, joinSpec);
-  const typeDirective = joinSpec.typeDirective(supergraph);
-  const implementsDirective = joinSpec.implementsDirective(supergraph);
-
-  // Next, we iterate on all types and add it to the proper subgraphs (along with any @key).
-  // Note that we first add all types empty and populate the types next. This avoids having to care about the iteration
-  // order if we have fields than depends on other types.
-  for (const type of filteredTypes(supergraph, joinSpec, coreFeatures.coreDefinition)) {
-    const typeApplications = type.appliedDirectivesOf(typeDirective);
-    if (!typeApplications.length) {
-      // Imply the type is in all subgraphs (technically, some subgraphs may not have had this type, but adding it
-      // in that case is harmless because it will be unreachable anyway).
-      subgraphs.values().map(sg => sg.schema).forEach(schema => schema.addType(newNamedType(type.kind, type.name)));
-    } else {
-      for (const application of typeApplications) {
-        const args = application.arguments();
-        const subgraphName = graphEnumNameToSubgraphName.get(args.graph)!;
-        const schema = subgraphs.get(subgraphName)!.schema;
-        // We can have more than one type directive for a given subgraph
-        let subgraphType = schema.type(type.name);
-        if (!subgraphType) {
-          subgraphType = schema.addType(newNamedType(type.kind, type.name));
-        }
-        if (args.key) {
-          const { resolvable } = args;
-          const directive = subgraphType.applyDirective('key', {'fields': args.key, resolvable});
-          if (args.extension) {
-            directive.setOfExtension(subgraphType.newExtension());
+    // Next, we iterate on all types and add it to the proper subgraphs (along with any @key).
+    // Note that we first add all types empty and populate the types next. This avoids having to care about the iteration
+    // order if we have fields than depends on other types.
+    for (const type of filteredTypes(supergraph, joinSpec, coreFeatures.coreDefinition)) {
+      const typeApplications = type.appliedDirectivesOf(typeDirective);
+      if (!typeApplications.length) {
+        // Imply the type is in all subgraphs (technically, some subgraphs may not have had this type, but adding it
+        // in that case is harmless because it will be unreachable anyway).
+        subgraphs.values().map(sg => sg.schema).forEach(schema => schema.addType(newNamedType(type.kind, type.name)));
+      } else {
+        for (const application of typeApplications) {
+          const args = application.arguments();
+          const subgraphName = graphEnumNameToSubgraphName.get(args.graph)!;
+          const schema = subgraphs.get(subgraphName)!.schema;
+          // We can have more than one type directive for a given subgraph
+          let subgraphType = schema.type(type.name);
+          if (!subgraphType) {
+            subgraphType = schema.addType(newNamedType(type.kind, type.name));
+          }
+          if (args.key) {
+            const { resolvable } = args;
+            const directive = subgraphType.applyDirective('key', {'fields': args.key, resolvable});
+            if (args.extension) {
+              directive.setOfExtension(subgraphType.newExtension());
+            }
           }
         }
       }
     }
-  }
 
-  const ownerDirective = joinSpec.ownerDirective(supergraph);
-  const fieldDirective = joinSpec.fieldDirective(supergraph);
-  // We can now populate all those types (with relevant @provides and @requires on fields).
-  for (const type of filteredTypes(supergraph, joinSpec, coreFeatures.coreDefinition)) {
-    switch (type.kind) {
-      case 'ObjectType':
-      // @ts-expect-error: we fall-through the inputObjectType for fields.
-      case 'InterfaceType':
-        const addedInterfaces = [];
-        const implementsApplications = implementsDirective ? type.appliedDirectivesOf(implementsDirective) : [];
-        for (const application of implementsApplications) {
-          const args = application.arguments();
-          const subgraph = subgraphs.get(graphEnumNameToSubgraphName.get(args.graph)!)!;
-          const schema = subgraph.schema;
-          (schema.type(type.name)! as (ObjectType | InterfaceType)).addImplementedInterface(args.interface);
-          addedInterfaces.push(args.interface);
-        }
-        for (const implementations of type.interfaceImplementations()) {
-          // If the object/interface implements an interface but we had no @join__implements for it (which will
-          // always be the case for join v0.1 in particular), then that means the object/interface should implement
-          // the interface in all subgraphs (which contains both types).
-          const name = implementations.interface.name;
-          if (!addedInterfaces.includes(name)) {
-            for (const subgraph of subgraphs) {
-              const subgraphType = subgraph.schema.type(type.name);
-              const subgraphItf = subgraph.schema.type(name);
-              if (subgraphType && subgraphItf) {
-                (subgraphType as (ObjectType | InterfaceType)).addImplementedInterface(name);
-              }
-            }
+    const ownerDirective = joinSpec.ownerDirective(supergraph);
+    const fieldDirective = joinSpec.fieldDirective(supergraph);
+    // We can now populate all those types (with relevant @provides and @requires on fields).
+    for (const type of filteredTypes(supergraph, joinSpec, coreFeatures.coreDefinition)) {
+      switch (type.kind) {
+        case 'ObjectType':
+          // @ts-expect-error: we fall-through the inputObjectType for fields.
+        case 'InterfaceType':
+          const addedInterfaces = [];
+          const implementsApplications = implementsDirective ? type.appliedDirectivesOf(implementsDirective) : [];
+          for (const application of implementsApplications) {
+            const args = application.arguments();
+            const subgraph = subgraphs.get(graphEnumNameToSubgraphName.get(args.graph)!)!;
+            const schema = subgraph.schema;
+            (schema.type(type.name)! as (ObjectType | InterfaceType)).addImplementedInterface(args.interface);
+            addedInterfaces.push(args.interface);
           }
-        }
-        // Fall-through on purpose.
-      case 'InputObjectType':
-        for (const field of type.fields()) {
-          const fieldApplications = field.appliedDirectivesOf(fieldDirective);
-          if (!fieldApplications.length) {
-            // The meaning of having no join__field depends on whether the parent type has a join__owner.
-            // If it does, it means the field is only on that owner subgraph. Otherwise, we kind of don't
-            // know, so we add it to all subgraphs that have the parent type and, if the field base type
-            // is a named type, know that field type.
-            const ownerApplications = ownerDirective ? type.appliedDirectivesOf(ownerDirective) : [];
-            if (!ownerApplications.length) {
-              const fieldBaseType = baseType(field.type!);
+          for (const implementations of type.interfaceImplementations()) {
+            // If the object/interface implements an interface but we had no @join__implements for it (which will
+            // always be the case for join v0.1 in particular), then that means the object/interface should implement
+            // the interface in all subgraphs (which contains both types).
+            const name = implementations.interface.name;
+            if (!addedInterfaces.includes(name)) {
               for (const subgraph of subgraphs) {
-                if (subgraph.schema.type(fieldBaseType.name)) {
-                  addSubgraphField(field, subgraph);
+                const subgraphType = subgraph.schema.type(type.name);
+                const subgraphItf = subgraph.schema.type(name);
+                if (subgraphType && subgraphItf) {
+                  (subgraphType as (ObjectType | InterfaceType)).addImplementedInterface(name);
                 }
               }
-            } else {
-              assert(ownerApplications.length == 1, () => `Found multiple join__owner directives on type ${type}`)
-              const subgraph = subgraphs.get(graphEnumNameToSubgraphName.get(ownerApplications[0].arguments().graph)!)!;
-              const subgraphField = addSubgraphField(field, subgraph);
-              assert(subgraphField, () => `Found join__owner directive on ${type} but no corresponding join__type`);
             }
-          } else {
-            for (const application of fieldApplications) {
-              const args = application.arguments();
-              const subgraph = subgraphs.get(graphEnumNameToSubgraphName.get(args.graph)!)!;
-              const subgraphField = addSubgraphField(field, subgraph, args.type);
-              assert(subgraphField, () => `Found join__field directive for graph ${subgraph.name} on field ${field.coordinate} but no corresponding join__type on ${type}`);
-              if (args.requires) {
-                subgraphField.applyDirective(subgraph.metadata().requiresDirective(), {'fields': args.requires});
-              }
-              if (args.provides) {
-                subgraphField.applyDirective(subgraph.metadata().providesDirective(), {'fields': args.provides});
-              }
-              if (args.external) {
-                subgraphField.applyDirective(subgraph.metadata().externalDirective());
-              }
-              if (args.usedOverridden) {
-                subgraphField.applyDirective(subgraph.metadata().externalDirective(), {'reason': '[overridden]'});
+          }
+          // Fall-through on purpose.
+        case 'InputObjectType':
+          for (const field of type.fields()) {
+            const fieldApplications = field.appliedDirectivesOf(fieldDirective);
+            if (!fieldApplications.length) {
+              // The meaning of having no join__field depends on whether the parent type has a join__owner.
+              // If it does, it means the field is only on that owner subgraph. Otherwise, we kind of don't
+              // know, so we add it to all subgraphs that have the parent type and, if the field base type
+              // is a named type, know that field type.
+              const ownerApplications = ownerDirective ? type.appliedDirectivesOf(ownerDirective) : [];
+              if (!ownerApplications.length) {
+                const fieldBaseType = baseType(field.type!);
+                for (const subgraph of subgraphs) {
+                  if (subgraph.schema.type(fieldBaseType.name)) {
+                    addSubgraphField(field, subgraph);
+                  }
+                }
+              } else {
+                assert(ownerApplications.length == 1, () => `Found multiple join__owner directives on type ${type}`)
+                const subgraph = subgraphs.get(graphEnumNameToSubgraphName.get(ownerApplications[0].arguments().graph)!)!;
+                const subgraphField = addSubgraphField(field, subgraph);
+                assert(subgraphField, () => `Found join__owner directive on ${type} but no corresponding join__type`);
               }
-              if (args.override) {
-                subgraphField.applyDirective(subgraph.metadata().overrideDirective(), {'from': args.override});
+            } else {
+              for (const application of fieldApplications) {
+                const args = application.arguments();
+                const subgraph = subgraphs.get(graphEnumNameToSubgraphName.get(args.graph)!)!;
+                const subgraphField = addSubgraphField(field, subgraph, args.type);
+                assert(subgraphField, () => `Found join__field directive for graph ${subgraph.name} on field ${field.coordinate} but no corresponding join__type on ${type}`);
+                if (args.requires) {
+                  subgraphField.applyDirective(subgraph.metadata().requiresDirective(), {'fields': args.requires});
+                }
+                if (args.provides) {
+                  subgraphField.applyDirective(subgraph.metadata().providesDirective(), {'fields': args.provides});
+                }
+                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});
+                }
               }
             }
           }
-        }
-        break;
-      case 'EnumType':
-        // TODO: it's not guaranteed that every enum value was in every subgraph declaring the enum and we should preserve
-        // that info with the join spec. But for now, we add every values to all subgraphs (having the enum)
-        for (const subgraph of subgraphs) {
-          const subgraphEnum = subgraph.schema.type(type.name);
-          if (!subgraphEnum) {
-            continue;
-          }
-          assert(isEnumType(subgraphEnum), () => `${subgraphEnum} should be an enum but found a ${subgraphEnum.kind}`);
-          for (const value of type.values) {
-            subgraphEnum.addValue(value.name);
-          }
-        }
-        break;
-      case 'UnionType':
-        // TODO: Same as for enums. We need to know in which subgraph each member is defined.
-        // But for now, we also add every members to all subgraphs (as long as the subgraph has both the union type
-        // and the member in question).
-        for (const subgraph of subgraphs) {
-          const subgraphUnion = subgraph.schema.type(type.name);
-          if (!subgraphUnion) {
-            continue;
-          }
-          assert(isUnionType(subgraphUnion), () => `${subgraphUnion} should be an enum but found a ${subgraphUnion.kind}`);
-          for (const memberType of type.types()) {
-            const subgraphType = subgraph.schema.type(memberType.name);
-            if (subgraphType) {
-              subgraphUnion.addType(subgraphType as ObjectType);
+          break;
+        case 'EnumType':
+          // TODO: it's not guaranteed that every enum value was in every subgraph declaring the enum and we should preserve
+          // that info with the join spec. But for now, we add every values to all subgraphs (having the enum)
+          for (const subgraph of subgraphs) {
+            const subgraphEnum = subgraph.schema.type(type.name);
+            if (!subgraphEnum) {
+              continue;
+            }
+            assert(isEnumType(subgraphEnum), () => `${subgraphEnum} should be an enum but found a ${subgraphEnum.kind}`);
+            for (const value of type.values) {
+              subgraphEnum.addValue(value.name);
             }
-          }
-        }
-        break;
-    }
-  }
-
-  for (const subgraph of subgraphs) {
-    if (isFed1) {
-      // The join spec in fed1 was not including external fields. Let's make sure we had them or we'll get validation
-      // errors later.
-      addExternalFields(subgraph, supergraph, isFed1);
-    }
-    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
-    // we later might not have added any fields/members to said type, they may be empty (indicating they clearly
-    // didn't belong to the subgraph in the first) and we need to remove them.
-    // Note that need to do this _after_ the `addExternalFields` call above since it may have added (external) fields
-    // to some of the types.
-    for (const type of subgraph.schema.types()) {
-      switch (type.kind) {
-        case 'ObjectType':
-        case 'InterfaceType':
-        case 'InputObjectType':
-          if (!type.hasFields()) {
-            // Note that we have to use removeRecursive or this could leave the subgraph invalid. But if the
-            // type was not in this subgraphs, nothing that depends on it should be either.
-            type.removeRecursive();
           }
           break;
         case 'UnionType':
-          if (type.membersCount() === 0) {
-            type.removeRecursive();
+          // TODO: Same as for enums. We need to know in which subgraph each member is defined.
+          // But for now, we also add every members to all subgraphs (as long as the subgraph has both the union type
+          // and the member in question).
+          for (const subgraph of subgraphs) {
+            const subgraphUnion = subgraph.schema.type(type.name);
+            if (!subgraphUnion) {
+              continue;
+            }
+            assert(isUnionType(subgraphUnion), () => `${subgraphUnion} should be an enum but found a ${subgraphUnion.kind}`);
+            for (const memberType of type.types()) {
+              const subgraphType = subgraph.schema.type(memberType.name);
+              if (subgraphType) {
+                subgraphUnion.addType(subgraphType as ObjectType);
+              }
+            }
           }
           break;
       }
     }
-  }
 
-  // TODO: Not sure that code is needed anymore (any field necessary to validate an interface will have been marked
-  // external)?
-  if (isFed1) {
-    // We now make a pass on every field of every interface and check that all implementers do have that field (even if
-    // external). If not (which can happen because, again, the v0.1 spec had no information on where an interface was
-    // truly defined, so we've so far added them everywhere with all their fields, but some fields may have been part
-    // of an extension and be only in a few subgraphs), we remove the field or the subgraph would be invalid.
     for (const subgraph of subgraphs) {
-      for (const itf of subgraph.schema.interfaceTypes()) {
-        // We only look at objects because interfaces are handled by this own loop in practice.
-        const implementations = itf.possibleRuntimeTypes();
-        for (const field of itf.fields()) {
-          if (!implementations.every(implem => implem.field(field.name))) {
-            field.remove();
-          }
+      if (isFed1) {
+        // The join spec in fed1 was not including external fields. Let's make sure we had them or we'll get validation
+        // errors later.
+        addExternalFields(subgraph, supergraph, isFed1);
+      }
+      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
+      // we later might not have added any fields/members to said type, they may be empty (indicating they clearly
+      // didn't belong to the subgraph in the first) and we need to remove them.
+      // Note that need to do this _after_ the `addExternalFields` call above since it may have added (external) fields
+      // to some of the types.
+      for (const type of subgraph.schema.types()) {
+        switch (type.kind) {
+          case 'ObjectType':
+          case 'InterfaceType':
+          case 'InputObjectType':
+            if (!type.hasFields()) {
+              // Note that we have to use removeRecursive or this could leave the subgraph invalid. But if the
+              // type was not in this subgraphs, nothing that depends on it should be either.
+              type.removeRecursive();
+            }
+            break;
+          case 'UnionType':
+            if (type.membersCount() === 0) {
+              type.removeRecursive();
+            }
+            break;
         }
-        // And it may be that the interface wasn't part of the subgraph at all!
-        if (!itf.hasFields()) {
-          itf.remove();
+      }
+    }
+
+    // TODO: Not sure that code is needed anymore (any field necessary to validate an interface will have been marked
+    // external)?
+    if (isFed1) {
+      // We now make a pass on every field of every interface and check that all implementers do have that field (even if
+      // external). If not (which can happen because, again, the v0.1 spec had no information on where an interface was
+      // truly defined, so we've so far added them everywhere with all their fields, but some fields may have been part
+      // of an extension and be only in a few subgraphs), we remove the field or the subgraph would be invalid.
+      for (const subgraph of subgraphs) {
+        for (const itf of subgraph.schema.interfaceTypes()) {
+          // We only look at objects because interfaces are handled by this own loop in practice.
+          const implementations = itf.possibleRuntimeTypes();
+          for (const field of itf.fields()) {
+            if (!implementations.every(implem => implem.field(field.name))) {
+              field.remove();
+            }
+          }
+          // And it may be that the interface wasn't part of the subgraph at all!
+          if (!itf.hasFields()) {
+            itf.remove();
+          }
         }
       }
     }
-  }
 
-  // We're done with the subgraphs, so call validate (which, amongst other things, sets up the _entities query field, which ensures
-  // 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.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
-      //    containing something invalid that fed1 accepted and fed2 didn't (for instance, an invalid `@provides` selection).
-      // 2. otherwise, this would be a bug (because fed1 compatibility excluded, we shouldn't extract invalid subgraphs from valid supergraphs).
-      // We throw essentially the same thing in both cases, but adapt the message slightly.
-      if (isFed1) {
-        // Note that this could be a bug with the code handling fed1 as well, but it's more helpful to ask users to recompose their subgraphs with fed2 as either
-        // 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 be 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 problems and, once fixed, generate a correct federation 2 supergraph';
-        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)}\n\n${dumpMsg}`);
+    // We're done with the subgraphs, so call validate (which, amongst other things, sets up the _entities query field, which ensures
+    // 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.validate();
+      } catch (e) {
+        // This is going to be caught directly by the enclosing try-catch, but this is so we indicate the subgraph having the issue.
+        throw new SubgraphExtractionError(e, subgraph);
       }
     }
-  }
 
-  return subgraphs;
+    return subgraphs;
+  } catch (e) {
+    let error = e;
+    let subgraph: Subgraph | undefined = undefined;
+    // We want this catch to capture all errors happening during extraction, but the most common
+    // case is likely going to be fed2 validation that fed1 didn't enforced, and those will be
+    // throw when validating the extracted subgraphs, and n that case we use
+    // `SubgraphExtractionError` to pass the subgraph that errored out, which allows us
+    // to provide a bit more context in those cases.
+    if (e instanceof SubgraphExtractionError) {
+      error = e.originalError;
+      subgraph = e.subgraph;
+    }
+
+    // There is 2 reasons this could happen:
+    // 1. if the supergraph is a Fed1 one, because fed2 has stricter validations than fed1, this could be due to the supergraph
+    //    containing something invalid that fed1 accepted and fed2 didn't (for instance, an invalid `@provides` selection).
+    // 2. otherwise, this would be a bug (because fed1 compatibility excluded, we shouldn't extract invalid subgraphs from valid supergraphs).
+    // We throw essentially the same thing in both cases, but adapt the message slightly.
+    const impacted = subgraph ? `subgraph "${subgraph.name}"` : 'subgraphs';
+    if (isFed1) {
+      // Note that this could be a bug with the code handling fed1 as well, but it's more helpful to ask users to recompose their subgraphs with fed2 as either
+      // it'll solve the issue and that's good, or we'll hit the other message anyway.
+      const msg = `Error extracting ${impacted} from the supergraph: this might be 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 problems and, once fixed, generate a correct federation 2 supergraph';
+      throw new Error(`${msg}.\n\nDetails:\n${errorToString(error)}`);
+    } else {
+      const msg = `Unexpected error extracting ${impacted} from the supergraph: this is either a bug, or the supergraph has been corrupted`;
+      const dumpMsg = subgraph ? '\n\n' + maybeDumpSubgraphSchema(subgraph) : '';
+      throw new Error(`${msg}.\n\nDetails:\n${errorToString(error)}${dumpMsg}`);
+    }
+  }
 }
 
 const DEBUG_SUBGRAPHS_ENV_VARIABLE_NAME = 'APOLLO_FEDERATION_DEBUG_SUBGRAPHS';
@@ -401,8 +426,8 @@ function copyType(type: Type, subgraph: Schema, subgraphName: string): Type {
       return new NonNullType(copyType(type.ofType, subgraph, subgraphName) as NullableType);
     default:
       const subgraphType = subgraph.type(type.name);
-      assert(subgraphType, () => `Cannot find type ${type.name} in subgraph ${subgraphName}`);
-      return subgraphType!;
+      assert(subgraphType, () => `Cannot find type "${type.name}" in subgraph "${subgraphName}"`);
+      return subgraphType;
   }
 }
 

package/src/federation.ts

@@ -1013,6 +1013,56 @@ function isFedSpecLinkDirective(directive: Directive<SchemaDefinition>): directi
 }
 
 function completeFed1SubgraphSchema(schema: Schema): GraphQLError[] {
+
+  // We special case @key, @requires and @provides because we've seen existing user schema where those
+  // have been defined in an invalid way, but in a way that fed1 wasn't rejecting. So for convenience,
+  // if we detect one of those case, we just remove the definition and let the code afteward add the
+  // proper definition back.
+  // 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);
+    if (!directive) {
+      continue;
+    }
+
+    // We shouldn't have applications at the time of this writing because `completeSubgraphSchema`, which calls this,
+    // is only called:
+    // 1. during schema parsing, by `FederationBluePrint.onDirectiveDefinitionAndSchemaParsed`, and that is called
+    //   before we process any directive applications.
+    // 2. by `setSchemaAsFed2Subgraph`, but as the name imply, this trickles to `completeFed2SubgraphSchema`, not
+    //   this one method.
+    // In other words, there is currently no way to create a full fed1 schema first, and get that method called
+    // second. If that changes (no real reason but...), we'd have to modify this because when we remove the
+    // definition to re-add the "correct" version, we'd have to re-attach existing applications (doable but not
+    // done). This assert is so we notice it quickly if that ever happens (again, unlikely, because fed1 schema
+    // is a backward compatibility thing and there is no reason to expand that too much in the future).
+    assert(directive.applications().length === 0, `${directive} shouldn't have had validation at that places`);
+
+    // The patterns we recognize and "correct" (by essentially ignoring the definition)
+    // are:
+    //  1. if the definition has no arguments at all.
+    //  2. if the `fields` argument is declared as nullable.
+    //  3. if the `fields` argument type is named "FieldSet" instead of "_FieldSet".
+    //
+    // Note that they all correspong to things we've seen in use schema.
+    const fieldType = directive.argument('fields')?.type?.toString();
+    // Note that to be on the safe side, we check that `fields` is the only argument. That's
+    // because while fed2 accepts the optional `resolvable` arg for @key, fed1 only ever
+    // accepted that one argument for all those directives. But if the use had definited
+    // more arguments _and_ provided value for such extra argument in some applications,
+    // us removing the definition would create validation errors that would be hard to
+    // understand for the user.
+    const fieldTypeIsWrongInKnownWays = !!fieldType
+      && directive.arguments().length === 1
+      && (fieldType === 'String' || fieldType === '_FieldSet' || fieldType === 'FieldSet');
+
+    if (directive.arguments().length === 0 || fieldTypeIsWrongInKnownWays) {
+      directive.remove();
+    }
+  }
+
   return [
     fieldSetTypeSpec.checkOrAdd(schema, '_' + fieldSetTypeSpec.name),
     keyDirectiveSpec.checkOrAdd(schema),