@apollo/federation-internals 2.0.0-preview.7 → 2.0.0

package/src/federation.ts

@@ -45,13 +45,15 @@ 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,
   ERROR_CATEGORIES,
   ERRORS,
+  withModifiedErrorMessage,
 } from "./error";
-import { computeShareables } from "./sharing";
+import { computeShareables } from "./precompute";
 import {
   CoreSpecDefinition,
   FeatureVersion,
@@ -70,14 +72,18 @@ import {
   externalDirectiveSpec,
   extendsDirectiveSpec,
   shareableDirectiveSpec,
-  tagDirectiveSpec,
+  overrideDirectiveSpec,
   FEDERATION2_SPEC_DIRECTIVES,
+  ALL_FEDERATION_DIRECTIVES_DEFAULT_NAMES,
+  FEDERATION2_ONLY_SPEC_DIRECTIVES,
 } from "./federationSpec";
 import { defaultPrintOptions, PrintOptions as PrintOptions, printSchema } from "./print";
 import { createObjectTypeSpecification, createScalarTypeSpecification, createUnionTypeSpecification } from "./directiveAndTypeSpecification";
+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
@@ -86,6 +92,8 @@ const federationSpec = FEDERATION_VERSIONS.latest();
 // disallowing it feels like more a good thing than a real restriction).
 export const FEDERATION_RESERVED_SUBGRAPH_NAME = '_';
 
+export const FEDERATION_UNNAMED_SUBGRAPH_NAME = '<unnamed>';
+
 const FEDERATION_OMITTED_VALIDATION_RULES = [
   // We allow subgraphs to declare an extension even if the subgraph itself doesn't have a corresponding definition.
   // The implication being that the definition is in another subgraph.
@@ -102,6 +110,7 @@ const FEDERATION_SPECIFIC_VALIDATION_RULES = [
 
 const FEDERATION_VALIDATION_RULES = specifiedSDLRules.filter(rule => !FEDERATION_OMITTED_VALIDATION_RULES.includes(rule)).concat(FEDERATION_SPECIFIC_VALIDATION_RULES);
 
+
 // Returns a list of the coordinate of all the fields in the selection that are marked external.
 function validateFieldSetSelections(
   directiveName: string,
@@ -257,53 +266,49 @@ function validateAllFieldSet<TParent extends SchemaElement<any, any>>(
   }
 }
 
-export function collectUsedExternalFieldsCoordinates(metadata: FederationMetadata): Set<string> {
-  const usedExternalCoordinates = new Set<string>();
+export function collectUsedFields(metadata: FederationMetadata): Set<FieldDefinition<CompositeType>> {
+  const usedFields = new Set<FieldDefinition<CompositeType>>();
 
   // Collects all external fields used by a key, requires or provides
-  collectUsedExternaFieldsForDirective<CompositeType>(
-    metadata,
+  collectUsedFieldsForDirective<CompositeType>(
     metadata.keyDirective(),
     type => type,
-    usedExternalCoordinates,
+    usedFields,
   );
-  collectUsedExternaFieldsForDirective<FieldDefinition<CompositeType>>(
-    metadata,
+  collectUsedFieldsForDirective<FieldDefinition<CompositeType>>(
     metadata.requiresDirective(),
     field => field.parent!,
-    usedExternalCoordinates,
+    usedFields,
   );
-  collectUsedExternaFieldsForDirective<FieldDefinition<CompositeType>>(
-    metadata,
+  collectUsedFieldsForDirective<FieldDefinition<CompositeType>>(
     metadata.providesDirective(),
     field => {
       const type = baseType(field.type!);
       return isCompositeType(type) ? type : undefined;
     },
-    usedExternalCoordinates,
+    usedFields,
   );
 
-  // Collects all external fields used to satisfy an interface constraint
-  for (const itfType of metadata.schema.types<InterfaceType>('InterfaceType')) {
+  // Collects all fields used to satisfy an interface constraint
+  for (const itfType of metadata.schema.interfaceTypes()) {
     const runtimeTypes = itfType.possibleRuntimeTypes();
     for (const field of itfType.fields()) {
       for (const runtimeType of runtimeTypes) {
         const implemField = runtimeType.field(field.name);
-        if (implemField && metadata.isFieldExternal(implemField)) {
-          usedExternalCoordinates.add(implemField.coordinate);
+        if (implemField) {
+          usedFields.add(implemField);
         }
       }
     }
   }
 
-  return usedExternalCoordinates;
+  return usedFields;
 }
 
-function collectUsedExternaFieldsForDirective<TParent extends SchemaElement<any, any>>(
-  metadata: FederationMetadata,
+function collectUsedFieldsForDirective<TParent extends SchemaElement<any, any>>(
   definition: DirectiveDefinition<{fields: any}>,
   targetTypeExtractor: (element: TParent) => CompositeType | undefined,
-  usedExternalCoordinates: Set<string>
+  usedFieldDefs: Set<FieldDefinition<CompositeType>>
 ) {
   for (const application of definition.applications()) {
     const type = targetTypeExtractor(application.parent! as TParent);
@@ -321,8 +326,7 @@ function collectUsedExternaFieldsForDirective<TParent extends SchemaElement<any,
       directive: application as Directive<any, {fields: any}>,
       includeInterfaceFieldsImplementations: true,
       validate: false,
-    }).filter((field) => metadata.isFieldExternal(field))
-      .forEach((field) => usedExternalCoordinates.add(field.coordinate));
+    }).forEach((field) => usedFieldDefs.add(field));
   }
 }
 
@@ -331,29 +335,26 @@ function collectUsedExternaFieldsForDirective<TParent extends SchemaElement<any,
  * interface implementation. Otherwise, the field declaration is somewhat useless.
  */
 function validateAllExternalFieldsUsed(metadata: FederationMetadata, errorCollector: GraphQLError[]): void {
-  const allUsedExternals = collectUsedExternalFieldsCoordinates(metadata);
   for (const type of metadata.schema.types()) {
     if (!isObjectType(type) && !isInterfaceType(type)) {
       continue;
     }
     for (const field of type.fields()) {
-      if (!metadata.isFieldExternal(field) || allUsedExternals.has(field.coordinate)) {
+      if (!metadata.isFieldExternal(field) || metadata.isFieldUsed(field)) {
         continue;
       }
 
-      if (!isFieldSatisfyingInterface(field)) {
-        errorCollector.push(ERRORS.EXTERNAL_UNUSED.err({
-          message: `Field "${field.coordinate}" is marked @external but is not used in any federation directive (@key, @provides, @requires) or to satisfy an interface;`
-          + ' the field declaration has no use and should be removed (or the field should not be @external).',
-          nodes: field.sourceAST,
-        }));
-      }
+      errorCollector.push(ERRORS.EXTERNAL_UNUSED.err({
+        message: `Field "${field.coordinate}" is marked @external but is not used in any federation directive (@key, @provides, @requires) or to satisfy an interface;`
+        + ' the field declaration has no use and should be removed (or the field should not be @external).',
+        nodes: field.sourceAST,
+      }));
     }
   }
 }
 
 function validateNoExternalOnInterfaceFields(metadata: FederationMetadata, errorCollector: GraphQLError[]) {
-  for (const itf of metadata.schema.types<InterfaceType>('InterfaceType')) {
+  for (const itf of metadata.schema.interfaceTypes()) {
     for (const field of itf.fields()) {
       if (metadata.isFieldExternal(field)) {
         errorCollector.push(ERRORS.EXTERNAL_ON_INTERFACE.err({
@@ -365,10 +366,6 @@ function validateNoExternalOnInterfaceFields(metadata: FederationMetadata, error
   }
 }
 
-function isFieldSatisfyingInterface(field: FieldDefinition<ObjectType | InterfaceType>): boolean {
-  return field.parent.interfaces().some(itf => itf.field(field.name));
-}
-
 /**
  * Register errors when, for an interface field, some of the implementations of that field are @external
  * _and_ not all of those field implementation have the same type (which otherwise allowed because field
@@ -379,7 +376,7 @@ function isFieldSatisfyingInterface(field: FieldDefinition<ObjectType | Interfac
  */
 function validateInterfaceRuntimeImplementationFieldsTypes(
   itf: InterfaceType,
-  metadata: FederationMetadata, 
+  metadata: FederationMetadata,
   errorCollector: GraphQLError[],
 ): void {
   const requiresDirective = federationMetadata(itf.schema())?.requiresDirective();
@@ -417,19 +414,10 @@ function formatFieldsToReturnType([type, implems]: [string, FieldDefinition<Obje
   return `${joinStrings(implems.map(printFieldCoordinate))} ${implems.length == 1 ? 'has' : 'have'} type "${type}"`;
 }
 
-function checkIfFed2Schema(schema: Schema): boolean {
-  const core = schema.coreFeatures;
-  if (!core) {
-    return false
-  }
-
-  const federationFeature = core.getByIdentity(federationSpec.identity);
-  return !!federationFeature && federationFeature.url.version.satisfies(new FeatureVersion(2, 0));
-}
-
 export class FederationMetadata {
   private _externalTester?: ExternalTester;
   private _sharingPredicate?: (field: FieldDefinition<CompositeType>) => boolean;
+  private _fieldUsedPredicate?: (field: FieldDefinition<CompositeType>) => boolean;
   private _isFed2Schema?: boolean;
 
   constructor(readonly schema: Schema) {
@@ -439,15 +427,21 @@ export class FederationMetadata {
     this._externalTester = undefined;
     this._sharingPredicate = undefined;
     this._isFed2Schema = undefined;
+    this._fieldUsedPredicate = undefined;
   }
 
   isFed2Schema(): boolean {
     if (!this._isFed2Schema) {
-      this._isFed2Schema = checkIfFed2Schema(this.schema);
+      const feature = this.federationFeature();
+      this._isFed2Schema = !!feature && feature.url.version.satisfies(new FeatureVersion(2, 0))
     }
     return this._isFed2Schema;
   }
 
+  federationFeature(): CoreFeature | undefined {
+    return this.schema.coreFeatures?.getByIdentity(federationSpec.identity);
+  }
+
   private externalTester(): ExternalTester {
     if (!this._externalTester) {
       this._externalTester = new ExternalTester(this.schema);
@@ -462,6 +456,18 @@ export class FederationMetadata {
     return this._sharingPredicate;
   }
 
+  private fieldUsedPredicate(): (field: FieldDefinition<CompositeType>) => boolean {
+    if (!this._fieldUsedPredicate) {
+      const usedFields = collectUsedFields(this);
+      this._fieldUsedPredicate = (field: FieldDefinition<CompositeType>) => !!usedFields.has(field);
+    }
+    return this._fieldUsedPredicate;
+  }
+
+  isFieldUsed(field: FieldDefinition<CompositeType>): boolean {
+    return this.fieldUsedPredicate()(field);
+  }
+
   isFieldExternal(field: FieldDefinition<any> | InputFieldDefinition) {
     return this.externalTester().isExternal(field);
   }
@@ -533,11 +539,15 @@ export class FederationMetadata {
     return this.getFederationDirective(keyDirectiveSpec.name);
   }
 
+  overrideDirective(): DirectiveDefinition<{from: string}> {
+    return this.getFederationDirective(overrideDirectiveSpec.name);
+  }
+
   extendsDirective(): DirectiveDefinition<Record<string, never>> {
     return this.getFederationDirective(extendsDirectiveSpec.name);
   }
 
-  externalDirective(): DirectiveDefinition<Record<string, never>> {
+  externalDirective(): DirectiveDefinition<{reason: string}> {
     return this.getFederationDirective(externalDirectiveSpec.name);
   }
 
@@ -554,11 +564,17 @@ export class FederationMetadata {
   }
 
   tagDirective(): DirectiveDefinition<{name: string}> {
-    return this.getFederationDirective(tagDirectiveSpec.name);
+    return this.getFederationDirective(tagSpec.tagDirectiveSpec.name);
+  }
+
+  inaccessibleDirective(): DirectiveDefinition<{}> {
+    return this.getFederationDirective(
+      inaccessibleSpec.inaccessibleDirectiveSpec.name
+    );
   }
 
   allFederationDirectives(): DirectiveDefinition[] {
-    const baseDirectives = [
+    const baseDirectives: DirectiveDefinition[] = [
       this.keyDirective(),
       this.externalDirective(),
       this.requiresDirective(),
@@ -567,7 +583,7 @@ export class FederationMetadata {
       this.extendsDirective(),
     ];
     return this.isFed2Schema()
-      ? baseDirectives.concat(this.shareableDirective())
+      ? baseDirectives.concat(this.shareableDirective(), this.inaccessibleDirective(), this.overrideDirective())
       : baseDirectives;
   }
 
@@ -603,6 +619,10 @@ export class FederationMetadata {
 }
 
 export class FederationBlueprint extends SchemaBlueprint {
+  constructor(private readonly withRootTypeRenaming: boolean) {
+    super();
+  }
+
   onAddedCoreFeature(schema: Schema, feature: CoreFeature) {
     super.onAddedCoreFeature(schema, feature);
     if (feature.url.identity === federationIdentity) {
@@ -613,19 +633,21 @@ export class FederationBlueprint extends SchemaBlueprint {
     }
   }
 
-  onMissingDirectiveDefinition(schema: Schema, name: string): DirectiveDefinition | undefined {
+  onMissingDirectiveDefinition(schema: Schema, name: string, args?: {[key: string]: any}): DirectiveDefinition | GraphQLError[] | undefined {
     if (name === linkDirectiveDefaultName) {
-      linkSpec.addToSchema(schema);
-      return schema.directive(name);
+      const url = args && (args['url'] as string | undefined);
+      const as = url && url.startsWith(linkSpec.identity) ? (args['as'] as string | undefined) : undefined;
+      const errors = linkSpec.addDefinitionsToSchema(schema, as);
+      return errors.length > 0 ? errors : schema.directive(name);
     }
-    return super.onMissingDirectiveDefinition(schema, name);
+    return super.onMissingDirectiveDefinition(schema, name, args);
   }
 
   ignoreParsedField(type: NamedType, fieldName: string): boolean {
     // Historically, federation 1 has accepted invalid schema, including some where the Query type included
     // the definition of `_entities` (so `_entities(representations: [_Any!]!): [_Entity]!`) but _without_
     // defining the `_Any` or `_Entity` type. So while we want to be stricter for fed2 (so this kind of
-    // really weird case can be fixed), we want fed2 to accept as much fed1 schema as possible. 
+    // really weird case can be fixed), we want fed2 to accept as much fed1 schema as possible.
     //
     // So, to avoid this problem, we ignore the _entities and _service fields if we parse them from
     // a fed1 input schema. Those will be added back anyway (along with the proper types) post-parsing.
@@ -643,8 +665,8 @@ export class FederationBlueprint extends SchemaBlueprint {
     }
   }
 
-  onDirectiveDefinitionAndSchemaParsed(schema: Schema) {
-    completeSubgraphSchema(schema);
+  onDirectiveDefinitionAndSchemaParsed(schema: Schema): GraphQLError[] {
+    return completeSubgraphSchema(schema);
   }
 
   onInvalidation(schema: Schema) {
@@ -659,22 +681,24 @@ export class FederationBlueprint extends SchemaBlueprint {
 
     // We rename all root type to their default names (we do here rather than in `prepareValidation` because
     // that can actually fail).
-    for (const k of allSchemaRootKinds) {
-      const type = schema.schemaDefinition.root(k)?.type;
-      const defaultName = defaultRootName(k);
-      if (type && type.name !== defaultName) {
-        // We first ensure there is no other type using the default root name. If there is, this is a
-        // composition error.
-        const existing = schema.type(defaultName);
-        if (existing) {
-          errors.push(ERROR_CATEGORIES.ROOT_TYPE_USED.get(k).err({
-            message: `The schema has a type named "${defaultName}" but it is not set as the ${k} root type ("${type.name}" is instead): `
+    if (this.withRootTypeRenaming) {
+      for (const k of allSchemaRootKinds) {
+        const type = schema.schemaDefinition.root(k)?.type;
+        const defaultName = defaultRootName(k);
+        if (type && type.name !== defaultName) {
+          // We first ensure there is no other type using the default root name. If there is, this is a
+          // composition error.
+          const existing = schema.type(defaultName);
+          if (existing) {
+            errors.push(ERROR_CATEGORIES.ROOT_TYPE_USED.get(k).err({
+              message: `The schema has a type named "${defaultName}" but it is not set as the ${k} root type ("${type.name}" is instead): `
               + 'this is not supported by federation. '
               + 'If a root type does not use its default name, there should be no other type with that default name.',
-            nodes: sourceASTs(type, existing),
-          }));
+              nodes: sourceASTs(type, existing),
+            }));
+          }
+          type.rename(defaultName);
         }
-        type.rename(defaultName);
       }
     }
 
@@ -759,7 +783,7 @@ export class FederationBlueprint extends SchemaBlueprint {
       }
     }
 
-    for (const itf of schema.types<InterfaceType>('InterfaceType')) {
+    for (const itf of schema.interfaceTypes()) {
       validateInterfaceRuntimeImplementationFieldsTypes(itf, metadata, errors);
     }
 
@@ -769,9 +793,52 @@ export class FederationBlueprint extends SchemaBlueprint {
   validationRules(): readonly SDLValidationRule[] {
     return FEDERATION_VALIDATION_RULES;
   }
-}
 
-const federationBlueprint = new FederationBlueprint();
+  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)) {
+      // 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).
+      //  2. the directive has not been imported at all (so needs to be prefixed for it to work).
+      //  3. the directive has an `import`, but it's been aliased to another name.
+      if (metadata.isFed2Schema()) {
+        const federationFeature = metadata.federationFeature();
+        assert(federationFeature, 'Fed2 subgraph _must_ link to the federation feature')
+        const directiveNameInSchema = federationFeature.directiveNameInSchema(unknownDirectiveName);
+        if (directiveNameInSchema.startsWith(federationFeature.nameInSchema + '__')) {
+          // There is no import for that directive
+          return withModifiedErrorMessage(
+            error,
+            `${error.message} If you meant the "@${unknownDirectiveName}" federation directive, you should use fully-qualified name "@${directiveNameInSchema}" or add "@${unknownDirectiveName}" to the \`import\` argument of the @link to the federation specification.`
+          );
+        } else {
+          // There's an import, but it's renamed
+          return withModifiedErrorMessage(
+            error,
+            `${error.message} If you meant the "@${unknownDirectiveName}" federation directive, you should use "@${directiveNameInSchema}" as it is imported under that name in the @link to the federation specification of this schema.`
+          );
+        }
+      } else {
+        return withModifiedErrorMessage(
+          error,
+          `${error.message} If you meant the "@${unknownDirectiveName}" federation 2 directive, note that this schema is a federation 1 schema. To be a federation 2 schema, it needs to @link to the federation specifcation v2.`
+        );
+      }
+    } 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));
+      if (suggestions.length > 0) {
+        return withModifiedErrorMessage(
+          error,
+          `${error.message}${didYouMean(suggestions.map((s) => '@' + s))} If so, note that ${suggestions.length === 1 ? 'it is a federation 2 directive' : 'they are federation 2 directives'} but this schema is a federation 1 one. To be a federation 2 schema, it needs to @link to the federation specifcation v2.`
+        );
+      }
+    }
+    return error;
+  }
+}
 
 function findUnusedNamedForLinkDirective(schema: Schema): string | undefined {
   if (!schema.directive(linkSpec.url.name)) {
@@ -800,7 +867,10 @@ export function setSchemaAsFed2Subgraph(schema: Schema) {
     assert(spec.url.version.satisfies(linkSpec.version), `Fed2 schema must use @link with version >= 1.0, but schema uses ${spec.url}`);
   } else {
     const alias = findUnusedNamedForLinkDirective(schema);
-    linkSpec.addToSchema(schema, alias);
+    const errors = linkSpec.addToSchema(schema, alias);
+    if (errors.length > 0) {
+      throw ErrGraphQLValidationFailed(errors);
+    }
     spec = linkSpec;
     core = schema.coreFeatures;
     assert(core, 'Schema should now be a core schema');
@@ -814,9 +884,16 @@ export function setSchemaAsFed2Subgraph(schema: Schema) {
       import: FEDERATION2_SPEC_DIRECTIVES.map((spec) => `@${spec.name}`),
     }
   );
-  completeSubgraphSchema(schema);
+  const errors = completeSubgraphSchema(schema);
+  if (errors.length > 0) {
+    throw ErrGraphQLValidationFailed(errors);
+  }
 }
 
+// This is the full @link declaration as added by `asFed2SubgraphDocument`. It's here primarily for uses by tests that print and match
+// subgraph schema to avoid having to update 20+ tests every time we use a new directive or the order of import changes ...
+export const FEDERATION2_LINK_WTH_FULL_IMPORTS = '@link(url: "https://specs.apollo.dev/federation/v2.0", import: ["@key", "@requires", "@provides", "@external", "@tag", "@extends", "@shareable", "@inaccessible", "@override"])';
+
 export function asFed2SubgraphDocument(document: DocumentNode): DocumentNode {
   const fed2LinkExtension: SchemaExtensionNode = {
     kind: Kind.SCHEMA_EXTENSION,
@@ -878,10 +955,11 @@ export function isEntityType(type: NamedType): boolean {
 export function buildSubgraph(
   name: string,
   url: string,
-  source: DocumentNode | string
+  source: DocumentNode | string,
+  withRootTypeRenaming: boolean = true,
 ): Subgraph {
   const buildOptions = {
-    blueprint: federationBlueprint,
+    blueprint: new FederationBlueprint(withRootTypeRenaming),
     validate: false,
   };
   let subgraph: Subgraph;
@@ -891,7 +969,7 @@ export function buildSubgraph(
       : buildSchemaFromAST(source, buildOptions)
     subgraph = new Subgraph(name, url, schema);
   } catch (e) {
-    if (e instanceof GraphQLError) {
+    if (e instanceof GraphQLError && name !== FEDERATION_UNNAMED_SUBGRAPH_NAME) {
       throw addSubgraphToError(e, name, ERRORS.INVALID_GRAPHQL);
     } else {
       throw e;
@@ -901,27 +979,30 @@ export function buildSubgraph(
 }
 
 export function newEmptyFederation2Schema(): Schema {
-  const schema = new Schema(federationBlueprint);
+  const schema = new Schema(new FederationBlueprint(true));
   setSchemaAsFed2Subgraph(schema);
   return schema;
 }
 
-function completeSubgraphSchema(schema: Schema) {
+function completeSubgraphSchema(schema: Schema): GraphQLError[] {
   const coreFeatures = schema.coreFeatures;
   if (coreFeatures) {
     const fedFeature = coreFeatures.getByIdentity(federationIdentity);
     if (fedFeature) {
-      completeFed2SubgraphSchema(schema);
+      return completeFed2SubgraphSchema(schema);
     } else {
-      completeFed1SubgraphSchema(schema);
+      return completeFed1SubgraphSchema(schema);
     }
   } else {
     const fedLink = schema.schemaDefinition.appliedDirectivesOf(linkDirectiveDefaultName).find(isFedSpecLinkDirective);
     if (fedLink) {
-      linkSpec.addToSchema(schema);
-      completeFed2SubgraphSchema(schema);
+      const errors = linkSpec.addToSchema(schema);
+      if (errors.length > 0) {
+        return errors;
+      }
+      return completeFed2SubgraphSchema(schema);
     } else {
-      completeFed1SubgraphSchema(schema);
+      return completeFed1SubgraphSchema(schema);
     }
   }
 }
@@ -931,15 +1012,16 @@ function isFedSpecLinkDirective(directive: Directive<SchemaDefinition>): directi
   return directive.name === linkDirectiveDefaultName && args['url'] && (args['url'] as string).startsWith(federationIdentity);
 }
 
-function completeFed1SubgraphSchema(schema: Schema) {
-  fieldSetTypeSpec.checkOrAdd(schema, '_' + fieldSetTypeSpec.name);
-
-  keyDirectiveSpec.checkOrAdd(schema);
-  requiresDirectiveSpec.checkOrAdd(schema);
-  providesDirectiveSpec.checkOrAdd(schema);
-  extendsDirectiveSpec.checkOrAdd(schema);
-  externalDirectiveSpec.checkOrAdd(schema);
-  tagDirectiveSpec.checkOrAdd(schema);
+function completeFed1SubgraphSchema(schema: Schema): GraphQLError[] {
+  return [
+    fieldSetTypeSpec.checkOrAdd(schema, '_' + fieldSetTypeSpec.name),
+    keyDirectiveSpec.checkOrAdd(schema),
+    requiresDirectiveSpec.checkOrAdd(schema),
+    providesDirectiveSpec.checkOrAdd(schema),
+    extendsDirectiveSpec.checkOrAdd(schema),
+    externalDirectiveSpec.checkOrAdd(schema),
+    tagSpec.tagDirectiveSpec.checkOrAdd(schema),
+  ].flat();
 }
 
 function completeFed2SubgraphSchema(schema: Schema) {
@@ -951,13 +1033,13 @@ function completeFed2SubgraphSchema(schema: Schema) {
 
   const spec = FEDERATION_VERSIONS.find(fedFeature.url.version);
   if (!spec) {
-    throw ERRORS.UNKNOWN_FEDERATION_LINK_VERSION.err({
+    return [ERRORS.UNKNOWN_FEDERATION_LINK_VERSION.err({
       message: `Invalid version ${fedFeature.url.version} for the federation feature in @link direction on schema`,
       nodes: fedFeature.directive.sourceAST
-    });
+    })];
   }
 
-  spec.addElementsToSchema(schema);
+  return spec.addElementsToSchema(schema);
 }
 
 export function parseFieldSetArgument({
@@ -1178,7 +1260,7 @@ export const serviceTypeSpec = createObjectTypeSpecification({
 export const entityTypeSpec = createUnionTypeSpecification({
   name: '_Entity',
   membersFct: (schema) => {
-    return schema.types<ObjectType>("ObjectType").filter(isEntityType).map((t) => t.name);
+    return schema.objectTypes().filter(isEntityType).map((t) => t.name);
   },
 });
 
@@ -1239,7 +1321,7 @@ export class Subgraph {
     }
 
     if (!queryType.field(serviceFieldName)) {
-      queryType.addField(serviceFieldName, metadata.serviceType());
+      queryType.addField(serviceFieldName, new NonNullType(metadata.serviceType()));
     }
   }